![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to monsters.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / srogue|
Return to monsters.c CVS log | Up to [contributed] / early-roguelike / srogue |
1.1 rubenllo 1: /*
2: * File with various monster functions in it
3: *
4: * @(#)monsters.c 9.0 (rdk) 7/17/84
5: *
6: * Super-Rogue
7: * Copyright (C) 1984 Robert D. Kindelberger
8: * All rights reserved.
9: *
10: * Based on "Rogue: Exploring the Dungeons of Doom"
11: * Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
12: * All rights reserved.
13: *
14: * See the file LICENSE.TXT for full copyright and licensing information.
15: */
16:
17: #include <string.h>
18: #include "rogue.h"
19: #include <ctype.h>
20: #include "rogue.ext"
21:
22: /*
23: * rnd_mon:
24: * Pick a monster to show up. The lower the level,
25: * the meaner the monster.
26: */
27: char
28: rnd_mon(bool wander, bool baddie)
29: {
30: /* baddie; TRUE when from a polymorph stick */
31: reg int i, ok, cnt;
32:
33: cnt = 0;
34: if (levcount == 0) /* if only asmodeus possible */
35: return(MAXMONS);
36: if (baddie) {
37: while (1) {
38: i = rnd(MAXMONS); /* pick ANY monster */
39: if (monsters[i].m_lev.l_lev < 0) /* skip genocided ones */
40: continue;
41: return i;
42: }
43: }
44: ok = FALSE;
45: do {
46: /*
47: * get a random monster from this range
48: */
49: i = rnd(levcount);
50: /*
51: * Only create a wandering monster if we want one
52: * (or the count is exceeded)
53: */
54: if (!wander || mtlev[i]->m_lev.d_wand || ++cnt > 500)
55: ok = TRUE;
56: } while(!ok);
57: return (midx(mtlev[i]->m_show));
58: }
59:
60: /*
61: * lev_mon:
62: * This gets all monsters possible on this level
63: */
64: void
65: lev_mon(void)
66: {
67: reg int i;
68: reg struct monster *mm;
69:
70: levcount = 0;
71: for (i = 0; i < MAXMONS; i++) {
72: mm = &monsters[i];
73: if (mm->m_lev.h_lev >= level && mm->m_lev.l_lev <= level) {
74: mtlev[levcount] = mm;
75: if (++levcount >= MONRANGE)
76: break;
77: }
78: }
79: if (levcount == 0) /* if no monsters are possible */
80: mtlev[0] = &monsters[MAXMONS]; /* then asmodeus 'A' */
81: }
82:
83: /*
84: * new_monster:
85: * Pick a new monster and add it to the list
86: */
87: struct linked_list *
88: new_monster(char type, struct coord *cp, bool treas)
89: {
90: reg struct linked_list *item;
91: reg struct thing *tp;
92: reg struct monster *mp;
93: reg struct stats *st;
94: float killexp; /* experience gotten for killing him */
95:
96: item = new_item(sizeof(struct thing));
97: attach(mlist, item);
98: tp = THINGPTR(item);
99: st = &tp->t_stats;
100: mp = &monsters[type]; /* point to this monsters structure */
101: tp->t_type = mp->m_show;
102: tp->t_indx = type;
103: tp->t_pos = *cp;
104: tp->t_room = roomin(cp);
105: tp->t_oldch = mvwinch(cw, cp->y, cp->x);
106: tp->t_nomove = 0;
107: tp->t_nocmd = 0;
108: mvwaddch(mw, cp->y, cp->x, tp->t_type);
109:
110: /*
111: * copy monster data
112: */
113: tp->t_stats = mp->m_stats;
114:
115: /*
116: * If below amulet level, make the monsters meaner the
117: * deeper the hero goes.
118: */
119: if (level > AMLEVEL)
120: st->s_lvl += ((level - AMLEVEL) / 4);
121:
122: /*
123: * If monster in treasure room, then tougher.
124: */
125: if (treas)
126: st->s_lvl += 1;
127: if (levtype == MAZELEV)
128: st->s_lvl += 1;
129: /*
130: * If the hero is going back up, then the monsters are more
131: * prepared for him, so tougher.
132: */
133: if (goingup())
134: st->s_lvl += 1;
135:
136: /*
137: * Get hit points for monster depending on his experience
138: */
139: st->s_hpt = roll(st->s_lvl, 8);
140: st->s_maxhp = st->s_hpt;
141: /*
142: * Adjust experience point we get for killing it by the
143: * strength of this particular monster by ~~ +- 50%
144: */
145: killexp = mp->m_stats.s_exp * (0.47 + (float)st->s_hpt /
146: (8 * (float)st->s_lvl));
147:
148: st->s_exp = killexp; /* use float for accuracy */
149: if(st->s_exp < 1)
150: st->s_exp = 1; /* minimum 1 experience point */
151: tp->t_flags = mp->m_flags;
152: /*
153: * If monster in treasure room, then MEAN
154: */
155: if (treas || levtype == MAZELEV)
156: tp->t_flags |= ISMEAN;
157: tp->t_turn = TRUE;
158: tp->t_pack = NULL;
159: /*
160: * Dont wander if treas room
161: */
162: if (iswearing(R_AGGR) && !treas)
163: runto(cp, &hero);
164: if (tp->t_type == 'M') {
165: char mch;
166:
167: if (tp->t_pack != NULL)
168: mch = (OBJPTR(tp->t_pack))->o_type;
169: else {
170: switch (rnd(level >= AMLEVEL ? 9 : 8)) {
171: case 0: mch = GOLD;
172: when 1: mch = POTION;
173: when 2: mch = SCROLL;
174: when 3: mch = STAIRS;
175: when 4: mch = WEAPON;
176: when 5: mch = ARMOR;
177: when 6: mch = RING;
178: when 7: mch = STICK;
179: when 8: mch = AMULET;
180: }
181: }
182: if (treas)
183: mch = 'M'; /* no disguise in treasure room */
184: tp->t_disguise = mch;
185: }
186: return item;
187: }
188:
189: /*
190: * wanderer:
191: * A wandering monster has awakened and is headed for the player
192: */
193: void
194: wanderer(void)
195: {
196: reg int ch = '-';
197: reg struct room *rp, *hr = player.t_room;
198: reg struct linked_list *item;
199: reg struct thing *tp;
200: struct coord mp;
201:
202: do {
203: rp = &rooms[rnd_room()];
204: if (rp != hr || levtype == MAZELEV) {
205: mp = *rnd_pos(rp);
206: ch = mvinch(mp.y, mp.x);
207: }
208: } while (!step_ok(ch));
209: item = new_monster(rnd_mon(TRUE,FALSE), &mp, FALSE);
210: tp = THINGPTR(item);
211: tp->t_flags |= ISRUN;
212: tp->t_dest = &hero;
213: }
214:
215: /*
216: * wake_monster:
217: * What to do when the hero steps next to a monster
218: */
219: struct linked_list *
220: wake_monster(int y, int x)
221: {
222: reg struct thing *tp;
223: reg struct linked_list *it;
224: reg struct room *rp;
225: reg char ch;
226: bool treas = FALSE;
227:
228: if ((it = find_mons(y, x)) == NULL)
229: return NULL;
230: tp = THINGPTR(it);
231: ch = tp->t_type;
232: /*
233: * Every time he sees mean monster, it might start chasing him
234: */
235: rp = player.t_room;
236: if (rp != NULL && rf_on(rp,ISTREAS)) {
237: tp->t_flags &= ~ISHELD;
238: treas = TRUE;
239: }
240: if (treas || (rnd(100) > 33 && on(*tp,ISMEAN) && off(*tp,ISHELD) &&
241: !iswearing(R_STEALTH))) {
242: tp->t_dest = &hero;
243: tp->t_flags |= ISRUN;
244: }
245: if (ch == 'U' && pl_off(ISBLIND)) {
246: if ((rp != NULL && !rf_on(rp,ISDARK) && levtype != MAZELEV)
247: || DISTANCE(y, x, hero.y, hero.x) < 3) {
248: if (off(*tp,ISFOUND) && !save(VS_PETRIFICATION)
249: && !iswearing(R_SUSAB) && pl_off(ISINVINC)) {
250: msg("The umber hulk's gaze has confused you.");
251: if (pl_on(ISHUH))
252: lengthen(unconfuse,rnd(20)+HUHDURATION);
253: else
254: fuse(unconfuse,TRUE,rnd(20)+HUHDURATION);
255: player.t_flags |= ISHUH;
256: }
257: tp->t_flags |= ISFOUND;
258: }
259: }
260: /*
261: * Hide invisible monsters
262: */
263: if ((tp->t_flags & ISINVIS) && pl_off(CANSEE))
264: ch = mvinch(y, x);
265: /*
266: * Let greedy ones guard gold
267: */
268: if (on(*tp, ISGREED) && off(*tp, ISRUN)) {
269: if (rp != NULL && rp->r_goldval) {
270: tp->t_dest = &rp->r_gold;
271: tp->t_flags |= ISRUN;
272: }
273: }
274: return it;
275: }
276:
277: /*
278: * genocide:
279: * Eradicate a monster forevermore
280: */
281: void
282: genocide(void)
283: {
284: reg struct linked_list *ip, *nip;
285: reg struct thing *mp;
286: struct monster *mm;
287: reg int i, ii, c;
288:
289: if (levcount == 0) {
290: mpos = 0;
291: msg("You cannot genocide Asmodeus !!");
292: return;
293: }
294: tryagain:
295: i = TRUE; /* assume an error now */
296: while (i) {
297: msg("Which monster (remember UPPER & lower case)?");
298: c = readchar(); /* get a char */
299: if (c == ESCAPE) { /* he can abort (the fool) */
300: msg("");
301: return;
302: }
303: if (isalpha(c)) /* valid char here */
304: i = FALSE; /* exit the loop */
305: else { /* he didn't type a letter */
306: mpos = 0;
307: msg("Please specify a letter between 'A' and 'z'");
308: }
309: }
310: i = midx(c); /* get index to monster */
311: mm = &monsters[i];
312: if (mm->m_lev.l_lev < 0) {
313: mpos = 0;
314: msg("You have already eliminated the %s.",mm->m_name);
315: goto tryagain;
316: }
317: for (ip = mlist; ip != NULL; ip = nip) {
318: mp = THINGPTR(ip);
319: nip = next(ip);
320: if (mp->t_type == c)
321: remove_monster(&mp->t_pos, ip);
322: }
323: mm->m_lev.l_lev = -1; /* get rid of it */
324: mm->m_lev.h_lev = -1;
325: lev_mon(); /* redo monster list */
326: mpos = 0;
327: msg("You have wiped out the %s.",mm->m_name);
328: }
329:
330: /*
331: * unhold:
332: * Release the player from being held
333: */
334: void
335: unhold(char whichmon)
336: {
337: struct linked_list *item;
338: struct thing *mon;
339:
340: switch (whichmon) {
341: case 'F':
342: fung_hit = 0;
343: for (item = mlist; item != NULL; item = next(item)) {
344: mon = THINGPTR(item);
345: if (mon->t_type == 'F')
346: strcpy(mon->t_stats.s_dmg, "000d0");
347: }
348: case 'd':
349: player.t_flags &= ~ISHELD;
350: }
351: }
352:
353: /*
354: * midx:
355: * This returns an index to 'whichmon'
356: */
357: int
358: midx(char whichmon)
359: {
360: if (isupper(whichmon))
361: return(whichmon - 'A'); /* 0 to 25 for uppercase */
362: else if (islower(whichmon))
363: return(whichmon - 'a' + 26); /* 26 to 51 for lowercase */
364: else
365: return(MAXMONS); /* 52 for Asmodeus */
366: }
367:
368: /*
369: * monhurt:
370: * See when monster should run or fight. Return
371: * TRUE if hit points less than acceptable.
372: */
373: bool
374: monhurt(struct thing *th)
375: {
376: reg int ewis, crithp, f1, f2;
377: reg struct stats *st;
378:
379: st = &th->t_stats;
380: ewis = st->s_ef.a_wis;
381: if (ewis <= MONWIS) /* stupid monsters dont know */
382: return FALSE;
383: f1 = st->s_maxhp / 4; /* base hpt for being hurt */
384: f2 = (ewis - MONWIS) * 5 / 3; /* bonus for smart monsters */
385: if (th->t_flags & ISWOUND) /* if recovering from being */
386: f1 *= 2; /* wounded, then double the base */
387: crithp = f1 + f2; /* get critical hpt for hurt */
388: if (crithp > st->s_maxhp) /* only up to max hpt */
389: crithp = st->s_maxhp;
390: if (st->s_hpt < crithp) /* if < critical, then still hurt */
391: return TRUE;
392: return FALSE;
393: }