?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/i915: Use the spin_lock_irq() family of functions (2/2)
[dragonfly.git] / games / trek / events.c
blob629b7261fe3aa2a696b6fe04e1cd3bd573f7b94f
1 /*-
2 * Copyright (c) 1980, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * @(#)events.c 8.1 (Berkeley) 5/31/93
30 * $FreeBSD: src/games/trek/events.c,v 1.4 1999/11/30 03:49:47 billf Exp $
31 * $DragonFly: src/games/trek/events.c,v 1.4 2008/04/20 13:44:24 swildner Exp $
32 */
33
34 #include "getpar.h"
35 #include "trek.h"
36
37 /*
38 ** CAUSE TIME TO ELAPSE
39 **
40 ** This routine does a hell of a lot. It elapses time, eats up
41 ** energy, regenerates energy, processes any events that occur,
42 ** and so on.
43 **
44 ** 'timewarp' is set if called in a time warp.
45 */
46
47 void
48 events(int t_warp)
49 {
50 int i;
51 int j = 0;
52 struct kling *k;
53 double rtime;
54 double xdate;
55 double idate;
56 struct event *ev = NULL;
57 char *s;
58 int ix, iy;
59 struct quad *q;
60 struct event *e;
61 int evnum;
62 int restcancel;
63
64 /* if nothing happened, just allow for any Klingons killed */
65 if (Move.time <= 0.0) {
66 Now.time = Now.resource / Now.klings;
67 return;
68 }
69
70 /* indicate that the cloaking device is now working */
71 Ship.cloakgood = 1;
72
73 /* idate is the initial date */
74 idate = Now.date;
75
76 /* schedule attacks if resting too long */
77 if (Move.time > 0.5 && Move.resting)
78 schedule(E_ATTACK, 0.5, 0, 0, 0);
79
80 /* scan the event list */
81 while (1) {
82 restcancel = 0;
83 evnum = -1;
84 /* xdate is the date of the current event */
85 xdate = idate + Move.time;
86
87 /* find the first event that has happened */
88 for (i = 0; i < MAXEVENTS; i++) {
89 e = &Event[i];
90 if (e->evcode == 0 || (e->evcode & E_GHOST))
91 continue;
92 if (e->date < xdate) {
93 xdate = e->date;
94 ev = e;
95 evnum = i;
96 }
97 }
98 e = ev;
99
100 /* find the time between events */
101 rtime = xdate - Now.date;
102
103 /* decrement the magic "Federation Resources" pseudo-variable */
104 Now.resource -= Now.klings * rtime;
105 /* and recompute the time left */
106 Now.time = Now.resource / Now.klings;
107
108 /* move us up to the next date */
109 Now.date = xdate;
110
111 /* check for out of time */
112 if (Now.time <= 0.0)
113 lose(L_NOTIME);
114 #ifdef xTRACE
115 if (evnum >= 0 && Trace)
116 printf("xdate = %.2f, evcode %d params %d %d %d\n",
117 xdate, e->evcode, e->x, e->y, e->systemname);
118 #endif
119
120 /* if evnum < 0, no events occurred */
121 if (evnum < 0)
122 break;
123
124 /* otherwise one did. Find out what it is */
125 switch (e->evcode & E_EVENT) {
126
127 case E_SNOVA: /* supernova */
128 /* cause the supernova to happen */
129 snova(-1, 0);
130 /* and schedule the next one */
131 xresched(e, E_SNOVA, 1);
132 break;
133
134 case E_LRTB: /* long range tractor beam */
135 /* schedule the next one */
136 xresched(e, E_LRTB, Now.klings);
137 /* LRTB cannot occur if we are docked */
138 if (Ship.cond != DOCKED) {
139 /* pick a new quadrant */
140 i = ranf(Now.klings) + 1;
141 for (ix = 0; ix < NQUADS; ix++) {
142 for (iy = 0; iy < NQUADS; iy++) {
143 q = &Quad[ix][iy];
144 if (q->stars >= 0)
145 if ((i -= q->klings) <= 0)
146 break;
147 }
148 if (i <= 0)
149 break;
150 }
151
152 /* test for LRTB to same quadrant */
153 if (Ship.quadx == ix && Ship.quady == iy)
154 break;
155
156 /* nope, dump him in the new quadrant */
157 Ship.quadx = ix;
158 Ship.quady = iy;
159 printf("\n%s caught in long range tractor beam\n", Ship.shipname);
160 printf("*** Pulled to quadrant %d,%d\n", Ship.quadx, Ship.quady);
161 Ship.sectx = ranf(NSECTS);
162 Ship.secty = ranf(NSECTS);
163 initquad(0);
164 /* truncate the move time */
165 Move.time = xdate - idate;
166 }
167 break;
168
169 case E_KATSB: /* Klingon attacks starbase */
170 /* if out of bases, forget it */
171 if (Now.bases <= 0) {
172 unschedule(e);
173 break;
174 }
175
176 /* check for starbase and Klingons in same quadrant */
177 for (i = 0; i < Now.bases; i++) {
178 ix = Now.base[i].x;
179 iy = Now.base[i].y;
180 /* see if a Klingon exists in this quadrant */
181 q = &Quad[ix][iy];
182 if (q->klings <= 0)
183 continue;
184
185 /* see if already distressed */
186 for (j = 0; j < MAXEVENTS; j++) {
187 e = &Event[j];
188 if ((e->evcode & E_EVENT) != E_KDESB)
189 continue;
190 if (e->x == ix && e->y == iy)
191 break;
192 }
193 if (j < MAXEVENTS)
194 continue;
195
196 /* got a potential attack */
197 break;
198 }
199 e = ev;
200 if (i >= Now.bases) {
201 /* not now; wait a while and see if some Klingons move in */
202 reschedule(e, 0.5 + 3.0 * franf());
203 break;
204 }
205 /* schedule a new attack, and a destruction of the base */
206 xresched(e, E_KATSB, 1);
207 e = xsched(E_KDESB, 1, ix, iy, 0);
208
209 /* report it if we can */
210 if (!damaged(SSRADIO)) {
211 printf("\nUhura: Captain, we have received a distress signal\n");
212 printf(" from the starbase in quadrant %d,%d.\n",
213 ix, iy);
214 restcancel++;
215 } else {
216 /* SSRADIO out, make it so we can't see the distress call */
217 /* but it's still there!!! */
218 e->evcode |= E_HIDDEN;
219 }
220 break;
221
222 case E_KDESB: /* Klingon destroys starbase */
223 unschedule(e);
224 q = &Quad[e->x][e->y];
225 /* if the base has mysteriously gone away, or if the Klingon
226 got tired and went home, ignore this event */
227 if (q->bases <=0 || q->klings <= 0)
228 break;
229 /* are we in the same quadrant? */
230 if (e->x == Ship.quadx && e->y == Ship.quady) {
231 /* yep, kill one in this quadrant */
232 printf("\nSpock: ");
233 killb(Ship.quadx, Ship.quady);
234 } else {
235 /* kill one in some other quadrant */
236 killb(e->x, e->y);
237 }
238 break;
239
240 case E_ISSUE: /* issue a distress call */
241 xresched(e, E_ISSUE, 1);
242 /* if we already have too many, throw this one away */
243 if (Ship.distressed >= MAXDISTR)
244 break;
245 /* try a bunch of times to find something suitable */
246 for (i = 0; i < 100; i++) {
247 ix = ranf(NQUADS);
248 iy = ranf(NQUADS);
249 q = &Quad[ix][iy];
250 /* need a quadrant which is not the current one,
251 which has some stars which are inhabited and
252 not already under attack, which is not
253 supernova'ed, and which has some Klingons in it */
254 if (!((ix == Ship.quadx && iy == Ship.quady) || q->stars < 0 ||
255 (q->qsystemname & Q_DISTRESSED) ||
256 (q->qsystemname & Q_SYSTEM) == 0 || q->klings <= 0))
257 break;
258 }
259 if (i >= 100)
260 /* can't seem to find one; ignore this call */
261 break;
262
263 /* got one!! Schedule its enslavement */
264 Ship.distressed++;
265 e = xsched(E_ENSLV, 1, ix, iy, q->qsystemname);
266 q->qsystemname = (e - Event) | Q_DISTRESSED;
267
268 /* tell the captain about it if we can */
269 if (!damaged(SSRADIO)) {
270 printf("\nUhura: Captain, starsystem %s in quadrant %d,%d is under attack\n",
271 Systemname[e->systemname], ix, iy);
272 restcancel++;
273 } else {
274 /* if we can't tell him, make it invisible */
275 e->evcode |= E_HIDDEN;
276 }
277 break;
278
279 case E_ENSLV: /* starsystem is enslaved */
280 unschedule(e);
281 /* see if current distress call still active */
282 q = &Quad[e->x][e->y];
283 if (q->klings <= 0) {
284 /* no Klingons, clean up */
285 /* restore the system name */
286 q->qsystemname = e->systemname;
287 break;
288 }
289
290 /* play stork and schedule the first baby */
291 e = schedule(E_REPRO, Param.eventdly[E_REPRO] * franf(), e->x, e->y, e->systemname);
292
293 /* report the disaster if we can */
294 if (!damaged(SSRADIO)) {
295 printf("\nUhura: We've lost contact with starsystem %s\n",
296 Systemname[e->systemname]);
297 printf(" in quadrant %d,%d.\n",
298 e->x, e->y);
299 } else
300 e->evcode |= E_HIDDEN;
301 break;
302
303 case E_REPRO: /* Klingon reproduces */
304 /* see if distress call is still active */
305 q = &Quad[e->x][e->y];
306 if (q->klings <= 0) {
307 unschedule(e);
308 q->qsystemname = e->systemname;
309 break;
310 }
311 xresched(e, E_REPRO, 1);
312 /* reproduce one Klingon */
313 ix = e->x;
314 iy = e->y;
315 if (Now.klings == 127)
316 break; /* full right now */
317 if (q->klings >= MAXKLQUAD) {
318 /* this quadrant not ok, pick an adjacent one */
319 for (i = ix - 1; i <= ix + 1; i++) {
320 if (i < 0 || i >= NQUADS)
321 continue;
322 for (j = iy - 1; j <= iy + 1; j++) {
323 if (j < 0 || j >= NQUADS)
324 continue;
325 q = &Quad[i][j];
326 /* check for this quad ok (not full & no snova) */
327 if (q->klings >= MAXKLQUAD || q->stars < 0)
328 continue;
329 break;
330 }
331 if (j <= iy + 1)
332 break;
333 }
334 if (j > iy + 1)
335 /* cannot create another yet */
336 break;
337 ix = i;
338 iy = j;
339 }
340 /* deliver the child */
341 q->klings++;
342 Now.klings++;
343 if (ix == Ship.quadx && iy == Ship.quady) {
344 /* we must position Klingon */
345 sector(&ix, &iy);
346 Sect[ix][iy] = KLINGON;
347 k = &Etc.klingon[Etc.nkling++];
348 k->x = ix;
349 k->y = iy;
350 k->power = Param.klingpwr;
351 k->srndreq = 0;
352 compkldist(Etc.klingon[0].dist == Etc.klingon[0].avgdist ? 0 : 1);
353 }
354
355 /* recompute time left */
356 Now.time = Now.resource / Now.klings;
357 break;
358
359 case E_SNAP: /* take a snapshot of the galaxy */
360 xresched(e, E_SNAP, 1);
361 s = Etc.snapshot;
362 s = bmove(Quad, s, sizeof (Quad));
363 s = bmove(Event, s, sizeof (Event));
364 s = bmove(&Now, s, sizeof (Now));
365 Game.snap = 1;
366 break;
367
368 case E_ATTACK: /* Klingons attack during rest period */
369 if (!Move.resting) {
370 unschedule(e);
371 break;
372 }
373 attack(1);
374 reschedule(e, 0.5);
375 break;
376
377 case E_FIXDV:
378 i = e->systemname;
379 unschedule(e);
380
381 /* de-damage the device */
382 printf("%s reports repair work on the %s finished.\n",
383 Device[i].person, Device[i].name);
384
385 /* handle special processing upon fix */
386 switch (i) {
387
388 case LIFESUP:
389 Ship.reserves = Param.reserves;
390 break;
391
392 case SINS:
393 if (Ship.cond == DOCKED)
394 break;
395 printf("Spock has tried to recalibrate your Space Internal Navigation System,\n");
396 printf(" but he has no standard base to calibrate to. Suggest you get\n");
397 printf(" to a starbase immediately so that you can properly recalibrate.\n");
398 Ship.sinsbad = 1;
399 break;
400
401 case SSRADIO:
402 restcancel = dumpssradio();
403 break;
404 }
405 break;
406
407 default:
408 break;
409 }
410
411 if (restcancel && Move.resting && getynpar("Spock: Shall we cancel our rest period"))
412 Move.time = xdate - idate;
413
414 }
415
416 /* unschedule an attack during a rest period */
417 if ((e = Now.eventptr[E_ATTACK]) != NULL)
418 unschedule(e);
419
420 if (!t_warp) {
421 /* eat up energy if cloaked */
422 if (Ship.cloaked)
423 Ship.energy -= Param.cloakenergy * Move.time;
424
425 /* regenerate resources */
426 rtime = 1.0 - exp(-Param.regenfac * Move.time);
427 Ship.shield += (Param.shield - Ship.shield) * rtime;
428 Ship.energy += (Param.energy - Ship.energy) * rtime;
429
430 /* decrement life support reserves */
431 if (damaged(LIFESUP) && Ship.cond != DOCKED)
432 Ship.reserves -= Move.time;
433 }
434 return;
435 }
DragonFly BSD