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