```   1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
2: /* hack.makemon.c - version 1.0.2 */
3:
4: #include    "hack.h"
5: extern char fut_geno[];
6: extern char *index();
7: extern struct obj *mkobj_at();
8: struct monst zeromonst;
9:
10: /*
11:  * called with [x,y] = coordinates;
12:  *	[0,0] means anyplace
13:  *	[u.ux,u.uy] means: call mnexto (if !in_mklev)
14:  *
15:  *	In case we make an Orc or killer bee, we make an entire horde (swarm);
16:  *	note that in this case we return only one of them (the one at [x,y]).
17:  */
18: struct monst *
19: makemon(ptr,x,y)
20: register struct permonst *ptr;
21: {
22:     register struct monst *mtmp;
23:     register tmp, ct;
24:     boolean anything = (!ptr);
25:
26:     if(x != 0 || y != 0) if(m_at(x,y)) return((struct monst *) 0);
27:     if(ptr){
28:         if(index(fut_geno, ptr->mlet)) return((struct monst *) 0);
29:     } else {
30:         ct = CMNUM - strlen(fut_geno);
31:         if(index(fut_geno, 'm')) ct++;  /* make only 1 minotaur */
32:         if(index(fut_geno, '@')) ct++;
33:         if(ct <= 0) return(0);        /* no more monsters! */
34:         tmp = rn2(ct*dlevel/24 + 7);
35:         if(tmp < dlevel - 4) tmp = rn2(ct*dlevel/24 + 12);
36:         if(tmp >= ct) tmp = rn1(ct - ct/2, ct/2);
37:         for(ct = 0; ct < CMNUM; ct++){
38:             ptr = &mons[ct];
39:             if(index(fut_geno, ptr->mlet))
40:                 continue;
41:             if(!tmp--) goto gotmon;
42:         }
43:         panic("makemon?");
44:     }
45: gotmon:
46:     mtmp = newmonst(ptr->pxlth);
47:     *mtmp = zeromonst;  /* clear all entries in structure */
48:     for(ct = 0; ct < ptr->pxlth; ct++)
49:         ((char *) &(mtmp->mextra[0]))[ct] = 0;
50:     mtmp->nmon = fmon;
51:     fmon = mtmp;
52:     mtmp->m_id = flags.ident++;
53:     mtmp->data = ptr;
54:     mtmp->mxlth = ptr->pxlth;
55:     if(ptr->mlet == 'D') mtmp->mhpmax = mtmp->mhp = 80;
56:     else if(!ptr->mlevel) mtmp->mhpmax = mtmp->mhp = rnd(4);
57:     else mtmp->mhpmax = mtmp->mhp = d(ptr->mlevel, 8);
58:     mtmp->mx = x;
59:     mtmp->my = y;
60:     mtmp->mcansee = 1;
61:     if(ptr->mlet == 'M'){
62:         mtmp->mimic = 1;
63:         mtmp->mappearance = ']';
64:     }
65:     /* FIX -- extended scope off `in_mklev' to cover its following three
66: 		references */
67:     { extern boolean in_mklev;
68:     if(!in_mklev) {
69:         if(x == u.ux && y == u.uy && ptr->mlet != ' ')
70:             mnexto(mtmp);
71:         if(x == 0 && y == 0)
72:             rloc(mtmp);
73:     }
74:     if(ptr->mlet == 's' || ptr->mlet == 'S') {
75:         mtmp->mhide = mtmp->mundetected = 1;
76:         if(in_mklev)
77:         if(mtmp->mx && mtmp->my)
78:             (void) mkobj_at(0, mtmp->mx, mtmp->my);
79:     }
80:     if(ptr->mlet == ':') {
81:         mtmp->cham = 1;
82:         (void) newcham(mtmp, &mons[dlevel+14+rn2(CMNUM-14-dlevel)]);
83:     }
84:     if(ptr->mlet == 'I' || ptr->mlet == ';')
85:         mtmp->minvis = 1;
86:     if(ptr->mlet == 'L' || ptr->mlet == 'N'
87:         || (in_mklev && index("&w;", ptr->mlet) && rn2(5))
88:     ) mtmp->msleep = 1;
89:     }
90: #ifndef NOWORM
91:     if(ptr->mlet == 'w' && getwn(mtmp))
92:         initworm(mtmp);
93: #endif NOWORM
94:
95:     if(anything) if(ptr->mlet == 'O' || ptr->mlet == 'k') {
96:         coord enexto();
97:         coord mm;
98:         register int cnt = rnd(10);
99:         mm.x = x;
100:         mm.y = y;
101:         while(cnt--) {
102:             mm = enexto(mm.x, mm.y);
103:             (void) makemon(ptr, mm.x, mm.y);
104:         }
105:     }
106:
107:     return(mtmp);
108: }
109:
110: coord
111: enexto(xx,yy)
112: register xchar xx,yy;
113: {
114:     register xchar x,y;
115:     coord foo[15], *tfoo;
116:     int range;
117:
118:     tfoo = foo;
119:     range = 1;
120:     do {    /* full kludge action. */
121:         for(x = xx-range; x <= xx+range; x++)
122:             if(goodpos(x, yy-range)) {
123:                 tfoo->x = x;
124:                 tfoo++->y = yy-range;
125:                 if(tfoo == &foo[15]) goto foofull;
126:             }
127:         for(x = xx-range; x <= xx+range; x++)
128:             if(goodpos(x,yy+range)) {
129:                 tfoo->x = x;
130:                 tfoo++->y = yy+range;
131:                 if(tfoo == &foo[15]) goto foofull;
132:             }
133:         for(y = yy+1-range; y < yy+range; y++)
134:             if(goodpos(xx-range,y)) {
135:                 tfoo->x = xx-range;
136:                 tfoo++->y = y;
137:                 if(tfoo == &foo[15]) goto foofull;
138:             }
139:         for(y = yy+1-range; y < yy+range; y++)
140:             if(goodpos(xx+range,y)) {
141:                 tfoo->x = xx+range;
142:                 tfoo++->y = y;
143:                 if(tfoo == &foo[15]) goto foofull;
144:             }
145:         range++;
146:     } while(tfoo == foo);
147: foofull:
148:     return( foo[rn2(tfoo-foo)] );
149: }
150:
151: goodpos(x,y)    /* used only in mnexto and rloc */
152: {
153:     return(
154:     ! (x < 1 || x > COLNO-2 || y < 1 || y > ROWNO-2 ||
155:        m_at(x,y) || !ACCESSIBLE(levl[x][y].typ)
156:        || (x == u.ux && y == u.uy)
157:        || sobj_at(ENORMOUS_ROCK, x, y)
158:     ));
159: }
160:
161: rloc(mtmp)
162: struct monst *mtmp;
163: {
164:     register tx,ty;
165:     register char ch = mtmp->data->mlet;
166:
167: #ifndef NOWORM
168:     if(ch == 'w' && mtmp->mx) return;   /* do not relocate worms */
169: #endif NOWORM
170:     do {
171:         tx = rn1(COLNO-3,2);
172:         ty = rn2(ROWNO);
173:     } while(!goodpos(tx,ty));
174:     mtmp->mx = tx;
175:     mtmp->my = ty;
176:     if(u.ustuck == mtmp){
177:         if(u.uswallow) {
178:             u.ux = tx;
179:             u.uy = ty;
180:             docrt();
181:         } else  u.ustuck = 0;
182:     }
183:     pmon(mtmp);
184: }
185:
186: struct monst *
187: mkmon_at(let,x,y)
188: char let;
189: register int x,y;
190: {
191:     register int ct;
192:     register struct permonst *ptr;
193:
194:     for(ct = 0; ct < CMNUM; ct++) {
195:         ptr = &mons[ct];
196:         if(ptr->mlet == let)
197:             return(makemon(ptr,x,y));
198:     }
199:     return(0);
200: }
```

#### Defined functions

enexto defined in line 110; used 4 times
goodpos defined in line 151; used 6 times
mkmon_at defined in line 186; used 2 times

#### Defined variables

zeromonst defined in line 8; used 1 times
• in line 47
 Last modified: 1985-10-01 Generated: 2016-12-26 Generated by src2html V0.67 page hit count: 2886