Annotation of early-roguelike/arogue7/actions.c, Revision 1.1.1.1
1.1 rubenllo 1: /*
2: * actions.c - functions for dealing with monster actions
3: *
4: * Advanced Rogue
5: * Copyright (C) 1984, 1985, 1986 Michael Morgan, Ken Dalka and AT&T
6: * All rights reserved.
7: *
8: * Based on "Rogue: Exploring the Dungeons of Doom"
9: * Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
10: * All rights reserved.
11: *
12: * See the file LICENSE.TXT for full copyright and licensing information.
13: */
14:
15: #include <ctype.h>
16: #include <limits.h>
17: #include "curses.h"
18: #include "rogue.h"
19: #define MAXINT INT_MAX
20: #define MININT INT_MIN
21:
22: void m_breathe(struct thing *tp);
23: void m_select(struct thing *th, bool flee);
24: void m_sonic(struct thing *tp);
25: void m_spell(struct thing *tp);
26: void m_summon(struct thing *tp);
27: bool m_use_it(struct thing *tp, bool flee, struct room *rer, struct room *ree);
28: bool m_use_pack(struct thing *monster, coord *monst_pos, coord *defend_pos,
29: int dist, coord *shoot_dir);
30:
31: /*
32: * Did we disrupt a spell?
33: */
34: void
35: dsrpt_monster(struct thing *tp, bool always, bool see_him)
36: {
37: switch (tp->t_action) {
38: case A_SUMMON:
39: case A_MISSILE:
40: case A_SLOW:
41: tp->t_action = A_NIL; /* Just make the old fellow start over again */
42: tp->t_no_move = movement(tp);
43: tp->t_using = NULL;/* Just to be on the safe side */
44: turn_on(*tp, WASDISRUPTED);
45: if (see_him)
46: msg("%s's spell has been disrupted.",prname(monster_name(tp),TRUE));
47: /*
48: * maybe choose something else to do next time since player
49: * is disrupting us
50: */
51: tp->t_summon *= 2;
52: tp->t_cast /= 2;
53: return;
54: }
55:
56: /* We may want to disrupt other actions, too */
57: if (always) {
58: tp->t_action = A_NIL; /* Just make the old fellow start over again */
59: tp->t_no_move = movement(tp);
60: tp->t_using = NULL;/* Just to be on the safe side */
61: }
62: }
63:
64: void
65: dsrpt_player(void)
66: {
67: int which, action;
68: struct linked_list *item;
69: struct object *obj;
70:
71: action = player.t_action;
72: which = player.t_selection;
73:
74: switch (action) {
75: case C_CAST: /* Did we disrupt a spell? */
76: case C_PRAY:
77: case C_CHANT:
78: {
79: msg("Your %s was disrupted!", action == C_CAST ? "spell" : "prayer");
80:
81: /* Charge him anyway */
82: if (action == C_CAST)
83: spell_power += magic_spells[which].s_cost;
84: else if (action == C_PRAY)
85: pray_time += cleric_spells[which].s_cost;
86: else if (action == C_CHANT)
87: chant_time += druid_spells[which].s_cost;
88: }
89: when C_COUNT: /* counting of gold? */
90: {
91: if (purse > 0) {
92: msg("Your gold goes flying everywhere!");
93: do {
94: item = spec_item(GOLD, 0, 0, 0);
95: obj = OBJPTR(item);
96: obj->o_count = min(purse, rnd(10)+1);
97: purse -= obj->o_count;
98: obj->o_pos = hero;
99: fall(item, FALSE);
100: } while (purse > 0 && rnd(10) != 1);
101: }
102: }
103: when C_EAT:
104: msg("You gag on your food for a moment.");
105: del_pack(player.t_using);
106:
107: when A_PICKUP:
108: msg("You drop what you are picking up!");
109:
110: when C_SEARCH: /* searching for traps and secret doors... */
111: msg("Oww....You decide to stop searching.");
112: count = 0; /* don't search again */
113:
114: when C_SETTRAP:
115: msg("Oww....You can't get a trap set.");
116:
117: when A_NIL:
118: default:
119: return;
120: }
121: player.t_no_move = movement(&player); /* disoriented for a while */
122: player.t_action = A_NIL;
123: player.t_selection = 0;
124: player.t_using = NULL;
125: }
126:
127: /*
128: * m_act:
129: * If the critter isn't doing anything, choose an action for it.
130: * Otherwise, let it perform its chosen action.
131: */
132:
133: void
134: m_act(struct thing *tp)
135: {
136: struct object *obj;
137: bool flee; /* Are we scared? */
138:
139: /* What are we planning to do? */
140: switch (tp->t_action) {
141: default:
142: /* An unknown action! */
143: msg("Unknown monster action (%d)", tp->t_action);
144:
145: /* Fall through */
146:
147: case A_NIL:
148: /* If the monster is fairly intelligent and about to die, it
149: * may turn tail and run. But if we are a FRIENDLY creature
150: * in the hero's service, don't run.
151: */
152: if (off(*tp, ISFLEE) &&
153: tp->t_stats.s_hpt < tp->maxstats.s_hpt &&
154: tp->t_stats.s_hpt < max(10, tp->maxstats.s_hpt/6) &&
155: (off(*tp, ISFRIENDLY) || tp->t_dest != &hero) &&
156: rnd(25) < tp->t_stats.s_intel) {
157: turn_on(*tp, ISFLEE);
158:
159: /* It is okay to turn tail */
160: tp->t_oldpos = tp->t_pos;
161: }
162:
163: /* Should the monster run away? */
164: flee = on(*tp, ISFLEE) ||
165: ((tp->t_dest == &hero) && on(player, ISINWALL) &&
166: off(*tp, CANINWALL));
167:
168: m_select(tp, flee); /* Select an action */
169: return;
170:
171: when A_ATTACK:
172: /*
173: * We're trying to attack the player or monster at t_newpos
174: * if the prey moved, do nothing
175: */
176: obj = tp->t_using ? OBJPTR(tp->t_using) : NULL;
177: if (ce(tp->t_newpos, hero)) {
178: attack(tp, obj, FALSE);
179: }
180: else if (mvwinch(mw, tp->t_newpos.y, tp->t_newpos.x) &&
181: step_ok(tp->t_newpos.y, tp->t_newpos.x, FIGHTOK, tp)) {
182: skirmish(tp, &tp->t_newpos, obj, FALSE);
183: }
184:
185: when A_SELL:
186: /* Is the player still next to us? */
187: if (ce(tp->t_newpos, hero)) sell(tp);
188:
189: /* The darned player moved away */
190: else if (off(player, ISBLIND) &&
191: cansee(unc(tp->t_pos)) &&
192: (off(*tp, ISINVIS) || on(player, CANSEE)) &&
193: (off(*tp, ISSHADOW) || on(player, CANSEE)) &&
194: (off(*tp, CANSURPRISE) || ISWEARING(R_ALERT)))
195: msg("%s grunts with frustration",prname(monster_name(tp),TRUE));
196:
197: when A_MOVE:
198: /* Let's try to move */
199: do_chase(tp);
200:
201: /* If t_no_move > 0, we found that we have to fight! */
202: if (tp->t_no_move > 0) return;
203:
204: when A_BREATHE:
205: /* Breathe on the critter */
206: m_breathe(tp);
207:
208: when A_SLOW:
209: /* make him move slower */
210: add_slow();
211: turn_off(*tp, CANSLOW);
212:
213: when A_MISSILE:
214: /* Start up a magic missile spell */
215: m_spell(tp);
216:
217: when A_SONIC:
218: /* Let out a sonic blast! */
219: m_sonic(tp);
220:
221: when A_THROW:
222: /* We're throwing something (like an arrow) */
223: missile(tp->t_newpos.y, tp->t_newpos.x, tp->t_using, tp);
224:
225: when A_SUMMON:
226: /* We're summoning help */
227: m_summon(tp);
228:
229: when A_USERELIC:
230: /* Use our relic */
231: m_use_relic(tp);
232:
233: when A_USEWAND:
234: /* use the wand we have */
235: m_use_wand(tp);
236: }
237:
238: /* No action now */
239: tp->t_action = A_NIL;
240: tp->t_using = NULL;
241: }
242:
243: /*
244: * m_breathe:
245: * Breathe in the chosen direction.
246: */
247:
248: void
249: m_breathe(struct thing *tp)
250: {
251: register int damage;
252: register char *breath = "";
253:
254: damage = tp->t_stats.s_hpt;
255: turn_off(*tp, CANSURPRISE);
256:
257: /* Will it breathe at random */
258: if (on(*tp, CANBRANDOM)) {
259: /* Turn off random breath */
260: turn_off(*tp, CANBRANDOM);
261:
262: /* Select type of breath */
263: switch (rnd(10)) {
264: case 0: breath = "acid";
265: turn_on(*tp, NOACID);
266: when 1: breath = "flame";
267: turn_on(*tp, NOFIRE);
268: when 2: breath = "lightning bolt";
269: turn_on(*tp, NOBOLT);
270: when 3: breath = "chlorine gas";
271: turn_on(*tp, NOGAS);
272: when 4: breath = "ice";
273: turn_on(*tp, NOCOLD);
274: when 5: breath = "nerve gas";
275: turn_on(*tp, NOPARALYZE);
276: when 6: breath = "sleeping gas";
277: turn_on(*tp, NOSLEEP);
278: when 7: breath = "slow gas";
279: turn_on(*tp, NOSLOW);
280: when 8: breath = "confusion gas";
281: turn_on(*tp, ISCLEAR);
282: when 9: breath = "fear gas";
283: turn_on(*tp, NOFEAR);
284: }
285: }
286:
287: /* Or can it breathe acid? */
288: else if (on(*tp, CANBACID)) {
289: turn_off(*tp, CANBACID);
290: breath = "acid";
291: }
292:
293: /* Or can it breathe fire */
294: else if (on(*tp, CANBFIRE)) {
295: turn_off(*tp, CANBFIRE);
296: breath = "flame";
297: }
298:
299: /* Or can it breathe electricity? */
300: else if (on(*tp, CANBBOLT)) {
301: turn_off(*tp, CANBBOLT);
302: breath = "lightning bolt";
303: }
304:
305: /* Or can it breathe gas? */
306: else if (on(*tp, CANBGAS)) {
307: turn_off(*tp, CANBGAS);
308: breath = "chlorine gas";
309: }
310:
311: /* Or can it breathe ice? */
312: else if (on(*tp, CANBICE)) {
313: turn_off(*tp, CANBICE);
314: breath = "ice";
315: }
316:
317: else if (on(*tp, CANBPGAS)) {
318: turn_off(*tp, CANBPGAS);
319: breath = "nerve gas";
320: }
321:
322: /* can it breathe sleeping gas */
323: else if (on(*tp, CANBSGAS)) {
324: turn_off(*tp, CANBSGAS);
325: breath = "sleeping gas";
326: }
327:
328: /* can it breathe slow gas */
329: else if (on(*tp, CANBSLGAS)) {
330: turn_off(*tp, CANBSLGAS);
331: breath = "slow gas";
332: }
333:
334: /* can it breathe confusion gas */
335: else if (on(*tp, CANBCGAS)) {
336: turn_off(*tp, CANBCGAS);
337: breath = "confusion gas";
338: }
339:
340: /* can it breathe fear gas */
341: else {
342: turn_off(*tp, CANBFGAS);
343: breath = "fear gas";
344: }
345:
346: /* Now breathe -- sets "monst_dead" if it kills someone */
347: shoot_bolt(tp, tp->t_pos, tp->t_newpos, FALSE,
348: tp->t_index, breath, damage);
349:
350: running = FALSE;
351: if (fight_flush) md_flushinp();
352: }
353:
354: /*
355: * m_select:
356: * Select an action for the monster.
357: * flee: True if running away or player is inaccessible in wall
358: */
359:
360: void
361: m_select(struct thing *th, bool flee)
362: {
363: register struct room *rer, *ree; /* room of chaser, room of chasee */
364: int dist = MININT;
365: int mindist = MAXINT, maxdist = MININT;
366: bool rundoor; /* TRUE means run to a door */
367: char sch;
368: coord *last_door=0, /* Door we just came from */
369: this; /* Temporary destination for chaser */
370:
371: rer = roomin(&th->t_pos); /* Find room of chaser */
372: ree = roomin(th->t_dest); /* Find room of chasee */
373:
374: /* First see if we want to use an ability or weapon */
375: if (m_use_it(th, flee, rer, ree)) return;
376:
377: /*
378: * We don't count monsters on doors as inside rooms here because when
379: * a monster is in a room and the player is not in that room, the
380: * monster looks for the best door out. If we counted doors as part
381: * of the room, the monster would already be on the best door out;
382: * so he would never move.
383: */
384: if ((sch = CCHAR( mvwinch(stdscr, th->t_pos.y, th->t_pos.x) )) == DOOR ||
385: sch == SECRETDOOR || sch == PASSAGE) {
386: rer = NULL;
387: }
388: this = *th->t_dest;
389:
390: /*
391: * If we are in a room heading for the player and the player is not
392: * in the room with us, we run to the "best" door.
393: * If we are in a room fleeing from the player, then we run to the
394: * "best" door if he IS in the same room.
395: *
396: * Note: We don't bother with doors in mazes or if we can walk
397: * through walls.
398: */
399: if (rer != NULL && levtype != MAZELEV && off(*th, CANINWALL)) {
400: if (flee) rundoor = (rer == ree);
401: else rundoor = (rer != ree);
402: }
403: else rundoor = FALSE;
404:
405: if (rundoor) {
406: register struct linked_list *exitptr; /* For looping through exits */
407: coord *exit, /* A particular door */
408: *entrance; /* Place just inside doorway */
409: int exity, exitx; /* Door's coordinates */
410: char dch='\0'; /* Door character */
411:
412: if (th->t_doorgoal)
413: dch = CCHAR( mvwinch(stdscr, th->t_doorgoal->y, th->t_doorgoal->x) );
414:
415: /* Do we have a valid goal? */
416: if ((dch == PASSAGE || dch == DOOR) && /* A real door */
417: (!flee || !ce(*th->t_doorgoal, *th->t_dest))) { /* Prey should not
418: * be at door if
419: * we are running
420: * away
421: */
422: /* Make sure the player is not in the doorway, either */
423: entrance = doorway(rer, th->t_doorgoal);
424: if (!flee || entrance == NULL || !ce(*entrance, *th->t_dest)) {
425: this = *th->t_doorgoal;
426: dist = 0; /* Indicate that we have our door */
427: }
428: }
429:
430: /* Go through all the doors */
431: else for (exitptr = rer->r_exit; exitptr; exitptr = next(exitptr)) {
432: exit = DOORPTR(exitptr);
433: exity = exit->y;
434: exitx = exit->x;
435:
436: /* Make sure it is a real door */
437: dch = CCHAR( mvwinch(stdscr, exity, exitx) );
438: if (dch == PASSAGE || dch == DOOR) {
439: /* Don't count a door if we are fleeing from someone and
440: * he is standing on it. Also, don't count it if he is
441: * standing in the doorway.
442: */
443: if (flee) {
444: if (ce(*exit, *th->t_dest)) continue;
445:
446: entrance = doorway(rer, exit);
447: if (entrance != NULL && ce(*entrance, *th->t_dest))
448: continue;
449: }
450:
451: /* Were we just on this door? */
452: if (ce(*exit, th->t_oldpos)) last_door = exit;
453:
454: else {
455: dist = DISTANCE(th->t_dest->y, th->t_dest->x, exity, exitx);
456:
457: /* If fleeing, we want to maximize distance from door to
458: * what we flee, and minimize distance from door to us.
459: */
460: if (flee)
461: dist -= DISTANCE(th->t_pos.y, th->t_pos.x, exity, exitx);
462:
463: /* Maximize distance if fleeing, otherwise minimize it */
464: if ((flee && (dist > maxdist)) ||
465: (!flee && (dist < mindist))) {
466: th->t_doorgoal = exit; /* Use this door */
467: this = *exit;
468: mindist = maxdist = dist;
469: }
470: }
471: }
472: }
473:
474: /* Could we not find a door? */
475: if (dist == MININT) {
476: /* If we were on a door, go ahead and use it */
477: if (last_door) {
478: th->t_doorgoal = last_door;
479: this = th->t_oldpos;
480: dist = 0; /* Indicate that we found a door */
481: }
482: else th->t_doorgoal = NULL; /* No more door goal */
483: }
484:
485: /* Indicate that we do not want to flee from the door */
486: if (dist != MININT) flee = FALSE;
487: }
488: else th->t_doorgoal = 0; /* Not going to any door */
489:
490: /* Now select someplace to go and start the action */
491: chase(th, &this, rer, ree, flee);
492: }
493:
494: /*
495: * m_sonic:
496: * The monster is sounding a sonic blast.
497: */
498:
499: void
500: m_sonic(struct thing *tp)
501: {
502: register int damage;
503: static struct object blast =
504: {
505: MISSILE, {0, 0}, "", 0, "", "150" , NULL, 0, 0, 0, 0
506: };
507:
508: turn_off(*tp, CANSONIC);
509: turn_off(*tp, CANSURPRISE);
510: do_motion(&blast, tp->t_newpos.y, tp->t_newpos.x, tp);
511: damage = 150;
512: if (save(VS_BREATH, &player, -3))
513: damage /= 2;
514: msg ("%s's sonic blast hits you", prname(monster_name(tp), TRUE));
515: if ((pstats.s_hpt -= damage) <= 0)
516: death(tp->t_index);
517:
518: running = FALSE;
519: if (fight_flush) md_flushinp();
520: dsrpt_player();
521: }
522:
523: /*
524: * m_spell:
525: * The monster casts a spell. Currently this is limited to
526: * magic missile.
527: */
528: void
529: m_spell(struct thing *tp)
530: {
531: static struct object missile =
532: {
533: MISSILE, {0, 0}, "", 0, "", "0d4 " , NULL, 0, WS_MISSILE, 100, 1
534: };
535:
536: sprintf(missile.o_hurldmg, "%dd4", tp->t_stats.s_lvl);
537: do_motion(&missile, tp->t_newpos.y, tp->t_newpos.x, tp);
538: hit_monster(unc(missile.o_pos), &missile, tp);
539: turn_off(*tp, CANMISSILE);
540: turn_off(*tp, CANSURPRISE);
541:
542: running = FALSE;
543: if (fight_flush) md_flushinp();
544: }
545:
546: /*
547: * m_summon:
548: * Summon aid.
549: */
550:
551: void
552: m_summon(struct thing *tp)
553: {
554: register char *helpname, *mname;
555: int fail, numsum;
556: register int which, i;
557:
558: /* Let's make sure our prey is still here */
559: if (!cansee(unc(tp->t_pos)) || fallpos(&hero, FALSE, 2) == NULL) return;
560:
561: /*
562: * Non-uniques can only summon once. Uniques get fewer
563: * creatures with each successive summoning. Also, the
564: * probability of summoning goes down
565: */
566: if (off(*tp, ISUNIQUE))
567: turn_off(*tp, CANSUMMON);
568:
569: turn_off(*tp, CANSURPRISE);
570: mname = monster_name(tp);
571: helpname = monsters[tp->t_index].m_typesum;
572: which = findmindex(helpname);
573:
574: if ((off(*tp, ISINVIS) || on(player, CANSEE)) &&
575: (off(*tp, ISSHADOW) || on(player, CANSEE)) &&
576: (off(*tp, CANSURPRISE) || ISWEARING(R_ALERT))) {
577: if (monsters[which].m_normal == FALSE) { /* genocided? */
578: msg("%s appears dismayed", prname(mname, TRUE));
579: monsters[tp->t_index].m_numsum = 0;
580: }
581: else {
582: msg("%s summons %ss for help", prname(mname, TRUE), helpname);
583: }
584: }
585: else {
586: if (monsters[which].m_normal == FALSE) /* genocided? */
587: monsters[tp->t_index].m_numsum = 0;
588: else {
589: msg("%ss seem to appear from nowhere!", helpname);
590: }
591: }
592: numsum = monsters[tp->t_index].m_numsum;
593: if (numsum && on(*tp, ISUNIQUE)) { /* UNIQUEs summon less each time */
594: monsters[tp->t_index].m_numsum--;
595: tp->t_summon *= 2; /* cut probability in half */
596: }
597:
598: /*
599: * try to make all the creatures around player but remember
600: * if unsuccessful
601: */
602: for (i=0, fail=0; i<numsum; i++) {
603: if (!creat_mons(&player, which, FALSE))
604: fail++; /* remember the failures */
605: }
606:
607: /*
608: * try once again to make the buggers
609: */
610: for (i=0; i<fail; i++)
611: creat_mons(tp, which, FALSE);
612:
613: /* Now let the poor fellow see all the trouble */
614: light(&hero);
615: turn_on(*tp, HASSUMMONED);
616: }
617:
618: /*
619: * m_use_it:
620: * See if the monster (tp) has anything useful it can do
621: * (ie. an ability or a weapon) other than just move.
622: */
623:
624: bool
625: m_use_it(struct thing *tp, bool flee, struct room *rer, struct room *ree)
626: {
627: int dist;
628: register coord *ee = tp->t_dest, *er = &tp->t_pos;
629: coord *shoot_dir;
630: struct linked_list *weapon;
631: struct thing *prey;
632: bool dest_player; /* Are we after the player? */
633:
634: /*
635: * If we are fleeing, there's a chance, depending on our
636: * intelligence, that we'll just run in terror.
637: */
638: if (flee && rnd(25) >= tp->t_stats.s_intel) return(FALSE);
639:
640: /*
641: * Make sure that we have a living destination, and record whether
642: * it is the player.
643: */
644: if (ee != NULL) {
645: if (ce(*ee, hero)) {
646: dest_player = TRUE;
647: prey = &player;
648: }
649: else {
650: struct linked_list *item;
651:
652: dest_player = FALSE;
653:
654: /* What is the monster we're chasing? */
655: item = find_mons(ee->y, ee->x);
656: if (item != NULL) prey = THINGPTR(item);
657: else return(FALSE);
658: }
659: }
660: else return(FALSE);
661:
662: /*
663: * If we are friendly to the hero, we don't do anything.
664: */
665: if (on(*tp, ISFRIENDLY) && dest_player) return(FALSE);
666:
667: /*
668: * Also, for now, if our prey is in a wall, we won't do
669: * anything. The prey must be in the same room as we are OR
670: * we must have a straight shot at him. Note that
671: * shoot_dir must get set before rer is checked so
672: * that we get a valid value.
673: */
674: if (on(*prey, ISINWALL) ||
675: ((shoot_dir = can_shoot(er, ee)) == NULL &&
676: (rer == NULL || rer != ree)))
677: return(FALSE);
678:
679: /*
680: * If we can't see the prey then forget it
681: */
682: if (on(*prey, ISINVIS) && off(*tp, CANSEE))
683: return(FALSE);
684:
685: /* How far are we from our prey? */
686: dist = DISTANCE(er->y, er->x, ee->y, ee->x);
687:
688: /*
689: * Shall we summon aid so we don't have to get our hands dirty?
690: * For now, we will only summon aid against the player.
691: * We'll wait until he's within 2 dots of a missile length.
692: */
693: if (on(*tp, CANSUMMON) && dest_player &&
694: dist < (BOLT_LENGTH+2)*(BOLT_LENGTH+2) &&
695: rnd(tp->t_summon) < tp->t_stats.s_lvl &&
696: monsters[tp->t_index].m_numsum > 0 &&
697: fallpos(&hero, FALSE, 2) != NULL) {
698: tp->t_action = A_SUMMON; /* We're going to summon help */
699: tp->t_no_move = movement(tp); /* It takes time! */
700: return(TRUE);
701: }
702:
703: /*
704: * If the creature can cast a slow spell and if the prey is within
705: * 2 dots of a missile fire, then see whether we will cast it.
706: * if next to player, lessen chance because we don't like being
707: * disrupted
708: */
709: if (on(*tp, CANSLOW) && dest_player &&
710: dist < (BOLT_LENGTH+5)*(BOLT_LENGTH+5) &&
711: rnd(100) < (dist > 3 ? tp->t_cast : tp->t_cast/2)) {
712: tp->t_action = A_SLOW; /* We're going to slow him */
713: tp->t_no_move = 3 * movement(tp); /* Takes time! */
714: debug("casting slow spell!");
715: return(TRUE);
716: }
717:
718: /*
719: * If we have a special magic item, we might use it. We will restrict
720: * this options to uniques with relics and creatures with wands for now.
721: * Also check for the quartermaster. Don't want him shooting wands....
722: */
723: if ((on(*tp, ISUNIQUE) || on(*tp, CARRYSTICK)) &&
724: off(*tp, CANSELL) && dest_player &&
725: m_use_pack(tp, er, ee, dist, shoot_dir)) {
726: return(TRUE);
727: }
728:
729: /* From now on, we must have a direct shot at the prey */
730: if (shoot_dir == NULL) return(FALSE);
731:
732: /* We may use a sonic blast if we can, only on the player */
733: if (on(*tp, CANSONIC) &&
734: dest_player &&
735: (dist < BOLT_LENGTH*2) &&
736: (rnd(100) < tp->t_breathe)) {
737: tp->t_newpos = *shoot_dir; /* Save the direction */
738: tp->t_action = A_SONIC; /* We're going to sonic blast */
739: tp->t_no_move = 2 * movement(tp); /* Takes 2 movement periods */
740: }
741:
742: /* If we can breathe, we may do so */
743: else if (on(*tp, CANBREATHE) &&
744: (dist < BOLT_LENGTH*BOLT_LENGTH) &&
745: (rnd(100) < tp->t_breathe)) {
746: tp->t_newpos = *shoot_dir; /* Save the direction */
747: tp->t_action = A_BREATHE; /* We're going to breathe */
748: tp->t_no_move = movement(tp); /* It takes 1 movement period */
749: }
750:
751: /*
752: * We may shoot missiles if we can
753: * if next to player, lessen chance so we don't get disrupted as often
754: */
755: else if (on(*tp,CANMISSILE) &&
756: rnd(100) < (dist > 3 ? tp->t_cast : tp->t_cast/2)){
757: tp->t_newpos = *shoot_dir; /* Save the direction */
758: tp->t_action = A_MISSILE; /* We're going to shoot MM's */
759: tp->t_no_move = 3 * movement(tp); /* Takes time! */
760: }
761:
762: /*
763: * If we can shoot or throw something, we might do so.
764: * If next to player, then forget it
765: */
766: else if ((on(*tp,CANSHOOT) || on(*tp,CARRYWEAPON) ||
767: on(*tp,CARRYDAGGER) || on(*tp, CARRYAXE)) &&
768: dist > 3 &&
769: off(*tp, CANSELL) &&
770: (weapon = get_hurl(tp))) {
771: tp->t_newpos = *shoot_dir; /* Save the direction */
772: tp->t_action = A_THROW; /* We're going to throw something */
773: tp->t_using = weapon; /* Save our weapon */
774: tp->t_no_move = 2 * movement(tp); /* Takes 2 movement periods */
775: }
776:
777: /* We couldn't find anything to do */
778: else return(FALSE);
779:
780: return(TRUE);
781:
782: }
783:
784: /*
785: * runners:
786: * Make all the awake monsters try to do something.
787: * segments: Number of segments since last called
788: */
789:
790: int
791: runners(int segments)
792: {
793: register struct linked_list *item;
794: register struct thing *tp = NULL;
795: register int min_time = 20; /* Minimum time until a monster can act */
796:
797: /*
798: * loop thru the list of running (wandering) monsters and see what
799: * each one will do this time.
800: *
801: * Note: the special case that one of this buggers kills another.
802: * if this happens than we have to see if the monster killed
803: * himself or someone else. In case its himself we have to get next
804: * one immediately. If it wasn't we have to get next one at very
805: * end in case he killed the next one.
806: */
807:
808: for (item = mlist; item != NULL; item = next(item)) {
809: tp = THINGPTR(item);
810: turn_on(*tp, ISREADY);
811: }
812:
813: for (;;) {
814:
815: for (item = mlist; item != NULL; item = next(item)) {
816: tp = THINGPTR(item);
817:
818: if (on(*tp, ISREADY))
819: break;
820: }
821:
822: if (item == NULL)
823: break;
824:
825: turn_off(*tp, ISREADY);
826:
827: /* If we are not awake, just skip us */
828: if (off(*tp, ISRUN) && off(*tp, ISHELD)) continue;
829:
830: /* See if it's our turn */
831: tp->t_no_move -= segments;
832: if (tp->t_no_move > 0) {
833: if (tp->t_no_move < min_time) min_time = tp->t_no_move;
834: continue;
835: }
836:
837: /* If we were frozen, we're moving now */
838: if (tp->t_action == A_FREEZE) tp->t_action = A_NIL;
839:
840: if (on(*tp, ISHELD)) {
841: /* Make sure the action and using are nil */
842: tp->t_action = A_NIL;
843: tp->t_using = NULL;
844:
845: /* Can we break free? */
846: if (rnd(tp->t_stats.s_lvl) > 11) {
847: turn_off(*tp, ISHELD);
848: runto(tp, &hero);
849: if (cansee(tp->t_pos.y, tp->t_pos.x))
850: msg("%s breaks free from the hold spell",
851: prname(monster_name(tp), TRUE));
852: }
853:
854: /* Too bad -- try again later */
855: else tp->t_no_move = movement(tp);
856: }
857:
858: /* Heal the creature if it's not in the middle of some action */
859: if (tp->t_action == A_NIL) doctor(tp);
860:
861: while (off(*tp,ISELSEWHERE) &&
862: off(*tp,ISDEAD) &&
863: tp->t_no_move <= 0 && off(*tp, ISHELD) && on(*tp, ISRUN)) {
864: /* Let's act (or choose an action if t_action = A_NIL) */
865: m_act(tp);
866: }
867:
868: if (off(*tp,ISELSEWHERE) && off(*tp,ISDEAD)) {
869: if (tp->t_no_move < min_time) min_time = tp->t_no_move;
870: if (tp->t_quiet < 0) tp->t_quiet = 0;
871: }
872: }
873: return(min_time);
874: }
875:
876: /*
877: * See if a monster has some magic it can use. Return TRUE if so.
878: * Only care about relics and wands for now.
879: */
880: bool
881: m_use_pack(struct thing *monster, coord *monst_pos, coord *defend_pos,
882: int dist, coord *shoot_dir)
883: {
884: register struct object *obj;
885: register struct linked_list *pitem, *relic, *stick;
886: register int units = -1;
887:
888: relic = stick = NULL;
889:
890: for (pitem=monster->t_pack; pitem; pitem=next(pitem)) {
891: obj = OBJPTR(pitem);
892: if (obj->o_flags & ISCURSED) continue;
893: if (obj->o_type == RELIC) {
894: switch (obj->o_which) {
895: case MING_STAFF:
896: if (shoot_dir != NULL) {
897: units = 2; /* Use 2 time units */
898: relic = pitem;
899: }
900:
901: when EMORI_CLOAK:
902: if (obj->o_charges != 0 &&
903: shoot_dir != NULL) {
904: units = 2; /* Use 2 time units */
905: relic = pitem;
906: }
907:
908: when ASMO_ROD:
909: /* The bolt must be able to reach the defendant */
910: if (shoot_dir != NULL &&
911: dist < BOLT_LENGTH * BOLT_LENGTH) {
912: units = 2; /* Use 2 time units */
913: relic = pitem;
914: }
915:
916: when BRIAN_MANDOLIN:
917: /* The defendant must be the player and within 4 spaces */
918: if (ce(*defend_pos, hero) &&
919: dist < 25 &&
920: player.t_action != A_FREEZE) {
921: units = 4;
922: relic = pitem;
923: }
924:
925: when GERYON_HORN:
926: /* The defendant must be the player and within 5 spaces */
927: if (ce(*defend_pos, hero) &&
928: dist < 25 &&
929: (off(player,ISFLEE)|| player.t_dest!=&monster->t_pos)) {
930: units = 3;
931: relic = pitem;
932: }
933: }
934: }
935: if (obj->o_type == STICK) {
936: if (obj->o_charges < 1) continue;
937: switch(obj->o_which) {
938: case WS_ELECT:
939: case WS_FIRE:
940: case WS_COLD:
941: /* The bolt must be able to reach the defendant */
942: if (shoot_dir != NULL &&
943: dist < BOLT_LENGTH * BOLT_LENGTH) {
944: units = 3;
945: stick = pitem;
946: }
947:
948: when WS_MISSILE:
949: case WS_SLOW_M:
950: case WS_CONFMON:
951: case WS_PARALYZE:
952: case WS_MDEG:
953: case WS_FEAR:
954: if (shoot_dir != NULL) {
955: units = 3;
956: stick = pitem;
957: }
958:
959: otherwise:
960: break;
961: }
962: }
963: }
964:
965: /* use relics in preference to all others */
966: if (relic) debug("chance to use relic = %d%%", monster->t_artifact);
967: if (stick) debug("chance to use stick = %d%%", monster->t_wand);
968: if (relic && rnd(100) < monster->t_artifact) {
969: monster->t_action = A_USERELIC;
970: pitem = relic;
971: }
972: else if (stick && rnd(100) < monster->t_wand) {
973: /*
974: * see if the monster will use the wand
975: */
976: pitem = stick;
977: monster->t_action = A_USEWAND;
978: }
979: else {
980: return(FALSE);
981: }
982:
983: monster->t_no_move = units * movement(monster);
984: monster->t_using = pitem;
985: monster->t_newpos = *shoot_dir;
986: return(TRUE);
987: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to actions.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / arogue7