?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Nuke unused macro and comment
[dragonfly.git] / games / larn / monster.c
blob6c4859f2b26e89cb6b77f9e987e3dc4eafb3b004
1 /*
2 * monster.c Larn is copyrighted 1986 by Noah Morgan.
3 * $FreeBSD: src/games/larn/monster.c,v 1.6 1999/11/16 11:47:40 marcel Exp $
4 * $DragonFly: src/games/larn/monster.c,v 1.4 2006/08/26 17:05:05 pavalos Exp $
5 *
6 * This file contains the following functions:
7 * ----------------------------------------------------------------------------
8 *
9 * createmonster(monstno) Function to create a monster next to the player
10 * int monstno;
11 *
12 * int cgood(x,y,itm,monst) Function to check location for emptiness
13 * int x,y,itm,monst;
14 *
15 * createitem(it,arg) Routine to place an item next to the player
16 * int it,arg;
17 *
18 * cast() Subroutine called by parse to cast a spell for the user
19 *
20 * speldamage(x) Function to perform spell functions cast by the player
21 * int x;
22 *
23 * loseint() Routine to decrement your int (intelligence) if > 3
24 *
25 * isconfuse() Routine to check to see if player is confused
26 *
27 * nospell(x,monst) Routine to return 1 if a spell doesn't affect a monster
28 * int x,monst;
29 *
30 * fullhit(xx) Function to return full damage against a monst (aka web)
31 * int xx;
32 *
33 * direct(spnum,dam,str,arg) Routine to direct spell damage 1 square in 1 dir
34 * int spnum,dam,arg;
35 * char *str;
36 *
37 * godirect(spnum,dam,str,delay,cshow) Function to perform missile attacks
38 * int spnum,dam,delay;
39 * char *str,cshow;
40 *
41 * ifblind(x,y) Routine to put "monster" or the monster name into lastmosnt
42 * int x,y;
43 *
44 * tdirect(spnum) Routine to teleport away a monster
45 * int spnum;
46 *
47 * omnidirect(sp,dam,str) Routine to damage all monsters 1 square from player
48 * int sp,dam;
49 * char *str;
50 *
51 * dirsub(x,y) Routine to ask for direction, then modify x,y for it
52 * int *x,*y;
53 *
54 * vxy(x,y) Routine to verify/fix (*x,*y) for being within bounds
55 * int *x,*y;
56 *
57 * dirpoly(spnum) Routine to ask for a direction and polymorph a monst
58 * int spnum;
59 *
60 * hitmonster(x,y) Function to hit a monster at the designated coordinates
61 * int x,y;
62 *
63 * hitm(x,y,amt) Function to just hit a monster at a given coordinates
64 * int x,y,amt;
65 *
66 * hitplayer(x,y) Function for the monster to hit the player from (x,y)
67 * int x,y;
68 *
69 * dropsomething(monst) Function to create an object when a monster dies
70 * int monst;
71 *
72 * dropgold(amount) Function to drop some gold around player
73 * int amount;
74 *
75 * something(level) Function to create a random item around player
76 * int level;
77 *
78 * newobject(lev,i) Routine to return a randomly selected new object
79 * int lev,*i;
80 *
81 * spattack(atckno,xx,yy) Function to process special attacks from monsters
82 * int atckno,xx,yy;
83 *
84 * checkloss(x) Routine to subtract hp from user and flag bottomline display
85 * int x;
86 *
87 * annihilate() Routine to annihilate monsters around player, playerx,playery
88 *
89 * newsphere(x,y,dir,lifetime) Function to create a new sphere of annihilation
90 * int x,y,dir,lifetime;
91 *
92 * rmsphere(x,y) Function to delete a sphere of annihilation from list
93 * int x,y;
94 *
95 * sphboom(x,y) Function to perform the effects of a sphere detonation
96 * int x,y;
97 *
98 * genmonst() Function to ask for monster and genocide from game
99 *
100 */
101 #include "header.h"
102
103 struct isave /* used for altar reality */
104 {
105 char type; /* 0=item, 1=monster */
106 char id; /* item number or monster number */
107 short arg; /* the type of item or hitpoints of monster */
108 };
109
110 static int cgood(int, int, int, int);
111 static void speldamage(int);
112 static void loseint(void);
113 static long isconfuse(void);
114 static int nospell(int, int);
115 static int fullhit(int);
116 static void direct(int, int, const char *, int);
117 static void ifblind(int, int);
118 static void tdirect(int);
119 static void omnidirect(int, int, const char *);
120 static int dirsub(int *, int *);
121 static void dirpoly(int);
122 static void dropsomething(int);
123 static int spattack(int, int, int);
124 static void sphboom(int, int);
125 static void genmonst(void);
126
127 /*
128 * createmonster(monstno) Function to create a monster next to the player
129 * int monstno;
130 *
131 * Enter with the monster number (1 to MAXMONST+8)
132 * Returns no value.
133 */
134 void
135 createmonster(int mon)
136 {
137 int x,y,k,i;
138 if (mon<1 || mon>MAXMONST+8) /* check for monster number out of bounds */
139 {
140 beep(); lprintf("\ncan't createmonst(%d)\n",(long)mon); nap(3000); return;
141 }
142 while (monster[mon].genocided && mon<MAXMONST) mon++; /* genocided? */
143 for (k=rnd(8), i= -8; i<0; i++,k++) /* choose direction, then try all */
144 {
145 if (k>8) k=1; /* wraparound the diroff arrays */
146 x = playerx + diroffx[k]; y = playery + diroffy[k];
147 if (cgood(x,y,0,1)) /* if we can create here */
148 {
149 mitem[x][y] = mon;
150 hitp[x][y] = monster[mon].hitpoints;
151 stealth[x][y]=know[x][y]=0;
152 switch(mon)
153 {
154 case ROTHE: case POLTERGEIST: case VAMPIRE: stealth[x][y]=1;
155 };
156 return;
157 }
158 }
159 }
160
161 /*
162 * int cgood(x,y,itm,monst) Function to check location for emptiness
163 * int x,y,itm,monst;
164 *
165 * Routine to return TRUE if a location does not have itm or monst there
166 * returns FALSE (0) otherwise
167 * Enter with itm or monst TRUE or FALSE if checking it
168 * Example: if itm==TRUE check for no item at this location
169 * if monst==TRUE check for no monster at this location
170 * This routine will return FALSE if at a wall or the dungeon exit on level 1
171 */
172 static int
173 cgood(int x, int y, int itm, int monst)
174 {
175 if ((y>=0) && (y<=MAXY-1) && (x>=0) && (x<=MAXX-1)) /* within bounds? */
176 if (item[x][y]!=OWALL) /* can't make anything on walls */
177 if (itm==0 || (item[x][y]==0)) /* is it free of items? */
178 if (monst==0 || (mitem[x][y]==0)) /* is it free of monsters? */
179 if ((level!=1) || (x!=33) || (y!=MAXY-1)) /* not exit to level 1 */
180 return(1);
181 return(0);
182 }
183
184 /*
185 * createitem(it,arg) Routine to place an item next to the player
186 * int it,arg;
187 *
188 * Enter with the item number and its argument (iven[], ivenarg[])
189 * Returns no value, thus we don't know about createitem() failures.
190 */
191 void
192 createitem(int it, int arg)
193 {
194 int x,y,k,i;
195 if (it >= MAXOBJ) return; /* no such object */
196 for (k=rnd(8), i= -8; i<0; i++,k++) /* choose direction, then try all */
197 {
198 if (k>8) k=1; /* wraparound the diroff arrays */
199 x = playerx + diroffx[k]; y = playery + diroffy[k];
200 if (cgood(x,y,1,0)) /* if we can create here */
201 {
202 item[x][y] = it; know[x][y]=0; iarg[x][y]=arg; return;
203 }
204 }
205 }
206
207 /*
208 * cast() Subroutine called by parse to cast a spell for the user
209 *
210 * No arguments and no return value.
211 */
212 static const char eys[] = "\nEnter your spell: ";
213
214 void
215 cast(void)
216 {
217 int i,j,a,b,d;
218 cursors();
219 if (c[SPELLS]<=0) { lprcat("\nYou don't have any spells!"); return; }
220 lprcat(eys); --c[SPELLS];
221 while ((a=getchr())=='D')
222 { seemagic(-1); cursors(); lprcat(eys); }
223 if (a=='\33') goto over; /* to escape casting a spell */
224 if ((b=getchr())=='\33') goto over; /* to escape casting a spell */
225 if ((d=getchr())=='\33')
226 { over: lprcat(aborted); c[SPELLS]++; return; } /* to escape casting a spell */
227 #ifdef EXTRA
228 c[SPELLSCAST]++;
229 #endif
230 for (lprc('\n'),j= -1,i=0; i<SPNUM; i++) /*seq search for his spell, hash?*/
231 if ((spelcode[i][0]==a) && (spelcode[i][1]==b) && (spelcode[i][2]==d))
232 if (spelknow[i])
233 { speldamage(i); j = 1; i=SPNUM; }
234
235 if (j == -1) lprcat(" Nothing Happened ");
236 bottomline();
237 }
238
239 /*
240 * speldamage(x) Function to perform spell functions cast by the player
241 * int x;
242 *
243 * Enter with the spell number, returns no value.
244 * Please insure that there are 2 spaces before all messages here
245 */
246 static void
247 speldamage(int x)
248 {
249 int i,j,clev;
250 int xl,xh,yl,yh;
251 char *p,*kn,*pm;
252 const char *cp;
253 if (x>=SPNUM) return; /* no such spell */
254 if (c[TIMESTOP]) { lprcat(" It didn't seem to work"); return; } /* not if time stopped */
255 clev = c[LEVEL];
256 if ((rnd(23)==7) || (rnd(18) > c[INTELLIGENCE]))
257 { lprcat(" It didn't work!"); return; }
258 if (clev*3+2 < x) { lprcat(" Nothing happens. You seem inexperienced at this"); return; }
259
260 switch(x)
261 {
262 /* ----- LEVEL 1 SPELLS ----- */
263
264 case 0: if (c[PROTECTIONTIME]==0) c[MOREDEFENSES]+=2; /* protection field +2 */
265 c[PROTECTIONTIME] += 250; return;
266
267 case 1: i = rnd(((clev+1)<<1)) + clev + 3;
268 godirect(x,i,(clev>=2)?" Your missiles hit the %s":" Your missile hit the %s",100,'+'); /* magic missile */
269
270 return;
271
272 case 2: if (c[DEXCOUNT]==0) c[DEXTERITY]+=3; /* dexterity */
273 c[DEXCOUNT] += 400; return;
274
275 case 3: i=rnd(3)+1;
276 cp=" While the %s slept, you smashed it %d times";
277 ws: direct(x,fullhit(i),cp,i); /* sleep */ return;
278
279 case 4: /* charm monster */ c[CHARMCOUNT] += c[CHARISMA]<<1; return;
280
281 case 5: godirect(x,rnd(10)+15+clev," The sound damages the %s",70,'@'); /* sonic spear */
282 return;
283
284 /* ----- LEVEL 2 SPELLS ----- */
285
286 case 6: i=rnd(3)+2; cp=" While the %s is entangled, you hit %d times";
287 goto ws; /* web */
288
289 case 7: if (c[STRCOUNT]==0) c[STREXTRA]+=3; /* strength */
290 c[STRCOUNT] += 150+rnd(100); return;
291
292 case 8: yl = playery-5; /* enlightenment */
293 yh = playery+6; xl = playerx-15; xh = playerx+16;
294 vxy(&xl,&yl); vxy(&xh,&yh); /* check bounds */
295 for (i=yl; i<=yh; i++) /* enlightenment */
296 for (j=xl; j<=xh; j++) know[j][i]=1;
297 draws(xl,xh+1,yl,yh+1); return;
298
299 case 9: raisehp(20+(clev<<1)); return; /* healing */
300
301 case 10: c[BLINDCOUNT]=0; return; /* cure blindness */
302
303 case 11: createmonster(makemonst(level+1)+8); return;
304
305 case 12: if (rnd(11)+7 <= c[WISDOM]) direct(x,rnd(20)+20+clev," The %s believed!",0);
306 else lprcat(" It didn't believe the illusions!");
307 return;
308
309 case 13: /* if he has the amulet of invisibility then add more time */
310 for (j=i=0; i<26; i++)
311 if (iven[i]==OAMULET) j+= 1+ivenarg[i];
312 c[INVISIBILITY] += (j<<7)+12; return;
313
314 /* ----- LEVEL 3 SPELLS ----- */
315
316 case 14: godirect(x,rnd(25+clev)+25+clev," The fireball hits the %s",40,'*'); return; /* fireball */
317
318 case 15: godirect(x,rnd(25)+20+clev," Your cone of cold strikes the %s",60,'O'); /* cold */
319 return;
320
321 case 16: dirpoly(x); return; /* polymorph */
322
323 case 17: c[CANCELLATION]+= 5+clev; return; /* cancellation */
324
325 case 18: c[HASTESELF]+= 7+clev; return; /* haste self */
326
327 case 19: omnidirect(x,30+rnd(10)," The %s gasps for air"); /* cloud kill */
328 return;
329
330 case 20: xh = min(playerx+1,MAXX-2); yh = min(playery+1,MAXY-2);
331 for (i=max(playerx-1,1); i<=xh; i++) /* vaporize rock */
332 for (j=max(playery-1,1); j<=yh; j++)
333 {
334 kn = &know[i][j]; pm = &mitem[i][j];
335 switch(*(p= &item[i][j]))
336 {
337 case OWALL: if (level < MAXLEVEL+MAXVLEVEL-1)
338 *p = *kn = 0;
339 break;
340
341 case OSTATUE: if (c[HARDGAME]<3)
342 {
343 *p=OBOOK; iarg[i][j]=level; *kn=0;
344 }
345 break;
346
347 case OTHRONE: *pm=GNOMEKING; *kn=0; *p= OTHRONE2;
348 hitp[i][j]=monster[GNOMEKING].hitpoints; break;
349
350 case OALTAR: *pm=DEMONPRINCE; *kn=0;
351 hitp[i][j]=monster[DEMONPRINCE].hitpoints; break;
352 };
353 switch(*pm)
354 {
355 case XORN: ifblind(i,j); hitm(i,j,200); break; /* Xorn takes damage from vpr */
356 }
357 }
358 return;
359
360 /* ----- LEVEL 4 SPELLS ----- */
361
362 case 21: direct(x,100+clev," The %s shrivels up",0); /* dehydration */
363 return;
364
365 case 22: godirect(x,rnd(25)+20+(clev<<1)," A lightning bolt hits the %s",1,'~'); /* lightning */
366 return;
367
368 case 23: i=min(c[HP]-1,c[HPMAX]/2); /* drain life */
369 direct(x,i+i,"",0); c[HP] -= i; return;
370
371 case 24: if (c[GLOBE]==0) c[MOREDEFENSES] += 10;
372 c[GLOBE] += 200; loseint(); /* globe of invulnerability */
373 return;
374
375 case 25: omnidirect(x,32+clev," The %s struggles for air in your flood!"); /* flood */
376 return;
377
378 case 26: if (rnd(151)==63) { beep(); lprcat("\nYour heart stopped!\n"); nap(4000); died(270); return; }
379 if (c[WISDOM]>rnd(10)+10) direct(x,2000," The %s's heart stopped",0); /* finger of death */
380 else lprcat(" It didn't work"); return;
381
382 /* ----- LEVEL 5 SPELLS ----- */
383
384 case 27: c[SCAREMONST] += rnd(10)+clev; return; /* scare monster */
385
386 case 28: c[HOLDMONST] += rnd(10)+clev; return; /* hold monster */
387
388 case 29: c[TIMESTOP] += rnd(20)+(clev<<1); return; /* time stop */
389
390 case 30: tdirect(x); return; /* teleport away */
391
392 case 31: omnidirect(x,35+rnd(10)+clev," The %s cringes from the flame"); /* magic fire */
393 return;
394
395 /* ----- LEVEL 6 SPELLS ----- */
396
397 case 32: if ((rnd(23)==5) && (wizard==0)) /* sphere of annihilation */
398 {
399 beep(); lprcat("\nYou have been enveloped by the zone of nothingness!\n");
400 nap(4000); died(258); return;
401 }
402 xl=playerx; yl=playery;
403 loseint();
404 i=dirsub(&xl,&yl); /* get direction of sphere */
405 newsphere(xl,yl,i,rnd(20)+11); /* make a sphere */
406 return;
407
408 case 33: genmonst(); spelknow[33]=0; /* genocide */
409 loseint();
410 return;
411
412 case 34: /* summon demon */
413 if (rnd(100) > 30) { direct(x,150," The demon strikes at the %s",0); return; }
414 if (rnd(100) > 15) { lprcat(" Nothing seems to have happened"); return; }
415 lprcat(" The demon turned on you and vanished!"); beep();
416 i=rnd(40)+30; lastnum=277;
417 losehp(i); /* must say killed by a demon */ return;
418
419 case 35: /* walk through walls */
420 c[WTW] += rnd(10)+5; return;
421
422 case 36: /* alter reality */
423 {
424 struct isave *save; /* pointer to item save structure */
425 int sc; sc=0; /* # items saved */
426 save = (struct isave *)malloc(sizeof(struct isave)*MAXX*MAXY*2);
427 for (j=0; j<MAXY; j++)
428 for (i=0; i<MAXX; i++) /* save all items and monsters */
429 {
430 xl = item[i][j];
431 if (xl && xl!=OWALL && xl!=OANNIHILATION)
432 {
433 save[sc].type=0; save[sc].id=item[i][j];
434 save[sc++].arg=iarg[i][j];
435 }
436 if (mitem[i][j])
437 {
438 save[sc].type=1; save[sc].id=mitem[i][j];
439 save[sc++].arg=hitp[i][j];
440 }
441 item[i][j]=OWALL; mitem[i][j]=0;
442 if (wizard) know[i][j]=1; else know[i][j]=0;
443 }
444 eat(1,1); if (level==1) item[33][MAXY-1]=0;
445 for (j=rnd(MAXY-2), i=1; i<MAXX-1; i++) item[i][j]=0;
446 while (sc>0) /* put objects back in level */
447 {
448 --sc;
449 if (save[sc].type == 0)
450 {
451 int trys;
452 for (trys=100, i=j=1; --trys>0 && item[i][j]; i=rnd(MAXX-1), j=rnd(MAXY-1));
453 if (trys) { item[i][j]=save[sc].id; iarg[i][j]=save[sc].arg; }
454 }
455 else
456 { /* put monsters back in */
457 int trys;
458 for (trys=100, i=j=1; --trys>0 && (item[i][j]==OWALL || mitem[i][j]); i=rnd(MAXX-1), j=rnd(MAXY-1));
459 if (trys) { mitem[i][j]=save[sc].id; hitp[i][j]=save[sc].arg; }
460 }
461 }
462 loseint();
463 draws(0,MAXX,0,MAXY); if (wizard==0) spelknow[36]=0;
464 free((char*)save); positionplayer(); return;
465 }
466
467 case 37: /* permanence */ larn_adjtime(-99999L); spelknow[37]=0; /* forget */
468 loseint();
469 return;
470
471 default: lprintf(" spell %d not available!",(long)x); beep(); return;
472 };
473 }
474
475 /*
476 * loseint() Routine to subtract 1 from your int (intelligence) if > 3
477 *
478 * No arguments and no return value
479 */
480 static void
481 loseint(void)
482 {
483 if (--c[INTELLIGENCE]<3) c[INTELLIGENCE]=3;
484 }
485
486 /*
487 * isconfuse() Routine to check to see if player is confused
488 *
489 * This routine prints out a message saying "You can't aim your magic!"
490 * returns 0 if not confused, non-zero (time remaining confused) if confused
491 */
492 static long
493 isconfuse(void)
494 {
495 if (c[CONFUSE]) { lprcat(" You can't aim your magic!"); beep(); }
496 return(c[CONFUSE]);
497 }
498
499 /*
500 * nospell(x,monst) Routine to return 1 if a spell doesn't affect a monster
501 * int x,monst;
502 *
503 * Subroutine to return 1 if the spell can't affect the monster
504 * otherwise returns 0
505 * Enter with the spell number in x, and the monster number in monst.
506 */
507 static int
508 nospell(int x, int monst)
509 {
510 int tmp;
511 if (x>=SPNUM || monst>=MAXMONST+8 || monst<0 || x<0) return(0); /* bad spell or monst */
512 if ((tmp=spelweird[monst-1][x])==0) return(0);
513 cursors(); lprc('\n'); lprintf(spelmes[tmp],monster[monst].name); return(1);
514 }
515
516 /*
517 * fullhit(xx) Function to return full damage against a monster (aka web)
518 * int xx;
519 *
520 * Function to return hp damage to monster due to a number of full hits
521 * Enter with the number of full hits being done
522 */
523 static int
524 fullhit(int xx)
525 {
526 int i;
527 if (xx<0 || xx>20) return(0); /* fullhits are out of range */
528 if (c[LANCEDEATH]) return(10000); /* lance of death */
529 i = xx * ((c[WCLASS]>>1)+c[STRENGTH]+c[STREXTRA]-c[HARDGAME]-12+c[MOREDAM]);
530 return( (i>=1) ? i : xx );
531 }
532
533 /*
534 * direct(spnum,dam,str,arg) Routine to direct spell damage 1 square in 1 dir
535 * int spnum,dam,arg;
536 * char *str;
537 *
538 * Routine to ask for a direction to a spell and then hit the monster
539 * Enter with the spell number in spnum, the damage to be done in dam,
540 * lprintf format string in str, and lprintf's argument in arg.
541 * Returns no value.
542 */
543 static void
544 direct(int spnum, int dam, const char *str, int arg)
545 {
546 int x,y;
547 int m;
548 if (spnum<0 || spnum>=SPNUM || str==0) return; /* bad arguments */
549 if (isconfuse()) return;
550 dirsub(&x,&y);
551 m = mitem[x][y];
552 if (item[x][y]==OMIRROR)
553 {
554 if (spnum==3) /* sleep */
555 {
556 lprcat("You fall asleep! "); beep();
557 fool:
558 arg += 2;
559 while (arg-- > 0) { parse2(); nap(1000); }
560 return;
561 }
562 else if (spnum==6) /* web */
563 {
564 lprcat("You get stuck in your own web! "); beep();
565 goto fool;
566 }
567 else
568 {
569 lastnum=278;
570 lprintf(str,"spell caster (thats you)",(long)arg);
571 beep(); losehp(dam); return;
572 }
573 }
574 if (m==0)
575 { lprcat(" There wasn't anything there!"); return; }
576 ifblind(x,y);
577 if (nospell(spnum,m)) { lasthx=x; lasthy=y; return; }
578 lprintf(str,lastmonst,(long)arg); hitm(x,y,dam);
579 }
580
581 /*
582 * godirect(spnum,dam,str,delay,cshow) Function to perform missile attacks
583 * int spnum,dam,delay;
584 * char *str,cshow;
585 *
586 * Function to hit in a direction from a missile weapon and have it keep
587 * on going in that direction until its power is exhausted
588 * Enter with the spell number in spnum, the power of the weapon in hp,
589 * lprintf format string in str, the # of milliseconds to delay between
590 * locations in delay, and the character to represent the weapon in cshow.
591 * Returns no value.
592 */
593 void
594 godirect(int spnum, int dam, const char *str, int delay, char cshow)
595 {
596 char *p;
597 int x,y,m;
598 int dx,dy;
599 if (spnum<0 || spnum>=SPNUM || str==0 || delay<0) return; /* bad args */
600 if (isconfuse()) return;
601 dirsub(&dx,&dy); x=dx; y=dy;
602 dx = x-playerx; dy = y-playery; x = playerx; y = playery;
603 while (dam>0)
604 {
605 x += dx; y += dy;
606 if ((x > MAXX-1) || (y > MAXY-1) || (x < 0) || (y < 0))
607 {
608 dam=0; break; /* out of bounds */
609 }
610 if ((x==playerx) && (y==playery)) /* if energy hits player */
611 {
612 cursors(); lprcat("\nYou are hit my your own magic!"); beep();
613 lastnum=278; losehp(dam); return;
614 }
615 if (c[BLINDCOUNT]==0) /* if not blind show effect */
616 {
617 cursor(x+1,y+1); lprc(cshow); nap(delay); show1cell(x,y);
618 }
619 if ((m=mitem[x][y])) /* is there a monster there? */
620 {
621 ifblind(x,y);
622 if (nospell(spnum,m)) { lasthx=x; lasthy=y; return; }
623 cursors(); lprc('\n');
624 lprintf(str,lastmonst); dam -= hitm(x,y,dam);
625 show1cell(x,y); nap(1000); x -= dx; y -= dy;
626 }
627 else switch (*(p= &item[x][y]))
628 {
629 case OWALL: cursors(); lprc('\n'); lprintf(str,"wall");
630 if (dam>=50+c[HARDGAME]) /* enough damage? */
631 if (level<MAXLEVEL+MAXVLEVEL-1) /* not on V3 */
632 if ((x<MAXX-1) && (y<MAXY-1) && (x) && (y))
633 {
634 lprcat(" The wall crumbles");
635 god3: *p=0;
636 god: know[x][y]=0;
637 show1cell(x,y);
638 }
639 god2: dam = 0; break;
640
641 case OCLOSEDDOOR: cursors(); lprc('\n'); lprintf(str,"door");
642 if (dam>=40)
643 {
644 lprcat(" The door is blasted apart");
645 goto god3;
646 }
647 goto god2;
648
649 case OSTATUE: cursors(); lprc('\n'); lprintf(str,"statue");
650 if (c[HARDGAME]<3)
651 if (dam>44)
652 {
653 lprcat(" The statue crumbles");
654 *p=OBOOK; iarg[x][y]=level;
655 goto god;
656 }
657 goto god2;
658
659 case OTHRONE: cursors(); lprc('\n'); lprintf(str,"throne");
660 if (dam>39)
661 {
662 mitem[x][y]=GNOMEKING; hitp[x][y]=monster[GNOMEKING].hitpoints;
663 *p = OTHRONE2;
664 goto god;
665 }
666 goto god2;
667
668 case OMIRROR: dx *= -1; dy *= -1; break;
669 };
670 dam -= 3 + (c[HARDGAME]>>1);
671 }
672 }
673
674 /*
675 * ifblind(x,y) Routine to put "monster" or the monster name into lastmosnt
676 * int x,y;
677 *
678 * Subroutine to copy the word "monster" into lastmonst if the player is blind
679 * Enter with the coordinates (x,y) of the monster
680 * Returns no value.
681 */
682 static void
683 ifblind(int x, int y)
684 {
685 const char *p;
686 vxy(&x,&y); /* verify correct x,y coordinates */
687 if (c[BLINDCOUNT]) { lastnum=279; p="monster"; }
688 else { lastnum=mitem[x][y]; p=monster[lastnum].name; }
689 strcpy(lastmonst,p);
690 }
691
692 /*
693 * tdirect(spnum) Routine to teleport away a monster
694 * int spnum;
695 *
696 * Routine to ask for a direction to a spell and then teleport away monster
697 * Enter with the spell number that wants to teleport away
698 * Returns no value.
699 */
700 static void
701 tdirect(int spnum)
702 {
703 int x,y;
704 int m;
705 if (spnum<0 || spnum>=SPNUM) return; /* bad args */
706 if (isconfuse()) return;
707 dirsub(&x,&y);
708 if ((m=mitem[x][y])==0)
709 { lprcat(" There wasn't anything there!"); return; }
710 ifblind(x,y);
711 if (nospell(spnum,m)) { lasthx=x; lasthy=y; return; }
712 fillmonst(m); mitem[x][y]=know[x][y]=0;
713 }
714
715 /*
716 * omnidirect(sp,dam,str) Routine to damage all monsters 1 square from player
717 * int sp,dam;
718 * char *str;
719 *
720 * Routine to cast a spell and then hit the monster in all directions
721 * Enter with the spell number in sp, the damage done to wach square in dam,
722 * and the lprintf string to identify the spell in str.
723 * Returns no value.
724 */
725 static void
726 omnidirect(int spnum, int dam, const char *str)
727 {
728 int x,y,m;
729 if (spnum<0 || spnum>=SPNUM || str==0) return; /* bad args */
730 for (x=playerx-1; x<playerx+2; x++)
731 for (y=playery-1; y<playery+2; y++)
732 {
733 if ((m=mitem[x][y]))
734 {
735 if (nospell(spnum,m) == 0)
736 {
737 ifblind(x,y);
738 cursors(); lprc('\n'); lprintf(str,lastmonst);
739 hitm(x,y,dam); nap(800);
740 }
741 else { lasthx=x; lasthy=y; }
742 }
743 }
744 }
745
746 /*
747 * static dirsub(x,y) Routine to ask for direction, then modify x,y for it
748 * int *x,*y;
749 *
750 * Function to ask for a direction and modify an x,y for that direction
751 * Enter with the origination coordinates in (x,y).
752 * Returns index into diroffx[] (0-8).
753 */
754 static int
755 dirsub(int *x, int *y)
756 {
757 int i;
758 lprcat("\nIn What Direction? ");
759 for (i=0; ; )
760 switch(getchr())
761 {
762 case 'b': i++;
763 case 'n': i++;
764 case 'y': i++;
765 case 'u': i++;
766 case 'h': i++;
767 case 'k': i++;
768 case 'l': i++;
769 case 'j': i++; goto out;
770 };
771 out:
772 *x = playerx+diroffx[i]; *y = playery+diroffy[i];
773 vxy(x,y); return(i);
774 }
775
776 /*
777 * vxy(x,y) Routine to verify/fix coordinates for being within bounds
778 * int *x,*y;
779 *
780 * Function to verify x & y are within the bounds for a level
781 * If *x or *y is not within the absolute bounds for a level, fix them so that
782 * they are on the level.
783 * Returns TRUE if it was out of bounds, and the *x & *y in the calling
784 * routine are affected.
785 */
786 int
787 vxy(int *x, int *y)
788 {
789 int flag=0;
790 if (*x<0) { *x=0; flag++; }
791 if (*y<0) { *y=0; flag++; }
792 if (*x>=MAXX) { *x=MAXX-1; flag++; }
793 if (*y>=MAXY) { *y=MAXY-1; flag++; }
794 return(flag);
795 }
796
797 /*
798 * dirpoly(spnum) Routine to ask for a direction and polymorph a monst
799 * int spnum;
800 *
801 * Subroutine to polymorph a monster and ask for the direction its in
802 * Enter with the spell number in spmun.
803 * Returns no value.
804 */
805 static void
806 dirpoly(int spnum)
807 {
808 int x,y,m;
809 if (spnum<0 || spnum>=SPNUM) return; /* bad args */
810 if (isconfuse()) return; /* if he is confused, he can't aim his magic */
811 dirsub(&x,&y);
812 if (mitem[x][y]==0)
813 { lprcat(" There wasn't anything there!"); return; }
814 ifblind(x,y);
815 if (nospell(spnum,mitem[x][y])) { lasthx=x; lasthy=y; return; }
816 while ( monster[m = mitem[x][y] = rnd(MAXMONST+7)].genocided );
817 hitp[x][y] = monster[m].hitpoints;
818 show1cell(x,y); /* show the new monster */
819 }
820
821 /*
822 * hitmonster(x,y) Function to hit a monster at the designated coordinates
823 * int x,y;
824 *
825 * This routine is used for a bash & slash type attack on a monster
826 * Enter with the coordinates of the monster in (x,y).
827 * Returns no value.
828 */
829 void
830 hitmonster(int x, int y)
831 {
832 int tmp,monst,damag=0,flag;
833 if (c[TIMESTOP]) return; /* not if time stopped */
834 vxy(&x,&y); /* verify coordinates are within range */
835 if ((monst = mitem[x][y]) == 0) return;
836 hit3flag=1; ifblind(x,y);
837 tmp = monster[monst].armorclass + c[LEVEL] + c[DEXTERITY] + c[WCLASS]/4 - 12;
838 cursors();
839 if ((rnd(20) < tmp-c[HARDGAME]) || (rnd(71) < 5)) /* need at least random chance to hit */
840 {
841 lprcat("\nYou hit"); flag=1;
842 damag = fullhit(1);
843 if (damag<9999) damag=rnd(damag)+1;
844 }
845 else
846 {
847 lprcat("\nYou missed"); flag=0;
848 }
849 lprcat(" the "); lprcat(lastmonst);
850 if (flag) /* if the monster was hit */
851 if ((monst==RUSTMONSTER) || (monst==DISENCHANTRESS) || (monst==CUBE))
852 if (c[WIELD]>0)
853 if (ivenarg[c[WIELD]] > -10)
854 {
855 lprintf("\nYour weapon is dulled by the %s",lastmonst); beep();
856 --ivenarg[c[WIELD]];
857 }
858 if (flag) hitm(x,y,damag);
859 if (monst == VAMPIRE) if (hitp[x][y]<25) { mitem[x][y]=BAT; know[x][y]=0; }
860 }
861
862 /*
863 * hitm(x,y,amt) Function to just hit a monster at a given coordinates
864 * int x,y,amt;
865 *
866 * Returns the number of hitpoints the monster absorbed
867 * This routine is used to specifically damage a monster at a location (x,y)
868 * Called by hitmonster(x,y)
869 */
870 int
871 hitm(int x, int y, int amt)
872 {
873 int monst;
874 int hpoints,amt2;
875 vxy(&x,&y); /* verify coordinates are within range */
876 amt2 = amt; /* save initial damage so we can return it */
877 monst = mitem[x][y];
878 if (c[HALFDAM]) amt >>= 1; /* if half damage curse adjust damage points */
879 if (amt<=0) amt2 = amt = 1;
880 lasthx=x; lasthy=y;
881 stealth[x][y]=1; /* make sure hitting monst breaks stealth condition */
882 c[HOLDMONST]=0; /* hit a monster breaks hold monster spell */
883 switch(monst) /* if a dragon and orb(s) of dragon slaying */
884 {
885 case WHITEDRAGON: case REDDRAGON: case GREENDRAGON:
886 case BRONZEDRAGON: case PLATINUMDRAGON: case SILVERDRAGON:
887 amt *= 1+(c[SLAYING]<<1); break;
888 }
889 /* invincible monster fix is here */
890 if (hitp[x][y] > monster[monst].hitpoints)
891 hitp[x][y] = monster[monst].hitpoints;
892 if ((hpoints = hitp[x][y]) <= amt)
893 {
894 #ifdef EXTRA
895 c[MONSTKILLED]++;
896 #endif
897 lprintf("\nThe %s died!",lastmonst);
898 raiseexperience((long)monster[monst].experience);
899 amt = monster[monst].gold; if (amt>0) dropgold(rnd(amt)+amt);
900 dropsomething(monst); disappear(x,y); bottomline();
901 return(hpoints);
902 }
903 hitp[x][y] = hpoints-amt; return(amt2);
904 }
905
906 /*
907 * hitplayer(x,y) Function for the monster to hit the player from (x,y)
908 * int x,y;
909 *
910 * Function for the monster to hit the player with monster at location x,y
911 * Returns nothing of value.
912 */
913 void
914 hitplayer(int x, int y)
915 {
916 int dam,tmp,mster,bias;
917 vxy(&x,&y); /* verify coordinates are within range */
918 lastnum = mster = mitem[x][y];
919 /* spirit naga's and poltergeist's do nothing if scarab of negate spirit */
920 if (c[NEGATESPIRIT] || c[SPIRITPRO]) if ((mster ==POLTERGEIST) || (mster ==SPIRITNAGA)) return;
921 /* if undead and cube of undead control */
922 if (c[CUBEofUNDEAD] || c[UNDEADPRO]) if ((mster ==VAMPIRE) || (mster ==WRAITH) || (mster ==ZOMBIE)) return;
923 if ((know[x][y]&1) == 0)
924 {
925 know[x][y]=1; show1cell(x,y);
926 }
927 bias = (c[HARDGAME]) + 1;
928 hitflag = hit2flag = hit3flag = 1;
929 yrepcount=0;
930 cursors(); ifblind(x,y);
931 if (c[INVISIBILITY]) if (rnd(33)<20)
932 {
933 lprintf("\nThe %s misses wildly",lastmonst); return;
934 }
935 if (c[CHARMCOUNT]) if (rnd(30)+5*monster[mster].level-c[CHARISMA]<30)
936 {
937 lprintf("\nThe %s is awestruck at your magnificence!",lastmonst);
938 return;
939 }
940 if (mster==BAT) dam=1;
941 else
942 {
943 dam = monster[mster].damage;
944 dam += rnd((int)((dam<1)?1:dam)) + monster[mster].level;
945 }
946 tmp = 0;
947 if (monster[mster].attack>0)
948 if (((dam + bias + 8) > c[AC]) || (rnd((int)((c[AC]>0)?c[AC]:1))==1))
949 { if (spattack(monster[mster].attack,x,y)) { flushall(); return; }
950 tmp = 1; bias -= 2; cursors(); }
951 if (((dam + bias) > c[AC]) || (rnd((int)((c[AC]>0)?c[AC]:1))==1))
952 {
953 lprintf("\n The %s hit you ",lastmonst); tmp = 1;
954 if ((dam -= c[AC]) < 0) dam=0;
955 if (dam > 0) { losehp(dam); bottomhp(); flushall(); }
956 }
957 if (tmp == 0) lprintf("\n The %s missed ",lastmonst);
958 }
959
960 /*
961 * dropsomething(monst) Function to create an object when a monster dies
962 * int monst;
963 *
964 * Function to create an object near the player when certain monsters are killed
965 * Enter with the monster number
966 * Returns nothing of value.
967 */
968 static void
969 dropsomething(int monst)
970 {
971 switch(monst)
972 {
973 case ORC: case NYMPH: case ELF: case TROGLODYTE:
974 case TROLL: case ROTHE: case VIOLETFUNGI:
975 case PLATINUMDRAGON: case GNOMEKING: case REDDRAGON:
976 something(level); return;
977
978 case LEPRECHAUN: if (rnd(101)>=75) creategem();
979 if (rnd(5)==1) dropsomething(LEPRECHAUN); return;
980 }
981 }
982
983 /*
984 * dropgold(amount) Function to drop some gold around player
985 * int amount;
986 *
987 * Enter with the number of gold pieces to drop
988 * Returns nothing of value.
989 */
990 void
991 dropgold(int amount)
992 {
993 if (amount > 250) createitem(OMAXGOLD,amount/100); else createitem(OGOLDPILE,amount);
994 }
995
996 /*
997 * something(lvl) Function to create a random item around player
998 * int lvl;
999 *
1000 * Function to create an item from a designed probability around player
1001 * Enter with the cave level on which something is to be dropped
1002 * Returns nothing of value.
1003 */
1004 void
1005 something(int lvl)
1006 {
1007 int j;
1008 int i;
1009 if (lvl<0 || lvl>MAXLEVEL+MAXVLEVEL) return; /* correct level? */
1010 if (rnd(101)<8) something(lvl); /* possibly more than one item */
1011 j = newobject(lvl,&i); createitem(j,i);
1012 }
1013
1014 /*
1015 * newobject(lev,i) Routine to return a randomly selected new object
1016 * int lev,*i;
1017 *
1018 * Routine to return a randomly selected object to be created
1019 * Returns the object number created, and sets *i for its argument
1020 * Enter with the cave level and a pointer to the items arg
1021 */
1022 static char nobjtab[] = { 0, OSCROLL, OSCROLL, OSCROLL, OSCROLL, OPOTION,
1023 OPOTION, OPOTION, OPOTION, OGOLDPILE, OGOLDPILE, OGOLDPILE, OGOLDPILE,
1024 OBOOK, OBOOK, OBOOK, OBOOK, ODAGGER, ODAGGER, ODAGGER, OLEATHER, OLEATHER,
1025 OLEATHER, OREGENRING, OPROTRING, OENERGYRING, ODEXRING, OSTRRING, OSPEAR,
1026 OBELT, ORING, OSTUDLEATHER, OSHIELD, OFLAIL, OCHAIN, O2SWORD, OPLATE,
1027 OLONGSWORD };
1028
1029 int
1030 newobject(int lev, int *i)
1031 {
1032 int tmp=32,j;
1033 if (level<0 || level>MAXLEVEL+MAXVLEVEL) return(0); /* correct level? */
1034 if (lev>6) tmp=37; else if (lev>4) tmp=35;
1035 j = nobjtab[tmp=rnd(tmp)]; /* the object type */
1036 switch(tmp)
1037 {
1038 case 1: case 2: case 3: case 4: *i=newscroll(); break;
1039 case 5: case 6: case 7: case 8: *i=newpotion(); break;
1040 case 9: case 10: case 11: case 12: *i=rnd((lev+1)*10)+lev*10+10; break;
1041 case 13: case 14: case 15: case 16: *i=lev; break;
1042 case 17: case 18: case 19: if (!(*i=newdagger())) return(0); break;
1043 case 20: case 21: case 22: if (!(*i=newleather())) return(0); break;
1044 case 23: case 32: case 35: *i=rund(lev/3+1); break;
1045 case 24: case 26: *i=rnd(lev/4+1); break;
1046 case 25: *i=rund(lev/4+1); break;
1047 case 27: *i=rnd(lev/2+1); break;
1048 case 30: case 33: *i=rund(lev/2+1); break;
1049 case 28: *i=rund(lev/3+1); if (*i==0) return(0); break;
1050 case 29: case 31: *i=rund(lev/2+1); if (*i==0) return(0); break;
1051 case 34: *i=newchain(); break;
1052 case 36: *i=newplate(); break;
1053 case 37: *i=newsword(); break;
1054 }
1055 return(j);
1056 }
1057
1058 /*
1059 * spattack(atckno,xx,yy) Function to process special attacks from monsters
1060 * int atckno,xx,yy;
1061 *
1062 * Enter with the special attack number, and the coordinates (xx,yy)
1063 * of the monster that is special attacking
1064 * Returns 1 if must do a show1cell(xx,yy) upon return, 0 otherwise
1065 *
1066 * atckno monster effect
1067 * ---------------------------------------------------
1068 * 0 none
1069 * 1 rust monster eat armor
1070 * 2 hell hound breathe light fire
1071 * 3 dragon breathe fire
1072 * 4 giant centipede weakening sing
1073 * 5 white dragon cold breath
1074 * 6 wraith drain level
1075 * 7 waterlord water gusher
1076 * 8 leprechaun steal gold
1077 * 9 disenchantress disenchant weapon or armor
1078 * 10 ice lizard hits with barbed tail
1079 * 11 umber hulk confusion
1080 * 12 spirit naga cast spells taken from special attacks
1081 * 13 platinum dragon psionics
1082 * 14 nymph steal objects
1083 * 15 bugbear bite
1084 * 16 osequip bite
1085 *
1086 * char rustarm[ARMORTYPES][2];
1087 * special array for maximum rust damage to armor from rustmonster
1088 * format is: { armor type , minimum attribute
1089 */
1090 #define ARMORTYPES 6
1091 static char rustarm[ARMORTYPES][2] = {
1092 { OSTUDLEATHER, -2 }, { ORING, -4 }, { OCHAIN, -5 },
1093 { OSPLINT, -6}, { OPLATE, -8}, { OPLATEARMOR, -9 }
1094 };
1095 static char spsel[] = { 1, 2, 3, 5, 6, 8, 9, 11, 13, 14 };
1096
1097 static int
1098 spattack(int x, int xx, int yy)
1099 {
1100 int i,j=0,k,m;
1101 const char *p=NULL;
1102 if (c[CANCELLATION]) return(0);
1103 vxy(&xx,&yy); /* verify x & y coordinates */
1104 switch(x)
1105 {
1106 case 1: /* rust your armor, j=1 when rusting has occurred */
1107 m = k = c[WEAR];
1108 if ((i=c[SHIELD]) != -1)
1109 {
1110 if (--ivenarg[i] < -1) ivenarg[i]= -1; else j=1;
1111 }
1112 if ((j==0) && (k != -1))
1113 {
1114 m = iven[k];
1115 for (i=0; i<ARMORTYPES; i++)
1116 if (m == rustarm[i][0]) /* find his armor in table */
1117 {
1118 if (--ivenarg[k]< rustarm[i][1])
1119 ivenarg[k]= rustarm[i][1]; else j=1;
1120 break;
1121 }
1122 }
1123 if (j==0) /* if rusting did not occur */
1124 switch(m)
1125 {
1126 case OLEATHER: p = "\nThe %s hit you -- Your lucky you have leather on";
1127 break;
1128 case OSSPLATE: p = "\nThe %s hit you -- Your fortunate to have stainless steel armor!";
1129 break;
1130 }
1131 else { beep(); p = "\nThe %s hit you -- your armor feels weaker"; }
1132 break;
1133
1134 case 2: i = rnd(15)+8-c[AC];
1135 spout: p="\nThe %s breathes fire at you!";
1136 if (c[FIRERESISTANCE])
1137 p="\nThe %s's flame doesn't phase you!";
1138 else
1139 spout2: if (p) { lprintf(p,lastmonst); beep(); }
1140 checkloss(i);
1141 return(0);
1142
1143 case 3: i = rnd(20)+25-c[AC]; goto spout;
1144
1145 case 4: if (c[STRENGTH]>3)
1146 {
1147 p="\nThe %s stung you! You feel weaker"; beep();
1148 --c[STRENGTH];
1149 }
1150 else p="\nThe %s stung you!";
1151 break;
1152
1153 case 5: p="\nThe %s blasts you with his cold breath";
1154 i = rnd(15)+18-c[AC]; goto spout2;
1155
1156 case 6: lprintf("\nThe %s drains you of your life energy!",lastmonst);
1157 loselevel(); beep(); return(0);
1158
1159 case 7: p="\nThe %s got you with a gusher!";
1160 i = rnd(15)+25-c[AC]; goto spout2;
1161
1162 case 8: if (c[NOTHEFT]) return(0); /* he has a device of no theft */
1163 if (c[GOLD])
1164 {
1165 p="\nThe %s hit you -- Your purse feels lighter";
1166 if (c[GOLD]>32767) c[GOLD]>>=1;
1167 else c[GOLD] -= rnd((int)(1+(c[GOLD]>>1)));
1168 if (c[GOLD] < 0) c[GOLD]=0;
1169 }
1170 else p="\nThe %s couldn't find any gold to steal";
1171 lprintf(p,lastmonst); disappear(xx,yy); beep();
1172 bottomgold(); return(1);
1173
1174 case 9: for(j=50; ; ) /* disenchant */
1175 {
1176 i=rund(26); m=iven[i]; /* randomly select item */
1177 if (m>0 && ivenarg[i]>0 && m!=OSCROLL && m!=OPOTION)
1178 {
1179 if ((ivenarg[i] -= 3)<0) ivenarg[i]=0;
1180 lprintf("\nThe %s hits you -- you feel a sense of loss",lastmonst);
1181 srcount=0; beep(); show3(i); bottomline(); return(0);
1182 }
1183 if (--j<=0)
1184 {
1185 p="\nThe %s nearly misses"; break;
1186 }
1187 break;
1188 }
1189 break;
1190
1191 case 10: p="\nThe %s hit you with his barbed tail";
1192 i = rnd(25)-c[AC]; goto spout2;
1193
1194 case 11: p="\nThe %s has confused you"; beep();
1195 c[CONFUSE]+= 10+rnd(10); break;
1196
1197 case 12: /* performs any number of other special attacks */
1198 return(spattack(spsel[rund(10)],xx,yy));
1199
1200 case 13: p="\nThe %s flattens you with his psionics!";
1201 i = rnd(15)+30-c[AC]; goto spout2;
1202
1203 case 14: if (c[NOTHEFT]) return(0); /* he has device of no theft */
1204 if (emptyhanded()==1)
1205 {
1206 p="\nThe %s couldn't find anything to steal";
1207 break;
1208 }
1209 lprintf("\nThe %s picks your pocket and takes:",lastmonst);
1210 beep();
1211 if (stealsomething()==0) lprcat(" nothing"); disappear(xx,yy);
1212 bottomline(); return(1);
1213
1214 case 15: i= rnd(10)+ 5-c[AC];
1215 spout3: p="\nThe %s bit you!";
1216 goto spout2;
1217
1218 case 16: i= rnd(15)+10-c[AC]; goto spout3;
1219 };
1220 if (p) { lprintf(p,lastmonst); bottomline(); }
1221 return(0);
1222 }
1223
1224 /*
1225 * checkloss(x) Routine to subtract hp from user and flag bottomline display
1226 * int x;
1227 *
1228 * Routine to subtract hitpoints from the user and flag the bottomline display
1229 * Enter with the number of hit points to lose
1230 * Note: if x > c[HP] this routine could kill the player!
1231 */
1232 void
1233 checkloss(int x)
1234 {
1235 if (x>0) { losehp(x); bottomhp(); }
1236 }
1237
1238 /*
1239 * annihilate() Routine to annihilate all monsters around player (playerx,playery)
1240 *
1241 * Gives player experience, but no dropped objects
1242 * Returns the experience gained from all monsters killed
1243 */
1244 long
1245 annihilate(void)
1246 {
1247 int i,j;
1248 long k;
1249 char *p;
1250 for (k=0, i=playerx-1; i<=playerx+1; i++)
1251 for (j=playery-1; j<=playery+1; j++)
1252 if (!vxy(&i,&j)) /* if not out of bounds */
1253 {
1254 if (*(p= &mitem[i][j])) /* if a monster there */
1255 {
1256 if (*p<DEMONLORD+2)
1257 {
1258 k += monster[(int)*p].experience; *p=know[i][j]=0;
1259 }
1260 else
1261 {
1262 lprintf("\nThe %s barely escapes being annihilated!",monster[(int)*p].name);
1263 hitp[i][j] = (hitp[i][j]>>1) + 1; /* lose half hit points*/
1264 }
1265 }
1266 }
1267 if (k>0)
1268 {
1269 lprcat("\nYou hear loud screams of agony!"); raiseexperience((long)k);
1270 }
1271 return(k);
1272 }
1273
1274 /*
1275 * newsphere(x,y,dir,lifetime) Function to create a new sphere of annihilation
1276 * int x,y,dir,lifetime;
1277 *
1278 * Enter with the coordinates of the sphere in x,y
1279 * the direction (0-8 diroffx format) in dir, and the lifespan of the
1280 * sphere in lifetime (in turns)
1281 * Returns the number of spheres currently in existence
1282 */
1283 long
1284 newsphere(int x, int y, int dir, int life)
1285 {
1286 int m;
1287 struct sphere *sp;
1288 if (((sp=(struct sphere *)malloc(sizeof(struct sphere)))) == 0)
1289 return(c[SPHCAST]); /* can't malloc, therefore failure */
1290 if (dir>=9) dir=0; /* no movement if direction not found */
1291 if (level==0) vxy(&x,&y); /* don't go out of bounds */
1292 else
1293 {
1294 if (x<1) x=1; if (x>=MAXX-1) x=MAXX-2;
1295 if (y<1) y=1; if (y>=MAXY-1) y=MAXY-2;
1296 }
1297 if ((m=mitem[x][y]) >= DEMONLORD+4) /* demons dispel spheres */
1298 {
1299 know[x][y]=1; show1cell(x,y); /* show the demon (ha ha) */
1300 cursors(); lprintf("\nThe %s dispels the sphere!",monster[m].name);
1301 beep(); rmsphere(x,y); /* remove any spheres that are here */
1302 return(c[SPHCAST]);
1303 }
1304 if (m==DISENCHANTRESS) /* disenchantress cancels spheres */
1305 {
1306 cursors(); lprintf("\nThe %s causes cancellation of the sphere!",monster[m].name); beep();
1307 boom: sphboom(x,y); /* blow up stuff around sphere */
1308 rmsphere(x,y); /* remove any spheres that are here */
1309 return(c[SPHCAST]);
1310 }
1311 if (c[CANCELLATION]) /* cancellation cancels spheres */
1312 {
1313 cursors(); lprcat("\nAs the cancellation takes effect, you hear a great earth shaking blast!"); beep();
1314 goto boom;
1315 }
1316 if (item[x][y]==OANNIHILATION) /* collision of spheres detonates spheres */
1317 {
1318 cursors(); lprcat("\nTwo spheres of annihilation collide! You hear a great earth shaking blast!"); beep();
1319 rmsphere(x,y);
1320 goto boom;
1321 }
1322 if (playerx==x && playery==y) /* collision of sphere and player! */
1323 {
1324 cursors();
1325 lprcat("\nYou have been enveloped by the zone of nothingness!\n");
1326 beep(); rmsphere(x,y); /* remove any spheres that are here */
1327 nap(4000); died(258);
1328 }
1329 item[x][y]=OANNIHILATION; mitem[x][y]=0; know[x][y]=1;
1330 show1cell(x,y); /* show the new sphere */
1331 sp->x=x; sp->y=y; sp->lev=level; sp->dir=dir; sp->lifetime=life; sp->p=0;
1332 if (spheres==0) spheres=sp; /* if first node in the sphere list */
1333 else /* add sphere to beginning of linked list */
1334 {
1335 sp->p = spheres; spheres = sp;
1336 }
1337 return(++c[SPHCAST]); /* one more sphere in the world */
1338 }
1339
1340 /*
1341 * rmsphere(x,y) Function to delete a sphere of annihilation from list
1342 * int x,y;
1343 *
1344 * Enter with the coordinates of the sphere (on current level)
1345 * Returns the number of spheres currently in existence
1346 */
1347 long
1348 rmsphere(int x, int y)
1349 {
1350 struct sphere *sp,*sp2=0;
1351 for (sp=spheres; sp; sp2=sp,sp=sp->p)
1352 if (level==sp->lev) /* is sphere on this level? */
1353 if ((x==sp->x) && (y==sp->y)) /* locate sphere at this location */
1354 {
1355 item[x][y]=mitem[x][y]=0; know[x][y]=1;
1356 show1cell(x,y); /* show the now missing sphere */
1357 --c[SPHCAST];
1358 if (sp==spheres) { sp2=sp; spheres=sp->p; free((char*)sp2); }
1359 else
1360 { sp2->p = sp->p; free((char*)sp); }
1361 break;
1362 }
1363 return(c[SPHCAST]); /* return number of spheres in the world */
1364 }
1365
1366 /*
1367 * sphboom(x,y) Function to perform the effects of a sphere detonation
1368 * int x,y;
1369 *
1370 * Enter with the coordinates of the blast, Returns no value
1371 */
1372 static void
1373 sphboom(int x, int y)
1374 {
1375 int i,j;
1376 if (c[HOLDMONST]) c[HOLDMONST]=1;
1377 if (c[CANCELLATION]) c[CANCELLATION]=1;
1378 for (j=max(1,x-2); j<min(x+3,MAXX-1); j++)
1379 for (i=max(1,y-2); i<min(y+3,MAXY-1); i++)
1380 {
1381 item[j][i]=mitem[j][i]=0;
1382 show1cell(j,i);
1383 if (playerx==j && playery==i)
1384 {
1385 cursors(); beep();
1386 lprcat("\nYou were too close to the sphere!");
1387 nap(3000);
1388 died(283); /* player killed in explosion */
1389 }
1390 }
1391 }
1392
1393 /*
1394 * genmonst() Function to ask for monster and genocide from game
1395 *
1396 * This is done by setting a flag in the monster[] structure
1397 */
1398 static void
1399 genmonst(void)
1400 {
1401 int i,j;
1402 cursors(); lprcat("\nGenocide what monster? ");
1403 for (i=0; (!isalpha(i)) && (i!=' '); i=getchr());
1404 lprc(i);
1405 for (j=0; j<MAXMONST; j++) /* search for the monster type */
1406 if (monstnamelist[j]==i) /* have we found it? */
1407 {
1408 monster[j].genocided=1; /* genocided from game */
1409 lprintf(" There will be no more %s's",monster[j].name);
1410 /* now wipe out monsters on this level */
1411 newcavelevel(level); draws(0,MAXX,0,MAXY); bot_linex();
1412 return;
1413 }
1414 lprcat(" You sense failure!");
1415 }
1416
DragonFly BSD