![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to them.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / games / warp|
Return to them.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / games / warp |
1.1 root 1: /* $Header: them.c,v 7.0.1.5 86/12/12 17:05:41 lwall Exp $ */
2:
3: /* $Log: them.c,v $
4: * Revision 7.0.1.5 86/12/12 17:05:41 lwall
5: * Baseline for net release.
6: *
7: * Revision 7.0.1.4 86/10/20 12:32:38 lwall
8: * Wasn't clearing FRIENDLY flag on pirate creation.
9: *
10: * Revision 7.0.1.3 86/10/20 12:15:33 lwall
11: * Was trying to create pirates from cloaked pirates.
12: *
13: * Revision 7.0.1.2 86/10/17 10:03:44 lwall
14: * Fixed Romulan writing spaces while cloaked.
15: *
16: * Revision 7.0.1.1 86/10/16 10:53:39 lwall
17: * Added Damage. Fixed random bugs.
18: *
19: * Revision 7.0 86/10/08 15:14:15 lwall
20: * Split into separate files. Added amoebas and pirates.
21: *
22: */
23:
24: #include "EXTERN.h"
25: #include "warp.h"
26: #include "bang.h"
27: #include "object.h"
28: #include "move.h"
29: #include "score.h"
30: #include "term.h"
31: #include "us.h"
32: #include "util.h"
33: #include "weapon.h"
34: #include "INTERN.h"
35: #include "them.h"
36:
37: void
38: them_init()
39: {
40: ;
41: }
42:
43: void
44: their_smarts()
45: {
46: Reg1 OBJECT *curkl;
47: Reg2 OBJECT *obj;
48: Reg3 int prob;
49: Reg4 int count;
50: Reg5 int y;
51: Reg6 int x;
52:
53: if (numcrushes && (obj=movers)->type == Crusher) {
54: if (numamoebas) {
55: y = obj->posy;
56: x = (obj->posx+(obj->image=='<'?1:-1)+XSIZE00)%XSIZE;
57: if (amb[y][x] == '~') {
58: obj->velx = 0; /* stop and munch amoeba */
59: modify_amoeba(y,x,1,' ',(int)rand_mod(5+ambsize/10)+1);
60: if (occupant[y][x] == nuke) /* except go for nucleus */
61: obj->velx = (obj->image=='<' ? 1 : -1);
62: }
63: else if (!obj->velx) {
64: if (!rand_mod(4))
65: obj->image = rand_mod(2) ? '<' : '>';
66: obj->velx = obj->image == '<' ? 1 : -1;
67: }
68: }
69: obj->vely += (rand_mod(222) - 111) / 100;
70: if (!(rand_mod(100))) {
71: setimage(obj, (obj->velx *= -1) < 0 ? '>' : '<');
72: }
73: }
74: if (numamoebas) {
75: if (!rand_mod(3))
76: nuke->velx = nuke->vely = 0;
77: if (nuke->strategy && ambsize < 90 && !rand_mod(200-smarts))
78: modify_amoeba(0,0,0,'~',(int)rand_mod(10));
79: if (ambsize > 200 || (ambsize > 100 && !rand_mod(15)))
80: modify_amoeba(yamblast,xamblast,2,' ',(ambsize-100)/5);
81: }
82: for (curkl = enemies; curkl->type == Enemy; curkl = curkl->next) {
83: if ((curkl->flags & (CLOAKS|FRIENDLY)) == CLOAKS &&
84: (curkl->image != ' ') &&
85: (curkl->energy > 300 || massacre) ) {
86: setimage(curkl, ' ');
87: }
88: if (madgorns)
89: prob = 3;
90: else if (curkl->vely || curkl->velx)
91: prob = massacre?10:20;
92: else if ((curkl->flags & (PIRATE|FRIENDLY)) == PIRATE) {
93: /* pirates want to sit sometimes */
94: if (curkl->strategy) {
95: if ((obj = lookimg(curkl->posy, curkl->posx, '@')) ||
96: (obj = lookimg(curkl->posy, curkl->posx, 'B')) ) {
97: make_plink(obj->posy, obj->posx);
98: if (!--curkl->strategy) { /* clock ran down */
99: if (obj->image == '@') {
100: obj->image = '*';
101: numinhab--;
102: if (obj->flags & STATIC)
103: mvaddch(obj->posy+1,obj->posx*2,obj->image);
104: if (curkl->energy < 20000)
105: curkl->energy += 5000;
106: }
107: prob = 2; /* our work here is done */
108: }
109: else if (obj->image == 'B') {
110: btorp -= rand_mod(50);
111: if (btorp < 0)
112: btorp = 0;
113: obj->energy -= rand_mod(500);
114: if (obj->energy < 0)
115: obj->energy = 0;
116: prob = 10000; /* stay here */
117: }
118: else
119: prob = 10000;
120: }
121: else { /* it went away--go elsewhere */
122: prob = 4;
123: curkl->strategy = 0;
124: }
125: }
126: else if (lookimg(curkl->posy, curkl->posx, '@') ||
127: lookimg(curkl->posy, curkl->posx, 'B')) {
128: curkl->strategy = rand_mod(15)+5;
129: prob = 10000;
130: }
131: else
132: prob = 4;
133: }
134: else if (curkl->image == 'M') { /* Mudd wants to sit sometimes */
135: if ((obj = lookimg(curkl->posy, curkl->posx, 'E')) ||
136: (obj = lookimg(curkl->posy, curkl->posx, 'B')) ) {
137: if (obj->image == 'B') {
138: btorp -= rand_mod(40);
139: if (btorp < 0)
140: btorp = 0;
141: obj->energy -= rand_mod(100);
142: if (obj->energy < 0)
143: obj->energy = 0;
144: }
145: else if (!obj->vely && !obj->velx) {
146: etorp -= rand_mod(10);
147: if (etorp < 0)
148: etorp = 0;
149: obj->energy -= rand_mod(20);
150: if (obj->energy < 0)
151: obj->energy = 0;
152: }
153: prob = 10000; /* stay here */
154: }
155: else /* it went away--go elsewhere */
156: prob = 4;
157: }
158: else if (curkl->flags & FRIENDLY) {
159: if (curkl->energy < 10000 &&
160: lookimg(curkl->posy, curkl->posx, '@') ) {
161: curkl->energy += 100;
162: prob = 20; /* do some loading */
163: }
164: else
165: prob = 4;
166: }
167: else if (curkl->image == '&') {
168: if (curkl->flags & COUNTDOWN) {
169: if (curkl->strategy)
170: curkl->strategy--;
171: else
172: curkl->flags &= ~COUNTDOWN;
173: prob = 100; /* someone's feeding us, so sit still */
174: }
175: else
176: prob = 4;
177: }
178: else
179: prob = 4; /* don't sit still too long */
180: count = 11;
181: for (;;) {
182: if (--count <= 0) /* no opening, just ram something */
183: break;
184:
185: #ifdef lint
186: prob = prob;
187: #endif
188: if (!(rand_mod(prob))) /* turn randomly occasionally */
189: goto accell;
190:
191: y=(curkl->posy+curkl->vely+YSIZE00)%YSIZE; /* find prospective */
192: x=(curkl->posx+curkl->velx+XSIZE00)%XSIZE; /* new position */
193:
194: if (numamoebas) {
195: if (curkl == nuke) {
196: if (amb[y][x] != '~')
197: goto accell; /* never move nucleus from protoplasm */
198: }
199: else {
200: if (amb[y][x] == '~' && rand_mod(2)) {
201: yamblast = y;
202: xamblast = x;
203: goto accell;
204: }
205: }
206: }
207:
208: obj = occupant[y][x];
209: if (!obj) break; /* is anyone there? */
210:
211: switch (obj->type) {
212: case Star:
213: if (obj->image == '@' && (curkl->flags & PIRATE)) {
214: if (curkl->image != 'P' && curkl->image != ' ') {
215: if (curkl->flags & FRIENDLY) {
216: curkl->flags &= ~FRIENDLY;
217: curkl->energy += 1000;
218: possiblescore += curkl->mass;
219: inumfriends--;
220: numfriends--;
221: inumenemies++;
222: numenemies++;
223: }
224: curkl->image = 'P';
225: }
226: break; /* go ahead and ram the star */
227: }
228: goto accell; /* try not to ram stars */
229: case Torp:
230: if (!obj->vely && !obj->velx && (rand_mod(100) <= smarts) &&
231: (obj->image == 'o' || obj->image == 'O' || obj->image == 'X'))
232: goto accell; /* try not to ram "friendly" torps */
233: break;
234: case Web:
235: if (curkl->image != 'T')
236: goto accell; /* non-Tholians shouldn't ram web */
237: if (count <= 5)
238: break; /* Tholians retrace web if desperate */
239: if (obj->image ==
240: (curkl->vely?
241: (curkl->velx?
242: (curkl->velx==curkl->vely?
243: '\\'
244: :
245: '/'
246: )
247: :
248: '|'
249: )
250: :
251: '-'
252: )
253: ) goto accell; /* Tholians try not to retrace web */
254: break; /* No problem with crossing web */
255: }
256: break; /* okay to move over object */
257:
258: accell:
259: /* determine maximum velocity */
260: if (massacre && curkl->image != 'T') {
261: curkl->vely = rand_mod(7) - 3;
262: curkl->velx = rand_mod(7) - 3;
263: }
264: else if (curkl->image == '&') {
265: if (rand_mod(2)) {
266: curkl->vely = rand_mod(3) - 1;
267: curkl->velx = rand_mod(3) - 1;
268: }
269: else {
270: curkl->vely = curkl->strategy & 3;
271: if (curkl->vely & 2)
272: curkl->vely = -1;
273: curkl->velx = (curkl->strategy >> 2) & 3;
274: if (curkl->velx & 2)
275: curkl->velx = -1;
276: }
277: }
278: else if (curkl->energy >= 2500 && curkl->image != 'T') {
279: curkl->vely = rand_mod(5) - 2;
280: curkl->velx = rand_mod(5) - 2;
281: }
282: else {
283: curkl->vely = rand_mod(3) - 1;
284: curkl->velx = rand_mod(3) - 1;
285: }
286: }
287: if (count != 10) {
288: if (curkl->image == ' ') {
289: setimage(curkl, curkl->flags & PIRATE ? 'P' : 'R');
290: }
291: if (!count) {
292: curkl->vely = 0;
293: curkl->velx = 0;
294: }
295: }
296: if (curkl->image == 'G' && (base||ent) &&
297: !rand_mod((103-smarts)*10) ) {
298: int xxx,yyy;
299:
300: for (xxx = -1; xxx<=1; xxx++)
301: for (yyy = -1; yyy<=1; yyy++)
302: if ((xxx||yyy) && rand_mod(2))
303: fire_torp(curkl,yyy,xxx);
304: }
305: else if (curkl->image == 'T' && (curkl->velx || curkl->vely)) {
306: Make_object(Web,
307: curkl->vely?
308: (curkl->velx?
309: (curkl->velx==curkl->vely?
310: '\\'
311: :
312: '/'
313: )
314: :
315: '|'
316: )
317: :
318: '-',
319: curkl->posy,curkl->posx,0,0,32767L,32767L,&root);
320: if (obj && obj->type == Web) {
321: unmake_object(obj);
322: occupant[y][x] = Null(OBJECT*);
323: }
324: }
325: }
326: /* klingon-style fighting */
327: if (numamoebas)
328: attack(nuke);
329: attack(base);
330: if (ent && (!cloaked || ent->image=='E' || ent->image=='e'))
331: attack(ent);
332: }
333:
334: void
335: modify_amoeba(y,x,where,ch,quant)
336: Reg1 int y;
337: Reg2 int x;
338: int where;
339: Reg6 int ch;
340: Reg7 int quant;
341: {
342: Reg3 int dy;
343: Reg4 int dx;
344: Reg5 int count = 15;
345:
346: if (!numamoebas)
347: return;
348: if (!where || (where==1 && rand_mod(2))) {
349: y = nuke->posy;
350: x = nuke->posx;
351: }
352: if (nuke->strategy && rand_mod(3)) {
353: dy = nuke->strategy & 3;
354: if (dy & 2)
355: dy = -1;
356: dx = (nuke->strategy >> 2) & 3;
357: if (dx & 2)
358: dx = -1;
359: if (ch == ' ') { /* take from the tail */
360: dy = -dy;
361: dx = -dx;
362: }
363: if (!rand_mod(100))
364: nuke->strategy = rand_mod(256);
365: }
366: else {
367: dy = rand_mod(3) - 1;
368: dx = rand_mod(3) - 1;
369: }
370: if (!dy && !dx)
371: return;
372: do {
373: if (--count < 0)
374: return;
375: y = (y + dy + YSIZE00) % YSIZE;
376: x = (x + dx + XSIZE00) % XSIZE;
377: } while (amb[y][x] != ' ');
378: if (ch == ' ') {
379: y = (y - dy + YSIZE00) % YSIZE;
380: x = (x - dx + XSIZE00) % XSIZE;
381: }
382: if (ambsize > 100 && quant > 2) {
383: quant >>= (ambsize/100);
384: }
385: if ((nuke->energy += quant << 6) > 32767)
386: nuke->energy = 32767;
387: count = quant << 3; /* endless loop catcher */
388: while (count-- > 0 && quant > 0) {
389: if (amb[y][x] != ch) {
390: quant--;
391: amb[y][x] = ch;
392: if (ch == '~') {
393: ambsize++;
394: yblasted[y] |= 2;
395: xblasted[x] |= 2;
396: blasted = TRUE;
397: }
398: else
399: ambsize--;
400: if (!occupant[y][x])
401: mvaddch(y+1,x*2,ch);
402: }
403: y = (y + rand_mod(3) + YSIZE99) % YSIZE;
404: x = (x + rand_mod(3) + XSIZE99) % XSIZE;
405: }
406: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.