![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to us.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 us.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / games / warp |
1.1 root 1: /* $Header: us.c,v 7.0.1.3 87/01/13 17:13:21 lwall Exp $ */
2:
3: /* $Log: us.c,v $
4: * Revision 7.0.1.3 87/01/13 17:13:21 lwall
5: * Partially fixed ^S behavior. It now just ignores ^S.
6: *
7: * Revision 7.0.1.2 86/12/12 17:06:09 lwall
8: * Baseline for net release.
9: *
10: * Revision 7.0.1.1 86/10/16 10:53:50 lwall
11: * Added Damage. Fixed random bugs.
12: *
13: * Revision 7.0 86/10/08 15:14:21 lwall
14: * Split into separate files. Added amoebas and pirates.
15: *
16: */
17:
18: #include "EXTERN.h"
19: #include "warp.h"
20: #include "bang.h"
21: #include "object.h"
22: #include "play.h"
23: #include "sig.h"
24: #include "term.h"
25: #include "util.h"
26: #include "weapon.h"
27: #include "INTERN.h"
28: #include "us.h"
29:
30: void
31: us_init()
32: {
33: ;
34: }
35:
36: void
37: do_direction(dy,dx)
38: int dy, dx;
39: {
40: Reg1 int decr;
41: Reg2 OBJECT *obj;
42:
43: if (status < 2) {
44: if (cloaking) {
45: char ch;
46:
47: cloaked = FALSE;
48: ch = (ent->energy >= 500?'E':'e');
49: if (ch != ent->image) {
50: setimage(ent, ch);
51: }
52: }
53: decr = 5+abs(evely)+abs(evelx)+tractor*tractor;
54: if (ent->energy >= decr) {
55: ent->energy -= decr;
56: if (tractor) {
57: if (!damage || !damflag[NOTRACTORS]) {
58: if (!rand_mod(50)) {
59: damage++;
60: damflag[NOTRACTORS] = rand_mod(smarts+10)+2;
61: }
62: if (tract(ent,dy,dx,tractor)) {
63: evely += tractor*dy;
64: evelx += tractor*dx;
65: }
66: }
67: }
68: else if (!damage ||
69: (!entmode && !damflag[NOIMPULSE]) ||
70: (entmode && !damflag[NOWARP]) ) {
71: if (!rand_mod(30+500/(abs(evely)+abs(evelx)+1))) {
72: damage++;
73: damflag[entmode?NOWARP:NOIMPULSE] = rand_mod(smarts+10)+2;
74: }
75: evely += dy;
76: evelx += dx;
77: }
78: if (inumthols &&
79: (obj=occupant[(ent->posy+evely+YSIZE00)%YSIZE]
80: [(ent->posx+evelx+XSIZE00)%XSIZE] ) &&
81: obj->type == Web)
82: evely = evelx = 0;
83: }
84: }
85: else if (status == 2) {
86: decr = 500+abs(bvely)*5+abs(bvelx)*5+tractor*tractor*100;
87: if (base->energy >= decr) {
88: base->energy -= decr;
89: if (tractor) {
90: if (tract(base,dy,dx,tractor)) {
91: bvely += tractor*dy;
92: bvelx += tractor*dx;
93: }
94: }
95: else {
96: bvely += dy;
97: bvelx += dx;
98: }
99: if (inumthols &&
100: (obj=occupant[(base->posy+bvely+YSIZE00)%YSIZE]
101: [(base->posx+bvelx+XSIZE00)%XSIZE] ) &&
102: obj->type == Web)
103: bvely = bvelx = 0;
104: }
105: }
106: tractor = 0;
107: }
108:
109: void
110: ctrl_direction(dy,dx)
111: int dy, dx;
112: {
113: if (status < 2) {
114: if (cloaking) {
115: char ch;
116:
117: cloaked = FALSE;
118: ch = (ent->energy >= 500?'E':'e');
119: if (ch != ent->image) {
120: setimage(ent, ch);
121: }
122: }
123: if (!damage || !damflag[NOPHASERS]) {
124: if (!rand_mod(200)) {
125: damage++;
126: damflag[NOPHASERS] = rand_mod(smarts+10)+2;
127: }
128: fire_phaser(ent, dy, dx);
129: }
130: }
131: else if (status == 2)
132: fire_phaser(base, dy, dx);
133: }
134:
135: void
136: shift_direction(dy,dx)
137: int dy, dx;
138: {
139: if (status < 2) {
140: if (cloaking) {
141: char ch;
142:
143: cloaked = FALSE;
144: ch = (ent->energy >= 500?'E':'e');
145: if (ch != ent->image) {
146: setimage(ent, ch);
147: }
148: }
149: if (!damage || !damflag[NOTORPS]) {
150: if (!rand_mod(300)) {
151: damage++;
152: damflag[NOTORPS] = rand_mod(smarts+10)+2;
153: }
154: fire_torp(ent, dy, dx);
155: }
156: }
157: else if (status == 2)
158: fire_torp(base, dy, dx);
159: }
160:
161: void
162: get_commands(done)
163: bool *done;
164: {
165: static char ch[80];
166: Reg1 int i;
167: Reg2 int count;
168: Reg3 bool ctrla = FALSE;
169: char numdestructs = 0, numzaps = 0;
170:
171: top:
172: while (count = read_nd(ch,(sizeof ch))) {
173: for (i=0; i<count; i++) {
174: if (ch[i] == 'Q') {
175: bombed_out = TRUE;
176: *done = TRUE;
177: keepgoing = FALSE;
178: return;
179: }
180: if (ch[i] == 'q' || ch[i] == BREAKCH || ch[i] == INTRCH) {
181: int x;
182: static char quest[] = "Do you wish to escape from reality? ";
183:
184: if (timer >= whenok) {
185: mvaddstr(12,22,quest);
186: do {
187: getcmd(&ch[i]);
188: } while (ch[i] != 'y' && ch[i] != 'n');
189: if (ch[i] == 'y') {
190: bombed_out = TRUE;
191: *done = TRUE;
192: return;
193: }
194: else {
195: for (x=11; x<=28; x++) {
196: mvaddch(12,x*2,
197: occupant[11][x]
198: ? occupant[11][x]->image
199: : numamoebas
200: ? amb[11][x]
201: : ' ');
202: addspace();
203: }
204: roundsleep(2);
205: whenok = timer + 10;
206: goto top;
207: }
208: }
209: else {
210: write(1,"\07",1);
211: goto top;
212: }
213: }
214: }
215: for (i=0; i<count; i++) {
216: if (ctrla) {
217: switch (ch[i]) {
218: case '1': case 'b':
219: ctrl_direction(1, -1);
220: break;
221: case '2': case 'j':
222: ctrl_direction(1, 0);
223: break;
224: case '3': case 'n':
225: ctrl_direction(1, 1);
226: break;
227: case '4': case 'h':
228: ctrl_direction(0, -1);
229: break;
230: case '6': case 'l':
231: ctrl_direction(0, 1);
232: break;
233: case '7': case 'y':
234: ctrl_direction(-1, -1);
235: break;
236: case '8': case 'k':
237: ctrl_direction(-1, 0);
238: break;
239: case '9': case 'u':
240: ctrl_direction(-1, 1);
241: break;
242: case 'r':
243: rewrite();
244: roundsleep(3);
245: ctrla = FALSE;
246: goto top;
247: case 'w':
248: clear();
249: while (!input_pending())
250: sleep(1);
251: rewrite();
252: roundsleep(3);
253: ctrla = FALSE;
254: goto top;
255: #ifdef SIGTSTP
256: case 'z':
257: clear();
258: mytstp();
259: sleep(4);
260: ctrla = FALSE;
261: goto top;
262: #endif
263: default:
264: break;
265: }
266: ctrla = FALSE;
267: }
268: else {
269: switch (ch[i]) {
270: case 'Z':
271: clear();
272: mytstp();
273: sleep(4);
274: goto top;
275: case 'i':
276: if (ent && (!damage || !damflag[NOIMPULSE])) {
277: entmode = 0;
278: status = 0;
279: }
280: break;
281: case 'w':
282: if (ent && (!damage || !damflag[NOWARP])) {
283: entmode = 1;
284: status = 1;
285: }
286: break;
287: case 'p':
288: if (base) {
289: status = 2;
290: }
291: break;
292: case 'o':
293: if (status < 2) {
294: if (base)
295: status = 2;
296: }
297: else if (status == 2) {
298: if (ent)
299: status = entmode;
300: }
301: break;
302: case 'v':
303: if (ent) {
304: status = entmode;
305: }
306: cloaking=FALSE;
307: cloaked=FALSE;
308: break;
309: case 'c':
310: if (ent) {
311: status = entmode;
312: if (ent->energy >= 250)
313: cloaking = TRUE;
314: }
315: break;
316: case 'z':
317: if (ent && (!damage || !damflag[NOZAPPER])) {
318: ++numzaps;
319: if (!rand_mod(100/numzaps)) {
320: damage++;
321: damflag[NOZAPPER] = rand_mod(smarts+10)+2;
322: }
323: if (nxtbang && bangm[nxtbang-1] < 0)
324: --nxtbang; /* consolidate zaps */
325: make_blast(evely*2+ent->posy,evelx*2+ent->posx,
326: -5000000L, 3*numzaps);
327: ent->energy /= 2;
328: }
329: break;
330: case 'D':
331: if (status < 2 && (!damage || !damflag[NODESTRUCT])) {
332: if (ent && !rand_mod(10)) {
333: damage++;
334: damflag[NODESTRUCT] = rand_mod(smarts+10)+2;
335: }
336: if (++numdestructs <= 2)
337: make_blast(evely*2+ent->posy,evelx*2+ent->posx,
338: 15000L, 3);
339: ent->energy /= 4;
340: }
341: else if (status == 2) {
342: if (numdestructs)
343: base->energy = base->energy / 2;
344: if (++numdestructs <= 2)
345: make_blast(base->posy, base->posx, 15000L, 5);
346: }
347: break;
348: case 'd':
349: if ((!damage || !damflag[NODESTRUCT]) && (base||ent)) {
350: Reg4 OBJECT *obj;
351: int x, y;
352:
353: if (ent && !rand_mod(200)) {
354: damage++;
355: damflag[NODESTRUCT] = rand_mod(smarts+10)+2;
356: }
357: for (obj = root.prev;
358: obj != &root;
359: obj = obj->prev) {
360: if (obj->image == '+') {
361: blast[y=(obj->posy+obj->vely+YSIZE00)%YSIZE]
362: [x=(obj->posx+obj->velx+XSIZE00)%XSIZE]
363: += 1;
364: yblasted[y] |= 1;
365: xblasted[x] |= 1;
366: blasted = TRUE;
367: obj->mass = (massacre?3000:4000);
368: }
369: }
370: }
371: break;
372: case 's':
373: if ((!damage || !damflag[NODESTRUCT]) && (base||ent)) {
374: Reg4 OBJECT *obj;
375: if (ent && !rand_mod(200)) {
376: damage++;
377: damflag[NODESTRUCT] = rand_mod(smarts+10)+2;
378: }
379: for (obj = root.prev;
380: obj->type == Torp || obj->type == Web ||
381: obj->type == Star;
382: obj = obj->prev) {
383: if (obj->image == '+')
384: obj->vely = obj->velx = 0;
385: }
386: }
387: break;
388: case '\001':
389: ctrla = TRUE;
390: break;
391: case '\002':
392: case '\003':
393: case '\004':
394: case '\005':
395: case '\006':
396: case '\007':
397: case '\010':
398: case '\011':
399: case '\012':
400: case '\013':
401: case '\014':
402: case '\015':
403: case '\016':
404: case '\017':
405: case '\020':
406: case '\021':
407: case '\022':
408: case '\023':
409: case '\024':
410: case '\025':
411: case '\026':
412: case '\027':
413: case '\030':
414: case '\031':
415: case '\032':
416: ch[i] += 96;
417: i--;
418: ctrla = TRUE;
419: break;
420: case '\033':
421: tractor = 0;
422: break;
423: case 'a':
424: tractor++;
425: break;
426: case 'r':
427: tractor--;
428: break;
429: case '1': case 'b':
430: do_direction(1,-1);
431: break;
432: case '2': case 'j':
433: do_direction(1,0);
434: break;
435: case '3': case 'n':
436: do_direction(1,1);
437: break;
438: case '4': case 'h':
439: do_direction(0,-1);
440: break;
441: case '6': case 'l':
442: do_direction(0,1);
443: break;
444: case '7': case 'y':
445: do_direction(-1,-1);
446: break;
447: case '8': case 'k':
448: do_direction(-1,0);
449: break;
450: case '9': case 'u':
451: do_direction(-1,1);
452: break;
453: case '0': case 'S':
454: if (status < 2) {
455: evely = 0;
456: evelx = 0;
457: }
458: break;
459: case '-':
460: if (status < 2 && ent->energy >= 10) {
461: evely *= -1;
462: evelx *= -1;
463: ent->energy -= 10;
464: }
465: break;
466: case '%': case '\177': case '_':
467: shift_direction(0, -1);
468: shift_direction(0, 1);
469: shift_direction(-1, 0);
470: shift_direction(1, 0);
471: shift_direction(-1, -1);
472: shift_direction(-1, 1);
473: shift_direction(1, -1);
474: shift_direction(1, 1);
475: break;
476: case '!': case 'B':
477: shift_direction(1, -1);
478: break;
479: case '@': case 'J':
480: shift_direction(1, 0);
481: break;
482: case '#': case 'N':
483: shift_direction(1, 1);
484: break;
485: case '$': case 'H':
486: shift_direction(0, -1);
487: break;
488: case '^': case 'L':
489: shift_direction(0, 1);
490: break;
491: case '&': case 'Y':
492: shift_direction(-1, -1);
493: break;
494: case '*': case 'K':
495: shift_direction(-1, 0);
496: break;
497: case '(': case 'U':
498: shift_direction(-1, 1);
499: break;
500: case '?':
501: helper();
502: roundsleep(3);
503: goto top;
504: default:
505: break;
506: }
507: }
508: }
509: }
510: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.