![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to daemon.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / urogue|
Return to daemon.c CVS log | Up to [contributed] / early-roguelike / urogue |
1.1 rubenllo 1: /*
2: daemon.c - functions for dealing with things that happen in the future
3:
4: UltraRogue: The Ultimate Adventure in the Dungeons of Doom
5: Copyright (C) 1985, 1986, 1992, 1993, 1995 Herb Chong
6: All rights reserved.
7:
8: Based on "Advanced Rogue"
9: Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka
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: /*
20: Needs to be rewritten again to work on a per creature basis.
21: Either each monster will have a list of effect, or each
22: fuse will take a creature pointer and multiple entries
23: for each fuse will be allowed. I tend to want to attach
24: the effects to the creature.
25: */
26:
27: #include "rogue.h"
28:
29: int demoncnt;
30:
31: struct daemon daemons[DAEMON_MAX] =
32: {
33: { DAEMON_NULL, NULL },
34: { DAEMON_DOCTOR, doctor },
35: { DAEMON_ROLLWAND, rollwand },
36: { DAEMON_STOMACH, stomach },
37: { DAEMON_RUNNERS, runners }
38: };
39:
40: struct fuse fuses[FUSE_MAX] =
41: {
42: { FUSE_NULL, NULL },
43: { FUSE_SWANDER, swander },
44: { FUSE_UNCONFUSE, unconfuse },
45: { FUSE_UNSCENT, unscent },
46: { FUSE_SCENT, scent },
47: { FUSE_UNHEAR, unhear },
48: { FUSE_HEAR, hear },
49: { FUSE_UNSEE, unsee },
50: { FUSE_UNSTINK, unstink },
51: { FUSE_UNCLRHEAD, unclrhead },
52: { FUSE_UNPHASE, unphase },
53: { FUSE_SIGHT, sight },
54: { FUSE_RES_STRENGTH, res_strength },
55: { FUSE_NOHASTE, nohaste },
56: { FUSE_NOSLOW, noslow },
57: { FUSE_SUFFOCATE, suffocate },
58: { FUSE_CURE_DISEASE, cure_disease },
59: { FUSE_UNITCH, un_itch },
60: { FUSE_APPEAR, appear },
61: { FUSE_UNELECTRIFY, unelectrify },
62: { FUSE_UNBHERO, unbhero },
63: { FUSE_UNSHERO, unshero },
64: { FUSE_UNXRAY, NULL },
65: { FUSE_UNDISGUISE, undisguise },
66: { FUSE_SHERO, shero },
67: { FUSE_WGHTCHK, wghtchk },
68: { FUSE_UNSUMMON, unsummon },
69: { FUSE_UNGAZE, ungaze },
70: { FUSE_UNCOLD, uncold },
71: { FUSE_UNHOT, unhot },
72: { FUSE_UNFLY, unfly },
73: { FUSE_UNBREATHE, unbreathe },
74: { FUSE_UNREGEN, unregen },
75: { FUSE_UNSUPEREAT, unsupereat },
76: { FUSE_UNSHIELD, unshield },
77: { FUSE_UNMSHIELD, unmshield },
78: { FUSE_UNTRUESEE, untruesee }
79: };
80:
81: /*
82: d_slot()
83: Find an empty slot in the daemon/fuse list
84: */
85:
86: struct delayed_action *
87: d_slot(void)
88: {
89: int i;
90: struct delayed_action *dev;
91:
92: for (i = 0, dev = d_list; i < MAXDAEMONS; i++, dev++)
93: if (dev->d_type == EMPTY)
94: return(dev);
95:
96: return(NULL);
97: }
98:
99:
100: /*
101: find_slot()
102: Find a particular slot in the table
103: */
104:
105: struct delayed_action *
106: find_slot(int type, int id)
107: {
108: int i;
109: struct delayed_action *dev;
110:
111: for (i = 0, dev = d_list; i < MAXDAEMONS; i++, dev++)
112: if ( (dev->d_type == type) && (id == dev->d_id) )
113: return(dev);
114:
115: return(NULL);
116: }
117:
118:
119: /*
120: daemon()
121: Start a daemon, takes a function.
122: */
123:
124: void
125: start_daemon(int id, void *arg, int whendo)
126: {
127: struct delayed_action *dev;
128:
129: dev = d_slot();
130:
131: if (dev != NULL)
132: {
133: dev->d_type = DAEMON;
134: dev->d_when = whendo;
135: dev->d_id = id;
136: dev->d_arg = arg;
137: dev->d_time = 1;
138: demoncnt += 1; /* update count */
139: }
140: }
141:
142:
143: /*
144: kill_daemon()
145: Remove a daemon from the list
146: */
147:
148: void
149: kill_daemon(int id)
150: {
151: struct delayed_action *dev;
152:
153: if ((dev = find_slot(DAEMON, id)) == NULL)
154: return;
155:
156: /* Take it out of the list */
157:
158: dev->d_type = EMPTY;
159: demoncnt -= 1; /* update count */
160:
161: return;
162: }
163:
164:
165: /*
166: do_daemons()
167: Run all the daemons that are active with the current flag,
168: passing the argument to the function.
169: */
170:
171: void
172: do_daemons(int now)
173: {
174: struct delayed_action *dev;
175:
176: /* Loop through the devil list */
177:
178: for (dev = d_list; dev < &d_list[MAXDAEMONS]; dev++)
179: /* Executing each one, giving it the proper arguments */
180: if ( (dev->d_when == now) && (dev->d_type == DAEMON))
181: {
182: if ((dev->d_id < 1) || (dev->d_id >= DAEMON_MAX))
183: printf("Bad daemon id %d\n", dev->d_id);
184: else if (daemons[dev->d_id].func == NULL)
185: printf("No action for daemon %d!!!\n", dev->d_id);
186: else
187: {
188: daemon_arg arg;
189:
190: arg.varg = dev->d_arg;
191: daemons[dev->d_id].func(&arg);
192: }
193: }
194:
195: }
196:
197:
198: /*
199: fuse()
200: Start a fuse to go off in a certain number of turns
201: */
202:
203: void
204: light_fuse(int id, void *arg, int time, int whendo)
205: {
206: struct delayed_action *wire;
207:
208: wire = d_slot();
209:
210: if (wire != NULL)
211: {
212: wire->d_type = FUSE;
213: wire->d_when = whendo;
214: wire->d_id = id;
215: wire->d_arg = arg;
216: wire->d_time = time;
217: demoncnt += 1; /* update count */
218: }
219: }
220:
221:
222: /*
223: lengthen()
224: Increase the time until a fuse goes off
225: */
226:
227: void
228: lengthen_fuse(int id, int xtime)
229: {
230: struct delayed_action *wire;
231:
232: if ((wire = find_slot(FUSE,id)) == NULL)
233: return;
234:
235: wire->d_time += xtime;
236:
237: return;
238: }
239:
240:
241: /*
242: extinguish()
243: Put out a fuse
244: */
245:
246: void
247: extinguish_fuse(int id)
248: {
249: struct delayed_action *wire;
250:
251: if ((wire = find_slot(FUSE,id)) == NULL)
252: return;
253:
254: wire->d_type = EMPTY;
255: demoncnt -= 1;
256:
257: return;
258: }
259:
260:
261: /*
262: do_fuses()
263: Decrement counters and start needed fuses
264: */
265:
266: void
267: do_fuses(int now)
268: {
269: struct delayed_action *wire;
270:
271: /* Step though the list */
272:
273: for (wire = d_list; wire < &d_list[MAXDAEMONS]; wire++)
274: {
275: /*
276: * Decrementing counters and starting things we want. We
277: * also need to remove the fuse from the list once it has
278: * gone off.
279: */
280:
281: if( (wire->d_type == FUSE) && (wire->d_when == now) )
282: {
283: if (--wire->d_time <= 0)
284: {
285: if (wire->d_id < 0 || wire->d_id >= FUSE_MAX)
286: printf("Bad fuse id %d\n", wire->d_id);
287: else if (fuses[wire->d_id].func == NULL)
288: printf("No action for fuse %d!\n", wire->d_id);
289: else
290: {
291: fuse_arg arg;
292:
293: arg.varg = wire->d_arg;
294: fuses[wire->d_id].func(&arg);
295: }
296: wire->d_type = EMPTY;
297: demoncnt -= 1;
298: }
299: }
300:
301: }
302:
303: return;
304: }
305:
306:
307: /*
308: activity()
309: Show wizard number of demaons and memory blocks used
310: */
311:
312: void
313: activity(void)
314: {
315: msg("Daemons = %d : Memory Items = %d ", demoncnt, total);
316: return;
317: }
318:
319: /*
320: waste_time()
321: Do nothing but let other things happen
322: */
323:
324: void
325: waste_time(void)
326: {
327: if (inwhgt) /* if from wghtchk then done */
328: return;
329:
330: do_daemons(BEFORE);
331: do_fuses(BEFORE);
332: do_daemons(AFTER);
333: do_fuses(AFTER);
334: }