![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kill.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / games / trek|
Return to kill.c CVS log | Up to [CSRG BSD Unix] / 43BSD / games / trek |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)kill.c 5.1 (Berkeley) 1/29/86";
9: #endif not lint
10:
11: # include "trek.h"
12:
13: /*
14: ** KILL KILL KILL !!!
15: **
16: ** This file handles the killing off of almost anything.
17: */
18:
19: /*
20: ** Handle a Klingon's death
21: **
22: ** The Klingon at the sector given by the parameters is killed
23: ** and removed from the Klingon list. Notice that it is not
24: ** removed from the event list; this is done later, when the
25: ** the event is to be caught. Also, the time left is recomputed,
26: ** and the game is won if that was the last klingon.
27: */
28:
29: killk(ix, iy)
30: int ix, iy;
31: {
32: register int i, j;
33:
34: printf(" *** Klingon at %d,%d destroyed ***\n", ix, iy);
35:
36: /* remove the scoundrel */
37: Now.klings -= 1;
38: Sect[ix][iy] = EMPTY;
39: Quad[Ship.quadx][Ship.quady].klings -= 1;
40: /* %%% IS THIS SAFE???? %%% */
41: Quad[Ship.quadx][Ship.quady].scanned -= 100;
42: Game.killk += 1;
43:
44: /* find the Klingon in the Klingon list */
45: for (i = 0; i < Etc.nkling; i++)
46: if (ix == Etc.klingon[i].x && iy == Etc.klingon[i].y)
47: {
48: /* purge him from the list */
49: Etc.nkling -= 1;
50: for (; i < Etc.nkling; i++)
51: bmove(&Etc.klingon[i+1], &Etc.klingon[i], sizeof Etc.klingon[i]);
52: break;
53: }
54:
55: /* find out if that was the last one */
56: if (Now.klings <= 0)
57: win();
58:
59: /* recompute time left */
60: Now.time = Now.resource / Now.klings;
61: return;
62: }
63:
64:
65: /*
66: ** handle a starbase's death
67: */
68:
69: killb(qx, qy)
70: int qx, qy;
71: {
72: register struct quad *q;
73: register struct xy *b;
74:
75: q = &Quad[qx][qy];
76:
77: if (q->bases <= 0)
78: return;
79: if (!damaged(SSRADIO))
80: /* then update starchart */
81: if (q->scanned < 1000)
82: q->scanned -= 10;
83: else
84: if (q->scanned > 1000)
85: q->scanned = -1;
86: q->bases = 0;
87: Now.bases -= 1;
88: for (b = Now.base; ; b++)
89: if (qx == b->x && qy == b->y)
90: break;
91: bmove(&Now.base[Now.bases], b, sizeof *b);
92: if (qx == Ship.quadx && qy == Ship.quady)
93: {
94: Sect[Etc.starbase.x][Etc.starbase.y] = EMPTY;
95: if (Ship.cond == DOCKED)
96: undock();
97: printf("Starbase at %d,%d destroyed\n", Etc.starbase.x, Etc.starbase.y);
98: }
99: else
100: {
101: if (!damaged(SSRADIO))
102: {
103: printf("Uhura: Starfleet command reports that the starbase in\n");
104: printf(" quadrant %d,%d has been destroyed\n", qx, qy);
105: }
106: else
107: schedule(E_KATSB | E_GHOST, 1e50, qx, qy, 0);
108: }
109: }
110:
111:
112: /**
113: ** kill an inhabited starsystem
114: **/
115:
116: kills(x, y, f)
117: int x, y; /* quad coords if f == 0, else sector coords */
118: int f; /* f != 0 -- this quad; f < 0 -- Enterprise's fault */
119: {
120: register struct quad *q;
121: register struct event *e;
122: register char *name;
123: char *systemname();
124:
125: if (f)
126: {
127: /* current quadrant */
128: q = &Quad[Ship.quadx][Ship.quady];
129: Sect[x][y] = EMPTY;
130: name = systemname(q);
131: if (name == 0)
132: return;
133: printf("Inhabited starsystem %s at %d,%d destroyed\n",
134: name, x, y);
135: if (f < 0)
136: Game.killinhab += 1;
137: }
138: else
139: {
140: /* different quadrant */
141: q = &Quad[x][y];
142: }
143: if (q->qsystemname & Q_DISTRESSED)
144: {
145: /* distressed starsystem */
146: e = &Event[q->qsystemname & Q_SYSTEM];
147: printf("Distress call for %s invalidated\n",
148: Systemname[e->systemname]);
149: unschedule(e);
150: }
151: q->qsystemname = 0;
152: q->stars -= 1;
153: }
154:
155:
156: /**
157: ** "kill" a distress call
158: **/
159:
160: killd(x, y, f)
161: int x, y; /* quadrant coordinates */
162: int f; /* set if user is to be informed */
163: {
164: register struct event *e;
165: register int i;
166: register struct quad *q;
167:
168: q = &Quad[x][y];
169: for (i = 0; i < MAXEVENTS; i++)
170: {
171: e = &Event[i];
172: if (e->x != x || e->y != y)
173: continue;
174: switch (e->evcode)
175: {
176: case E_KDESB:
177: if (f)
178: {
179: printf("Distress call for starbase in %d,%d nullified\n",
180: x, y);
181: unschedule(e);
182: }
183: break;
184:
185: case E_ENSLV:
186: case E_REPRO:
187: if (f)
188: {
189: printf("Distress call for %s in quadrant %d,%d nullified\n",
190: Systemname[e->systemname], x, y);
191: q->qsystemname = e->systemname;
192: unschedule(e);
193: }
194: else
195: {
196: e->evcode |= E_GHOST;
197: }
198: }
199: }
200: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.