|
3
|
1 /*
|
|
|
2 * redraw.c
|
|
|
3 */
|
|
|
4 #include "copyright.h"
|
|
|
5
|
|
|
6 #include <stdio.h>
|
|
|
7 #include <signal.h>
|
|
|
8 #include <math.h>
|
|
|
9 #include <ctype.h>
|
|
|
10 #include "Wlib.h"
|
|
|
11 #include "defs.h"
|
|
|
12 #include "struct.h"
|
|
|
13 #include "data.h"
|
|
|
14 #include "packets.h"
|
|
|
15 #include "proto.h"
|
|
|
16 #include "gameconf.h"
|
|
|
17 #ifdef SOUND
|
|
|
18 #include "Slib.h"
|
|
|
19 #endif
|
|
|
20 #include "sound.h"
|
|
|
21
|
|
|
22 typedef struct tractor Tractor;
|
|
|
23 struct tractor {
|
|
|
24 int sx, sy, d1x, d1y, d2x, d2y; /* source (x,y) dest (x1,y1) (x2,y2) */
|
|
|
25 Tractor *next;
|
|
|
26 } *tracthead = NULL, *tractcurrent = NULL, *tractrunner;
|
|
|
27
|
|
|
28 struct _clearzone *
|
|
|
29 new_czone()
|
|
|
30 {
|
|
|
31 if (clearzone == 0) {
|
|
|
32 czsize = 10;
|
|
|
33 clearzone = (struct _clearzone *) malloc(sizeof(*clearzone) * czsize);
|
|
|
34 clearcount = 0;
|
|
|
35 } else if (clearcount >= czsize) {
|
|
|
36 clearzone = (struct _clearzone *) realloc(clearzone,
|
|
|
37 sizeof(*clearzone) * (czsize *= 2));
|
|
|
38 }
|
|
|
39 return &clearzone[clearcount++];
|
|
|
40 }
|
|
|
41
|
|
|
42 /* Prototypes */
|
|
|
43 static void local P((void));
|
|
|
44 #ifndef COW_HAS_IT_WHY_SHOULDNT_WE
|
|
|
45 static
|
|
|
46 #endif
|
|
|
47 void map P((void));
|
|
|
48 static void redraw P((void));
|
|
|
49 /* static void stline P((int flag));*/
|
|
|
50 static W_Icon planetBitmap P((struct planet * p));
|
|
|
51 static W_Icon planetmBitmap P((struct planet * p));
|
|
|
52
|
|
|
53 void
|
|
|
54 intrupt()
|
|
|
55 {
|
|
|
56 static long lastread;
|
|
|
57 static struct timeval lastredraw = {0, 0};
|
|
|
58 struct timeval t;
|
|
|
59 static int needredraw=0;
|
|
|
60
|
|
|
61 #ifndef __osf__
|
|
|
62 long time();
|
|
|
63 #endif
|
|
|
64
|
|
|
65 udcounter++;
|
|
|
66
|
|
|
67 needredraw += readFromServer();
|
|
|
68
|
|
|
69 gettimeofday(&t, NULL);
|
|
|
70 if (needredraw && ((unsigned int) redrawDelay * 100000 <
|
|
|
71 (unsigned int) ((t.tv_sec - lastredraw.tv_sec) * 1000000
|
|
|
72 + (t.tv_usec - lastredraw.tv_usec)))) {
|
|
|
73 needredraw = 0;
|
|
|
74 lastredraw=t;
|
|
|
75 #if 0
|
|
|
76 lastread = time(NULL);
|
|
|
77 #endif
|
|
|
78 #ifdef RECORDER
|
|
|
79 if (!playback || (pb_update &&
|
|
|
80 ((!pb_scan) || !(udcounter % pb_advance))))
|
|
|
81 #endif
|
|
|
82 {
|
|
|
83 redraw();
|
|
|
84 playerlist2();
|
|
|
85 }
|
|
|
86 #ifdef RECORDER
|
|
|
87 if (playback) {
|
|
|
88 if(!pb_scan) {
|
|
|
89 if (pb_advance > 0) {
|
|
|
90 if ((pb_advance -= pb_update) <= 0) {
|
|
|
91 pb_advance = 0;
|
|
|
92 paused = 1;
|
|
|
93 }
|
|
|
94 } else if (pb_advance < 0) {
|
|
|
95 switch (pb_advance) {
|
|
|
96 case PB_REDALERT:
|
|
|
97 if (me->p_flags & PFRED) {
|
|
|
98 pb_advance = 0;
|
|
|
99 paused = 1;
|
|
|
100 }
|
|
|
101 break;
|
|
|
102 case PB_YELLOWALERT:
|
|
|
103 if (me->p_flags & PFYELLOW) {
|
|
|
104 pb_advance = 0;
|
|
|
105 paused = 1;
|
|
|
106 }
|
|
|
107 break;
|
|
|
108 case PB_DEATH:
|
|
|
109 default:
|
|
|
110 if (me->p_status != PALIVE) {
|
|
|
111 pb_advance = 0;
|
|
|
112 paused = 1;
|
|
|
113 }
|
|
|
114 break;
|
|
|
115 }
|
|
|
116 }
|
|
|
117 }
|
|
|
118 pb_update = 0;
|
|
|
119 }
|
|
|
120 if (recordGame)
|
|
|
121 writeUpdateMarker();
|
|
|
122 #endif
|
|
|
123 }
|
|
|
124 #if 0
|
|
|
125 if (lastread + 3 < time(NULL)) {
|
|
|
126 /*
|
|
|
127 We haven't heard from server for awhile... Strategy: send a
|
|
|
128 useless packet to "ping" server.
|
|
|
129 */
|
|
|
130 sendWarReq(me->p_hostile);
|
|
|
131 }
|
|
|
132 #endif
|
|
|
133 if (me->p_status == POUTFIT) {
|
|
|
134 death();
|
|
|
135 }
|
|
|
136 }
|
|
|
137
|
|
|
138 static void
|
|
|
139 redraw()
|
|
|
140 {
|
|
|
141
|
|
|
142 /* erase warning line if necessary */
|
|
|
143 if ((warntimer <= udcounter) && (warncount > 0)) {
|
|
|
144 #ifndef AMIGA
|
|
|
145 /* XFIX */
|
|
|
146 W_ClearArea(warnw, 5, 5, W_Textwidth * warncount, W_Textheight);
|
|
|
147 #else
|
|
|
148 W_ClearWindow(warnw);
|
|
|
149 #endif
|
|
|
150 warncount = 0;
|
|
|
151 }
|
|
|
152 if (W_FastClear) {
|
|
|
153 W_ClearWindow(w);
|
|
|
154 clearcount = 0;
|
|
|
155 clearlcount = 0;
|
|
|
156 tractcurrent = tracthead;
|
|
|
157 } else {
|
|
|
158 #if 0
|
|
|
159 /* just to save a little time on all the function calls */
|
|
|
160 /* all the normal clear functions are implemented as well. */
|
|
|
161 W_FlushClearZones(w, clearzone, clearcount);
|
|
|
162 clearcount = 0;
|
|
|
163 #else
|
|
|
164 while (clearcount) {
|
|
|
165 clearcount--;
|
|
|
166 /* XFIX */
|
|
|
167 W_CacheClearArea(w, clearzone[clearcount].x,
|
|
|
168 clearzone[clearcount].y, clearzone[clearcount].width,
|
|
|
169 clearzone[clearcount].height);
|
|
|
170
|
|
|
171 /*
|
|
|
172 W_ClearArea(w, clearzone[clearcount].x,
|
|
|
173 clearzone[clearcount].y, clearzone[clearcount].width,
|
|
|
174 clearzone[clearcount].height);
|
|
|
175 */
|
|
|
176 }
|
|
|
177 #endif
|
|
|
178 while (clearlcount) {
|
|
|
179 clearlcount--;
|
|
|
180 /* XFIX */
|
|
|
181 W_CacheLine(w, clearline[0][clearlcount],
|
|
|
182 clearline[1][clearlcount], clearline[2][clearlcount],
|
|
|
183 clearline[3][clearlcount], backColor);
|
|
|
184 /*
|
|
|
185 W_MakeLine(w, clearline[0][clearlcount],
|
|
|
186 clearline[1][clearlcount], clearline[2][clearlcount],
|
|
|
187 clearline[3][clearlcount], backColor);
|
|
|
188 */
|
|
|
189 }
|
|
|
190 /* XFIX */
|
|
|
191 #ifndef AMIGA
|
|
|
192 W_FlushClearAreaCache(w);
|
|
|
193 W_FlushLineCaches(w);
|
|
|
194 #endif
|
|
|
195 /* erase the tractor lines [BDyess] */
|
|
|
196 for (tractrunner = tracthead; tractrunner != tractcurrent;
|
|
|
197 tractrunner = tractrunner->next) {
|
|
|
198 W_MakeTractLine(w, tractrunner->sx, tractrunner->sy,
|
|
|
199 tractrunner->d1x, tractrunner->d1y,
|
|
|
200 backColor);
|
|
|
201 W_MakeTractLine(w, tractrunner->sx, tractrunner->sy,
|
|
|
202 tractrunner->d2x, tractrunner->d2y,
|
|
|
203 backColor);
|
|
|
204 }
|
|
|
205 tractcurrent = tracthead;
|
|
|
206 }
|
|
|
207
|
|
|
208 local(); /* redraw local window */
|
|
|
209
|
|
|
210 #ifdef AMIGA /* would do it in W_EventsPending, just have
|
|
|
211 it here so the display is updated sooner. */
|
|
|
212 W_Flush();
|
|
|
213 #endif
|
|
|
214
|
|
|
215 /* XFIX */
|
|
|
216 W_FlushLineCaches(w);
|
|
|
217
|
|
|
218 stline(0);
|
|
|
219
|
|
|
220 if (W_IsMapped(statwin))
|
|
|
221 updateStats();
|
|
|
222
|
|
|
223 updateInform(); /* check and update info window [BDyess] */
|
|
|
224
|
|
|
225 /* XFIX: last since its least accurate information */
|
|
|
226 if (mapmode)
|
|
|
227 map();
|
|
|
228
|
|
|
229 }
|
|
|
230
|
|
|
231 static W_Icon terrainBitmap(int x, int y)
|
|
|
232 {
|
|
|
233 int aster_bm = 0;
|
|
|
234 int aster_fluff = 0;
|
|
|
235
|
|
|
236 /* is no asteroids, then return fluff if adjacent 'roids */
|
|
|
237 if (!(terrainInfo[x*250 + y].types & T_ASTEROIDS)) aster_fluff = 1;
|
|
|
238
|
|
|
239 /* check surrounding terrain */
|
|
|
240 if (x > 0)
|
|
|
241 if (terrainInfo[(x-1)*250 + y].types & T_ASTEROIDS)
|
|
|
242 aster_bm |= (1<<0);
|
|
|
243 if (x < 249)
|
|
|
244 if (terrainInfo[(x+1)*250 + y].types & T_ASTEROIDS)
|
|
|
245 aster_bm |= (1<<2);
|
|
|
246 if (y > 0)
|
|
|
247 if (terrainInfo[x*250 + y-1].types & T_ASTEROIDS)
|
|
|
248 aster_bm |= (1<<3);
|
|
|
249 if (y < 249)
|
|
|
250 if (terrainInfo[x*250 + y+1].types & T_ASTEROIDS)
|
|
|
251 aster_bm |= (1<<1);
|
|
|
252
|
|
|
253 if (aster_fluff && aster_bm) return asteroidfluff[(x*250 + y)%3];
|
|
|
254 else return asteroidBM[aster_bm];
|
|
|
255 }
|
|
|
256
|
|
|
257 static W_Icon
|
|
|
258 planetBitmap(p)
|
|
|
259 register struct planet *p;
|
|
|
260 {
|
|
|
261 int i;
|
|
|
262 if (paradise) {
|
|
|
263 switch (PL_TYPE(*p)) {
|
|
|
264 case PLWHOLE:
|
|
|
265 return wormBM[udcounter % WORMFRAMES];
|
|
|
266 break;
|
|
|
267 case PLSTAR:
|
|
|
268 return starBM[udcounter % STARFRAMES];
|
|
|
269 break;
|
|
|
270 case PLAST:
|
|
|
271 return basteroid[0];
|
|
|
272 }
|
|
|
273 }
|
|
|
274 if (showlocal == 2) {
|
|
|
275 return (bplanets[0]);
|
|
|
276 } else if (p->pl_info & idx_to_mask(me->p_teami)) {
|
|
|
277 if (showlocal == 1 || showlocal == 4) {
|
|
|
278 i = 0;
|
|
|
279 if ((paradise) && (p->pl_flags & PLSHIPYARD))
|
|
|
280 i += 8;
|
|
|
281 if (p->pl_armies > 4)
|
|
|
282 i += 4;
|
|
|
283 if (p->pl_flags & PLREPAIR)
|
|
|
284 i += 2;
|
|
|
285 if (p->pl_flags & PLFUEL)
|
|
|
286 i += 1;
|
|
|
287 return ((showlocal == 1 ? bplanets2 : bplanetsMOO)[i]);
|
|
|
288 } else if (showlocal == 0) {
|
|
|
289 int team = mask_to_idx(p->pl_owner);
|
|
|
290 if (team < -1)
|
|
|
291 team = -1;
|
|
|
292 else if (team >= number_of_teams)
|
|
|
293 team = number_of_teams - 1;
|
|
|
294 return (bplanets[1 + team]);
|
|
|
295 } else {
|
|
|
296 int mask;
|
|
|
297 if (paradise)
|
|
|
298 mask = (p->pl_flags & PLSURMASK) >> PLSURSHIFT;
|
|
|
299 else {
|
|
|
300 mask = ((p->pl_flags & PLFUEL) ? 1 : 0)
|
|
|
301 | ((p->pl_flags & PLREPAIR) ? 2 : 0)
|
|
|
302 | ((p->pl_flags & PLAGRI) ? 4 : 0);
|
|
|
303 }
|
|
|
304 return bplanetsr[mask];
|
|
|
305 }
|
|
|
306 } else {
|
|
|
307 return (bplanets[5]);
|
|
|
308 }
|
|
|
309 }
|
|
|
310
|
|
|
311
|
|
|
312 static W_Icon
|
|
|
313 planetmBitmap(p)
|
|
|
314 register struct planet *p;
|
|
|
315 {
|
|
|
316 int i;
|
|
|
317 if (paradise) {
|
|
|
318 switch (p->pl_flags & PLTYPEMASK) {
|
|
|
319 case PLSTAR:
|
|
|
320 return mstarBM;
|
|
|
321 case PLAST:
|
|
|
322 return mbasteroid[0];
|
|
|
323 #ifdef VISIBLE_WORMHOLES
|
|
|
324 case PLWHOLE:
|
|
|
325 return mholeBM;
|
|
|
326 #endif /*VISIBLE_WORMHOLES*/
|
|
|
327 }
|
|
|
328 }
|
|
|
329 if (showgalactic == 2) {
|
|
|
330 return (mbplanets[0]);
|
|
|
331 } else if (showgalactic == 4) {
|
|
|
332 int infoage = 4;
|
|
|
333 if (!(p->pl_info & idx_to_mask(me->p_teami)))
|
|
|
334 return mbplanetsA[NSCOUTAGES - 1];
|
|
|
335 if (p->pl_owner == idx_to_mask(me->p_teami))
|
|
|
336 return mbplanetsA[0];
|
|
|
337
|
|
|
338 for (i = 0;
|
|
|
339 i < NSCOUTAGES - 1 && infoage < status2->clock - p->pl_timestamp;
|
|
|
340 i++, infoage = infoage * 5 / 3) {
|
|
|
341 }
|
|
|
342 return mbplanetsA[i];
|
|
|
343 } else if (p->pl_info & idx_to_mask(me->p_teami)) {
|
|
|
344 if (showgalactic == 1 || showgalactic == 5) {
|
|
|
345 i = 0;
|
|
|
346 if ((paradise) && (p->pl_flags & PLSHIPYARD))
|
|
|
347 i += 8;
|
|
|
348 if (p->pl_armies > 4)
|
|
|
349 i += 4;
|
|
|
350 if (p->pl_flags & PLREPAIR)
|
|
|
351 i += 2;
|
|
|
352 if (p->pl_flags & PLFUEL)
|
|
|
353 i += 1;
|
|
|
354 return ((showgalactic == 1 ? mbplanets2 : mbplanetsMOO)[i]);
|
|
|
355 } else if (showgalactic == 0) {
|
|
|
356 int team = mask_to_idx(p->pl_owner);
|
|
|
357 if (team < -1)
|
|
|
358 team = -1;
|
|
|
359 else if (team >= number_of_teams)
|
|
|
360 team = number_of_teams - 1;
|
|
|
361 return (mbplanets[1 + team]);
|
|
|
362 } else {
|
|
|
363 int mask;
|
|
|
364 if (paradise)
|
|
|
365 mask = (p->pl_flags & PLSURMASK) >> PLSURSHIFT;
|
|
|
366 else {
|
|
|
367 mask = ((p->pl_flags & PLFUEL) ? 1 : 0)
|
|
|
368 | ((p->pl_flags & PLREPAIR) ? 2 : 0)
|
|
|
369 | ((p->pl_flags & PLAGRI) ? 4 : 0);
|
|
|
370 }
|
|
|
371 return mbplanetsr[mask];
|
|
|
372 }
|
|
|
373 } else {
|
|
|
374 return (mbplanets[5]);
|
|
|
375 }
|
|
|
376 }
|
|
|
377
|
|
|
378 /* call this from local for each player, instead of having an extra loop! */
|
|
|
379 static void
|
|
|
380 redraw_photon_torps(j)
|
|
|
381 struct player *j;
|
|
|
382 {
|
|
|
383 int i, h;
|
|
|
384 struct torp *k;
|
|
|
385 int dx, dy;
|
|
|
386 int view;
|
|
|
387 struct _clearzone *cz;
|
|
|
388
|
|
|
389 view = SCALE * WINSIDE / 2;
|
|
|
390 i = j->p_no;
|
|
|
391 if (!j->p_ntorp)
|
|
|
392 return;
|
|
|
393 for (h = 0, k = &torps[ntorps * i + h]; h < ntorps; h++, k++) {
|
|
|
394 if (!k->t_status)
|
|
|
395 continue;
|
|
|
396 dx = k->t_x - me->p_x;
|
|
|
397 dy = k->t_y - me->p_y;
|
|
|
398 if (ABS(dx) > view || ABS(dy) > view) {
|
|
|
399 /* Call any torps off screen "free" (if owned by other) */
|
|
|
400 if (k->t_status == TEXPLODE && j != me) {
|
|
|
401 k->t_status = TFREE;
|
|
|
402 j->p_ntorp--;
|
|
|
403 }
|
|
|
404 continue;
|
|
|
405 }
|
|
|
406 dx = dx / SCALE + WINSIDE / 2;
|
|
|
407 dy = dy / SCALE + WINSIDE / 2;
|
|
|
408 #ifdef UNIX_SOUND
|
|
|
409 if ((k->t_status == TEXPLODE) && (k->t_fuse == 5)) play_sound (SND_TORPHIT);
|
|
|
410 #endif
|
|
|
411 if (k->t_status == TEXPLODE) {
|
|
|
412
|
|
|
413 k->t_fuse--;
|
|
|
414 if (k->t_fuse <= 0) {
|
|
|
415 k->t_status = TFREE;
|
|
|
416 j->p_ntorp--;
|
|
|
417 continue;
|
|
|
418 }
|
|
|
419 if (k->t_fuse >= NUMDETFRAMES) {
|
|
|
420 k->t_fuse = NUMDETFRAMES - 1;
|
|
|
421 }
|
|
|
422 W_WriteBitmap(dx - (cloud_width / 2), dy - (cloud_height / 2),
|
|
|
423 cloud[k->t_fuse], torpColor(k));
|
|
|
424 cz = new_czone();
|
|
|
425 cz->x = dx - (cloud_width / 2);
|
|
|
426 cz->y = dy - (cloud_height / 2);
|
|
|
427 cz->width = cloud_width;
|
|
|
428 cz->height = cloud_height;
|
|
|
429 } else if (k->t_owner != me->p_no && ((k->t_war & idx_to_mask(me->p_teami)) ||
|
|
|
430 (idx_to_mask(players[k->t_owner].p_teami) & (me->p_hostile | me->p_swar)))) {
|
|
|
431 /*
|
|
|
432 solid. Looks strange. W_FillArea(w, dx - (etorp_width/2), dy
|
|
|
433 - (etorp_height/2), etorp_width, etorp_height, torpColor(k));
|
|
|
434 */
|
|
|
435
|
|
|
436 #ifdef BORGTEST
|
|
|
437 W_CacheLine(w, dx - (etorp_width / 2), dy - (etorp_height / 2),
|
|
|
438 dx + (etorp_width / 2), dy + (etorp_height / 2),
|
|
|
439 (k->t_turns == 32767) ? notColor(k) : torpColor(k));
|
|
|
440 W_CacheLine(w, dx + (etorp_width / 2), dy - (etorp_height / 2),
|
|
|
441 dx - (etorp_width / 2), dy + (etorp_height / 2),
|
|
|
442 (k->t_turns == 32767) ? notColor(k) : torpColor(k));
|
|
|
443 #else
|
|
|
444 #ifdef TORPBITS
|
|
|
445 /*
|
|
|
446 went back to this for Amiga, one bitmap is faster than 2
|
|
|
447 lines.
|
|
|
448 */
|
|
|
449 W_WriteBitmap(dx - (etorp_width / 2), dy - (etorp_height / 2),
|
|
|
450 etorp, torpColor(k));
|
|
|
451 #else
|
|
|
452 /* XFIX */
|
|
|
453 if (0 && k->frame) {
|
|
|
454 W_CacheLine(w, dx - 2, dy,
|
|
|
455 dx + 2, dy, torpColor(k));
|
|
|
456 W_CacheLine(w, dx, dy - 2,
|
|
|
457 dx, dy + 2, torpColor(k));
|
|
|
458 } else {
|
|
|
459 W_CacheLine(w, dx - 1, dy - 1,
|
|
|
460 dx + 1, dy + 1, torpColor(k));
|
|
|
461 W_CacheLine(w, dx + 1, dy - 1,
|
|
|
462 dx - 1, dy + 1, torpColor(k));
|
|
|
463 }
|
|
|
464 k->frame = !k->frame;
|
|
|
465 #endif /* TORPBITS */
|
|
|
466 #endif
|
|
|
467
|
|
|
468 cz = new_czone();
|
|
|
469 cz->x = dx - (etorp_width / 2);
|
|
|
470 cz->y = dy - (etorp_height / 2);
|
|
|
471 cz->width = etorp_width;
|
|
|
472 cz->height = etorp_height;
|
|
|
473 } else {
|
|
|
474 /* XFIX */
|
|
|
475
|
|
|
476 if (0 /* animateTorps */ ) {
|
|
|
477 switch (k->frame) {
|
|
|
478 case 0:
|
|
|
479 W_CacheLine(w, dx - (mtorp_width / 2), dy, dx,
|
|
|
480 dy, torpColor(k));
|
|
|
481 break;
|
|
|
482 case 1:
|
|
|
483 W_CacheLine(w, dx - (mtorp_width / 2), dy - (mtorp_width / 2),
|
|
|
484 dx, dy, torpColor(k));
|
|
|
485 break;
|
|
|
486 case 2:
|
|
|
487 W_CacheLine(w, dx, dy, dx,
|
|
|
488 dy + (mtorp_width / 2), torpColor(k));
|
|
|
489 break;
|
|
|
490 case 3:
|
|
|
491 W_CacheLine(w, dx, dy,
|
|
|
492 dx + (mtorp_width / 2), dy - (mtorp_width / 2), torpColor(k));
|
|
|
493 break;
|
|
|
494 case 4:
|
|
|
495 W_CacheLine(w, dx, dy, dx + (mtorp_width / 2),
|
|
|
496 dy, torpColor(k));
|
|
|
497 break;
|
|
|
498 case 5:
|
|
|
499 W_CacheLine(w, dx - (mtorp_width / 2), dy - (mtorp_width / 2),
|
|
|
500 dx, dy, torpColor(k));
|
|
|
501 break;
|
|
|
502 case 6:
|
|
|
503 W_CacheLine(w, dx, dy - (mtorp_width / 2), dx,
|
|
|
504 dy, torpColor(k));
|
|
|
505 break;
|
|
|
506 case 7:
|
|
|
507 W_CacheLine(w, dx - (mtorp_width / 2), dy - (mtorp_width / 2),
|
|
|
508 dx, dy, torpColor(k));
|
|
|
509 break;
|
|
|
510 }
|
|
|
511 k->frame++;
|
|
|
512 if (k->frame > 7)
|
|
|
513 k->frame = 0;
|
|
|
514 } else {
|
|
|
515 #ifdef TORPBITS
|
|
|
516 W_WriteBitmap(dx - (mtorp_width / 2), dy - (mtorp_height / 2),
|
|
|
517 mtorp, torpColor(k));
|
|
|
518 #else
|
|
|
519 W_CacheLine(w, dx - (mtorp_width / 2), dy,
|
|
|
520 dx + (mtorp_width / 2), dy, torpColor(k));
|
|
|
521 W_CacheLine(w, dx, dy - (mtorp_width / 2),
|
|
|
522 dx, dy + (mtorp_width / 2), torpColor(k));
|
|
|
523 #endif
|
|
|
524 }
|
|
|
525
|
|
|
526 cz = new_czone();
|
|
|
527 cz->x = dx - (mtorp_width / 2);
|
|
|
528 cz->y = dy - (mtorp_height / 2);
|
|
|
529 cz->width = mtorp_width;
|
|
|
530 cz->height = mtorp_height;
|
|
|
531 }
|
|
|
532 }
|
|
|
533 }
|
|
|
534
|
|
|
535 static void
|
|
|
536 draw_one_thingy(k)
|
|
|
537 struct thingy *k;
|
|
|
538 {
|
|
|
539 int dx, dy;
|
|
|
540 int view;
|
|
|
541 struct _clearzone *cz;
|
|
|
542 view = SCALE * WINSIDE / 2;
|
|
|
543
|
|
|
544 if (k->t_shape == SHP_BLANK)
|
|
|
545 return;
|
|
|
546 /* printf("%d,%d - %d,%d\n", me->p_x, me->p_y, k->t_x, k->t_y); */
|
|
|
547 dx = k->t_x - me->p_x;
|
|
|
548 dy = k->t_y - me->p_y;
|
|
|
549 if (ABS(dx) > view || ABS(dy) > view) {
|
|
|
550 return;
|
|
|
551 }
|
|
|
552 dx = dx / SCALE + WINSIDE / 2;
|
|
|
553 dy = dy / SCALE + WINSIDE / 2;
|
|
|
554 switch (k->t_shape) {
|
|
|
555 case SHP_BOOM:
|
|
|
556 k->t_fuse--;
|
|
|
557 if (k->t_fuse <= 0) {
|
|
|
558 k->t_shape = SHP_BLANK;
|
|
|
559 return;
|
|
|
560 }
|
|
|
561 if (k->t_fuse >= NUMDETFRAMES) {
|
|
|
562 k->t_fuse = NUMDETFRAMES - 1;
|
|
|
563 }
|
|
|
564 W_WriteBitmap(dx - (cloud_width / 2), dy - (cloud_height / 2),
|
|
|
565 cloud[k->t_fuse], droneColor(k));
|
|
|
566 cz = new_czone();
|
|
|
567 cz->x = dx - (cloud_width / 2);
|
|
|
568 cz->y = dy - (cloud_height / 2);
|
|
|
569 cz->width = cloud_width;
|
|
|
570 cz->height = cloud_height;
|
|
|
571 break;
|
|
|
572 case SHP_MISSILE:
|
|
|
573 {
|
|
|
574 int dview = (int) (k->t_dir * NDRONEVIEWS + 128) / 256;
|
|
|
575 if (dview >= NDRONEVIEWS)
|
|
|
576 dview -= NDRONEVIEWS;
|
|
|
577 W_WriteBitmap
|
|
|
578 (dx - (drone_width / 2), dy - (drone_height / 2),
|
|
|
579 drone_bm[dview],
|
|
|
580 droneColor(k));
|
|
|
581 }
|
|
|
582 cz = new_czone();
|
|
|
583 cz->x = dx - (drone_width / 2);
|
|
|
584 cz->y = dy - (drone_height / 2);
|
|
|
585 cz->width = drone_width;
|
|
|
586 cz->height = drone_height;
|
|
|
587 break;
|
|
|
588 case SHP_TORP:
|
|
|
589 if (k->t_owner != me->p_no &&
|
|
|
590 ((k->t_war & idx_to_mask(me->p_teami)) ||
|
|
|
591 (idx_to_mask(players[k->t_owner].p_teami) & (me->p_hostile | me->p_swar)))) {
|
|
|
592 W_CacheLine(w, dx - (etorp_width / 2), dy - (etorp_height / 2),
|
|
|
593 dx + (etorp_width / 2), dy + (etorp_height / 2), torpColor(k));
|
|
|
594 W_CacheLine(w, dx + (etorp_width / 2), dy - (etorp_height / 2),
|
|
|
595 dx - (etorp_width / 2), dy + (etorp_height / 2), torpColor(k));
|
|
|
596 cz = new_czone();
|
|
|
597 cz->x = dx - (etorp_width / 2);
|
|
|
598 cz->y = dy - (etorp_height / 2);
|
|
|
599 cz->width = etorp_width;
|
|
|
600 cz->height = etorp_height;
|
|
|
601 } else {
|
|
|
602 W_CacheLine(w, dx - (mtorp_width / 2), dy, dx + (mtorp_width / 2), dy,
|
|
|
603 torpColor(k));
|
|
|
604 W_CacheLine(w, dx, dy - (mtorp_width / 2), dx, dy + (mtorp_width / 2),
|
|
|
605 torpColor(k));
|
|
|
606 cz = new_czone();
|
|
|
607 cz->x = dx - (mtorp_width / 2);
|
|
|
608 cz->y = dy - (mtorp_height / 2);
|
|
|
609 cz->width = mtorp_width;
|
|
|
610 cz->height = mtorp_height;
|
|
|
611 }
|
|
|
612 break;
|
|
|
613 case SHP_PLASMA:
|
|
|
614 case SHP_MINE: /* use plasma until I get a nifty bitmap */
|
|
|
615 if (k->t_owner != me->p_no &&
|
|
|
616 ((k->t_war & idx_to_mask(me->p_teami)) ||
|
|
|
617 (idx_to_mask(players[k->t_owner].p_teami) & (me->p_hostile | me->p_swar)))) {
|
|
|
618 W_WriteBitmap(dx - (eplasmatorp_width / 2),
|
|
|
619 dy - (eplasmatorp_height / 2),
|
|
|
620 eplasmatorp, torpColor(k));
|
|
|
621 cz = new_czone();
|
|
|
622 cz->x = dx - (eplasmatorp_width / 2);
|
|
|
623 cz->y = dy - (eplasmatorp_height / 2);
|
|
|
624 cz->width = eplasmatorp_width;
|
|
|
625 cz->height = eplasmatorp_height;
|
|
|
626 } else {
|
|
|
627 W_WriteBitmap(dx - (mplasmatorp_width / 2),
|
|
|
628 dy - (mplasmatorp_height / 2),
|
|
|
629 mplasmatorp, torpColor(k));
|
|
|
630 cz = new_czone();
|
|
|
631 cz->x = dx - (mplasmatorp_width / 2);
|
|
|
632 cz->y = dy - (mplasmatorp_height / 2);
|
|
|
633 cz->width = mplasmatorp_width;
|
|
|
634 cz->height = mplasmatorp_height;
|
|
|
635 }
|
|
|
636 break;
|
|
|
637 case SHP_PBOOM:
|
|
|
638 k->t_fuse--;
|
|
|
639 if (k->t_fuse <= 0) {
|
|
|
640 k->t_shape = SHP_BLANK;
|
|
|
641 return;
|
|
|
642 }
|
|
|
643 if (k->t_fuse >= NUMDETFRAMES) {
|
|
|
644 k->t_fuse = NUMDETFRAMES - 1;
|
|
|
645 }
|
|
|
646 W_WriteBitmap(dx - (plasmacloud_width / 2),
|
|
|
647 dy - (plasmacloud_height / 2),
|
|
|
648 plasmacloud[k->t_fuse], torpColor(k));
|
|
|
649 cz = new_czone();
|
|
|
650 cz->x = dx - (plasmacloud_width / 2);
|
|
|
651 cz->y = dy - (plasmacloud_height / 2);
|
|
|
652 cz->width = plasmacloud_width;
|
|
|
653 cz->height = plasmacloud_height;
|
|
|
654 break;
|
|
|
655 case SHP_FIGHTER:
|
|
|
656 {
|
|
|
657 int fview = (int) (k->t_dir * VIEWS + 128) / 256;
|
|
|
658 if (fview >= VIEWS)
|
|
|
659 fview -= VIEWS;
|
|
|
660 W_WriteBitmap(dx - (fighter_width / 2),
|
|
|
661 dy - (fighter_height / 2),
|
|
|
662 fighter[fview], torpColor(k));
|
|
|
663 cz = new_czone();
|
|
|
664 cz->x = dx - (fighter_width / 2);
|
|
|
665 cz->y = dy - (fighter_height / 2);
|
|
|
666 cz->width = fighter_width;
|
|
|
667 cz->height = fighter_height;
|
|
|
668 }
|
|
|
669 break;
|
|
|
670 case SHP_WARP_BEACON:
|
|
|
671 {
|
|
|
672 cz = new_czone();
|
|
|
673 cz->x = dx - (warpbeacon_width / 2);
|
|
|
674 cz->y = dy - (warpbeacon_height / 2);
|
|
|
675 cz->width = warpbeacon_width;
|
|
|
676 cz->height = warpbeacon_height;
|
|
|
677 W_WriteBitmap(cz->x, cz->y,
|
|
|
678 warpbeacon, W_White);
|
|
|
679 if (k->t_fuse > 4) {
|
|
|
680 W_WriteBitmap(cz->x, cz->y,
|
|
|
681 wbflash, shipCol[1 + mask_to_idx(k->t_owner)]);
|
|
|
682 }
|
|
|
683 if (++(k->t_fuse) > 6)
|
|
|
684 k->t_fuse = 0;
|
|
|
685 }
|
|
|
686 }
|
|
|
687 }
|
|
|
688
|
|
|
689 static void
|
|
|
690 redraw_drones(j)
|
|
|
691 struct player *j;
|
|
|
692 {
|
|
|
693 int i, h;
|
|
|
694 int count;
|
|
|
695
|
|
|
696 i = j->p_no;
|
|
|
697
|
|
|
698 if (!j->p_ndrone)
|
|
|
699 return;
|
|
|
700 count = 0;
|
|
|
701
|
|
|
702 for (h = i * npthingies; h < npthingies * (i + 1); h++) {
|
|
|
703 draw_one_thingy(&thingies[h]);
|
|
|
704 if (thingies[h].t_shape != SHP_BLANK)
|
|
|
705 count++;
|
|
|
706 }
|
|
|
707 j->p_ndrone = count;
|
|
|
708 }
|
|
|
709
|
|
|
710 static void
|
|
|
711 redraw_other_drones()
|
|
|
712 {
|
|
|
713 int h;
|
|
|
714
|
|
|
715 for (h = 0; h < ngthingies; h++)
|
|
|
716 draw_one_thingy(&thingies[nplayers * npthingies + h]);
|
|
|
717 }
|
|
|
718
|
|
|
719 static void
|
|
|
720 redraw_plasma_torps(j)
|
|
|
721 struct player *j;
|
|
|
722 {
|
|
|
723 int h, i;
|
|
|
724 register struct plasmatorp *pt;
|
|
|
725 struct _clearzone *cz;
|
|
|
726
|
|
|
727 int dx, dy;
|
|
|
728 int view;
|
|
|
729
|
|
|
730 view = SCALE * WINSIDE / 2;
|
|
|
731 i = j->p_no;
|
|
|
732
|
|
|
733 if (!j->p_nplasmatorp)
|
|
|
734 return;
|
|
|
735 for (h = 0, pt = &plasmatorps[nplasmas * i + h]; h < nplasmas; h++, pt++) {
|
|
|
736 if (!pt->pt_status)
|
|
|
737 continue;
|
|
|
738 dx = pt->pt_x - me->p_x;
|
|
|
739 dy = pt->pt_y - me->p_y;
|
|
|
740 if (ABS(dx) > view || ABS(dy) > view)
|
|
|
741 continue;
|
|
|
742 dx = dx / SCALE + WINSIDE / 2;
|
|
|
743 dy = dy / SCALE + WINSIDE / 2;
|
|
|
744 #ifdef UNIX_SOUND
|
|
|
745 if ((pt->pt_status == TEXPLODE) && (pt->pt_fuse == 5))
|
|
|
746 play_sound (SND_TORPHIT); /* Torp Hit used for Plasma Hit */
|
|
|
747 #endif
|
|
|
748 if (pt->pt_status == PTEXPLODE) {
|
|
|
749 pt->pt_fuse--;
|
|
|
750 if (pt->pt_fuse <= 0) {
|
|
|
751 pt->pt_status = PTFREE;
|
|
|
752 j->p_nplasmatorp--;
|
|
|
753 continue;
|
|
|
754 }
|
|
|
755 if (pt->pt_fuse >= NUMDETFRAMES) {
|
|
|
756 pt->pt_fuse = NUMDETFRAMES - 1;
|
|
|
757 }
|
|
|
758 W_WriteBitmap(dx - (plasmacloud_width / 2),
|
|
|
759 dy - (plasmacloud_height / 2),
|
|
|
760 plasmacloud[pt->pt_fuse], plasmatorpColor(pt));
|
|
|
761 cz = new_czone();
|
|
|
762 cz->x = dx - (plasmacloud_width / 2);
|
|
|
763 cz->y = dy - (plasmacloud_height / 2);
|
|
|
764 cz->width = plasmacloud_width;
|
|
|
765 cz->height = plasmacloud_height;
|
|
|
766 }
|
|
|
767 /* needmore: if(pt->pt_war & idx_to_mask(me->p_teami)) */
|
|
|
768 else if (pt->pt_owner != me->p_no && ((pt->pt_war & idx_to_mask(me->p_teami)) ||
|
|
|
769 (idx_to_mask(players[pt->pt_owner].p_teami) & (me->p_hostile | me->p_swar)))) {
|
|
|
770 W_WriteBitmap(dx - (eplasmatorp_width / 2),
|
|
|
771 dy - (eplasmatorp_height / 2),
|
|
|
772 eplasmatorp, plasmatorpColor(pt));
|
|
|
773 cz = new_czone();
|
|
|
774 cz->x = dx - (eplasmatorp_width / 2);
|
|
|
775 cz->y = dy - (eplasmatorp_height / 2);
|
|
|
776 cz->width = eplasmatorp_width;
|
|
|
777 cz->height = eplasmatorp_height;
|
|
|
778 } else {
|
|
|
779 W_WriteBitmap(dx - (mplasmatorp_width / 2),
|
|
|
780 dy - (mplasmatorp_height / 2),
|
|
|
781 mplasmatorp, plasmatorpColor(pt));
|
|
|
782 cz = new_czone();
|
|
|
783 cz->x = dx - (mplasmatorp_width / 2);
|
|
|
784 cz->y = dy - (mplasmatorp_height / 2);
|
|
|
785 cz->width = mplasmatorp_width;
|
|
|
786 cz->height = mplasmatorp_height;
|
|
|
787 }
|
|
|
788 }
|
|
|
789 }
|
|
|
790
|
|
|
791 #ifdef HOCKEY
|
|
|
792 void tactical_hockey P((void));
|
|
|
793 #endif
|
|
|
794
|
|
|
795 void
|
|
|
796 redraw_terrain()
|
|
|
797 {
|
|
|
798 int i,j;
|
|
|
799 int view;
|
|
|
800 int nx, ny; /* for adjusted coords, based on ship position */
|
|
|
801 int tx, ty, x; /* terrain grid x and y for 0,0 on the local */
|
|
|
802 struct _clearzone *cz;
|
|
|
803
|
|
|
804 view = SCALE * WINSIDE / 2;
|
|
|
805
|
|
|
806 nx = (int) ((me->p_x - view) / SCALE)%terrain_width;
|
|
|
807 ny = (int) ((me->p_y - view) / SCALE)%terrain_height;
|
|
|
808
|
|
|
809 ty = (int) ((me->p_y - view)/(GWIDTH/250));
|
|
|
810 x = tx = (int) ((me->p_x - view)/(GWIDTH/250));
|
|
|
811 if (ty < 0) ty = 0;
|
|
|
812 if (tx < 0) {
|
|
|
813 tx = 0;
|
|
|
814 x = 0;
|
|
|
815 }
|
|
|
816
|
|
|
817 if(received_terrain_info) {
|
|
|
818 for (i=0; i < WINSIDE; i += terrain_height) {
|
|
|
819 for (j=0; j < WINSIDE; j += terrain_width) {
|
|
|
820 if ((terrainInfo[tx*250+ty].types & T_ASTEROIDS) ||
|
|
|
821 ((tx > 0) && (terrainInfo[(tx-1)*250+ty].types & T_ASTEROIDS)) ||
|
|
|
822 ((tx < 249) && (terrainInfo[(tx+1)*250+ty].types & T_ASTEROIDS)) ||
|
|
|
823 ((ty > 0) && (terrainInfo[tx*250+(ty-1)].types & T_ASTEROIDS)) ||
|
|
|
824 ((tx < 249) && (terrainInfo[tx*250+(ty+1)].types & T_ASTEROIDS))) {
|
|
|
825 W_WriteBitmap(j-nx, i-ny, terrainBitmap(tx,ty), W_Grey);
|
|
|
826 cz = new_czone();
|
|
|
827 cz->x = j-nx;
|
|
|
828 cz->y = i-ny;
|
|
|
829 cz->width = terrain_width;
|
|
|
830 cz->height = terrain_height;
|
|
|
831 }
|
|
|
832 tx++;
|
|
|
833 if (tx >= 250) {
|
|
|
834 tx = x;
|
|
|
835 break;
|
|
|
836 }
|
|
|
837 }
|
|
|
838 ty++;
|
|
|
839 if (ty >= 250) break;
|
|
|
840 tx = x;
|
|
|
841 }
|
|
|
842 }
|
|
|
843 }
|
|
|
844
|
|
|
845 void
|
|
|
846 redraw_all_planets()
|
|
|
847 {
|
|
|
848 int view;
|
|
|
849 int i;
|
|
|
850 int dx, dy;
|
|
|
851 struct _clearzone *cz;
|
|
|
852 struct planet *l;
|
|
|
853 int nplan;
|
|
|
854
|
|
|
855 view = SCALE * WINSIDE / 2;
|
|
|
856 nplan = paradise ? nplanets : 40;
|
|
|
857
|
|
|
858 #ifdef HOCKEY
|
|
|
859 if(hockey) {
|
|
|
860 tactical_hockey();
|
|
|
861 }
|
|
|
862 #endif /*HOCKEY*/
|
|
|
863 for (i = 0, l = &planets[i]; i < nplan; i++, l++) {
|
|
|
864 dx = l->pl_x - me->p_x;
|
|
|
865 dy = l->pl_y - me->p_y;
|
|
|
866 if (ABS(dx) > view || ABS(dy) > view)
|
|
|
867 continue;
|
|
|
868 dx = dx / SCALE + WINSIDE / 2;
|
|
|
869 dy = dy / SCALE + WINSIDE / 2;
|
|
|
870 if (PL_TYPE(*l) == PLWHOLE)
|
|
|
871 W_WriteBitmap(dx - (wormhole_width / 2), dy - (wormhole_height / 2),
|
|
|
872 planetBitmap(l),
|
|
|
873 ((paradise) && (PL_TYPE(*l) == PLWHOLE))
|
|
|
874 ? textColor
|
|
|
875 : planetColor(l));
|
|
|
876 else
|
|
|
877 W_WriteBitmap(dx - (planet_width / 2), dy - (planet_height / 2),
|
|
|
878 planetBitmap(l),
|
|
|
879 ((paradise) && (PL_TYPE(*l) == PLSTAR))
|
|
|
880 ? textColor
|
|
|
881 : planetColor(l));
|
|
|
882 #ifdef SHOW_IND
|
|
|
883 if (showIND && (l->pl_info & idx_to_mask(me->p_teami)) && (l->pl_owner == NOBODY) && l->pl_flags & PLPLANET)
|
|
|
884 {
|
|
|
885 W_CacheLine (w, dx - (planet_width / 2), dy - (planet_height / 2),
|
|
|
886 dx + (planet_width / 2 - 1), dy + (planet_height / 2 - 1),
|
|
|
887 W_White);
|
|
|
888 W_CacheLine (w, dx + (planet_width / 2 - 1), dy - (planet_height / 2),
|
|
|
889 dx - (planet_width / 2), dy + (planet_height / 2 - 1),
|
|
|
890 W_White);
|
|
|
891 }
|
|
|
892 #endif
|
|
|
893 if (namemode) {
|
|
|
894 if (PL_TYPE(*l) != PLWHOLE) {
|
|
|
895 W_MaskText(w, dx - l->pl_namelen * W_Textwidth / 2, dy + (planet_height / 2),
|
|
|
896 ((paradise) && (PL_TYPE(*l) == PLSTAR))
|
|
|
897 ? textColor
|
|
|
898 : planetColor(l),
|
|
|
899 l->pl_name, l->pl_namelen, planetFont(l));
|
|
|
900 cz = new_czone();
|
|
|
901 cz->x = dx - l->pl_namelen * W_Textwidth / 2;
|
|
|
902 cz->y = dy + (planet_height / 2);
|
|
|
903 cz->width = W_Textwidth * l->pl_namelen;
|
|
|
904 cz->height = W_Textheight;
|
|
|
905 }
|
|
|
906 }
|
|
|
907 /* put letters and number next to */
|
|
|
908 /* planet bitmaps for resources and */
|
|
|
909 /* armies */
|
|
|
910 if (paradise && tacPlanetInfo) {
|
|
|
911 if (PL_TYPE(*l) == PLPLANET) {
|
|
|
912 char dspstr[8];
|
|
|
913 if (tacPlanetInfo & 1)
|
|
|
914 sprintf(dspstr, "%d", l->pl_armies);
|
|
|
915 if ((tacPlanetInfo & 2) && (l->pl_flags & PLREPAIR))
|
|
|
916 strcat(dspstr, "R");
|
|
|
917 if ((tacPlanetInfo & 4) && (l->pl_flags & PLFUEL))
|
|
|
918 strcat(dspstr, "F");
|
|
|
919 if ((tacPlanetInfo & 8) && (l->pl_flags & PLAGRI))
|
|
|
920 strcat(dspstr, "A");
|
|
|
921 if ((tacPlanetInfo & 16) && (l->pl_flags & PLSHIPYARD))
|
|
|
922 strcat(dspstr, "S");
|
|
|
923 cz = new_czone();
|
|
|
924 cz->x = dx + planet_width/2 + 2;
|
|
|
925 cz->y = dy;
|
|
|
926 cz->width = W_Textwidth * strlen(dspstr);
|
|
|
927 cz->height = W_Textheight;
|
|
|
928 W_MaskText(w, cz->x, cz->y,
|
|
|
929 planetColor(l), dspstr, strlen(dspstr),
|
|
|
930 planetFont(l));
|
|
|
931 }
|
|
|
932 }
|
|
|
933
|
|
|
934 /*--------draw tactical lock*/
|
|
|
935 if ((showLock & 2) && (me->p_flags & PFPLLOCK) && (me->p_planet == l->pl_no)) {
|
|
|
936 W_WriteTriangle(w, dx, dy - (planet_height) / 2 - 6, 5, 0, foreColor);
|
|
|
937 cz=new_czone();
|
|
|
938 cz->x=dx-5;
|
|
|
939 cz->y=dy - (planet_height) / 2 - 12;
|
|
|
940 cz->width=11;
|
|
|
941 cz->height=7;
|
|
|
942 }
|
|
|
943 cz = new_czone();
|
|
|
944 if (PL_TYPE(*l) == PLWHOLE) {
|
|
|
945 cz->x = dx - (wormhole_width / 2);
|
|
|
946 cz->y = dy - (wormhole_height / 2);
|
|
|
947 cz->width = wormhole_width;
|
|
|
948 cz->height = wormhole_height;
|
|
|
949 } else {
|
|
|
950 cz->x = dx - (planet_width / 2);
|
|
|
951 /*cz->y = dy - (planet_height / 2) - 13;*/
|
|
|
952 cz->y = dy - (planet_height / 2);
|
|
|
953 cz->width = planet_width;
|
|
|
954 /*cz->height = planet_height + 26;*/
|
|
|
955 cz->height = planet_height;
|
|
|
956 }
|
|
|
957 }
|
|
|
958 }
|
|
|
959
|
|
|
960 void
|
|
|
961 doShowMySpeed(dx, dy, ship_bits, j)
|
|
|
962 int dx, dy;
|
|
|
963 struct ship_shape *ship_bits;
|
|
|
964 struct player *j;
|
|
|
965 {
|
|
|
966 struct _clearzone *cz;
|
|
|
967 char idbuf[5];
|
|
|
968 int len;
|
|
|
969 int color;
|
|
|
970
|
|
|
971 sprintf(idbuf, "%c,%d", *(shipnos + j->p_no), me->p_speed);
|
|
|
972 len = strlen(idbuf);
|
|
|
973 /*
|
|
|
974 color the playernum,speed based on warp/afterburn/warpprep state
|
|
|
975 [BDyess]
|
|
|
976 */
|
|
|
977 switch (me->p_flags & (PFWARP | PFAFTER | PFWARPPREP)) {
|
|
|
978 case PFWARP:
|
|
|
979 color = W_Cyan;
|
|
|
980 me->p_flags &= ~PFWARPPREP;
|
|
|
981 break;
|
|
|
982 case PFAFTER:
|
|
|
983 color = rColor;
|
|
|
984 break;
|
|
|
985 case PFWARPPREP:
|
|
|
986 color = yColor;
|
|
|
987 break;
|
|
|
988 default: /* impulse */
|
|
|
989 if (me->p_speed > 0) {
|
|
|
990 color = gColor;
|
|
|
991 } else { /* stopped */
|
|
|
992 color = textColor;
|
|
|
993 }
|
|
|
994 break;
|
|
|
995 }
|
|
|
996 dx += ship_bits->width / 2;
|
|
|
997 dy -= ship_bits->height / 2;
|
|
|
998 /* underline number,speed if warp is suspended [BDyess] */
|
|
|
999 W_MaskText(w, dx, dy, color, idbuf, len, (me->p_flags & PFWPSUSPENDED) ?
|
|
|
1000 W_UnderlineFont : shipFont(j));
|
|
|
1001
|
|
|
1002 cz = new_czone();
|
|
|
1003 cz->x = dx;
|
|
|
1004 cz->y = dy;
|
|
|
1005 cz->width = len * W_Textwidth;
|
|
|
1006 cz->height = W_Textheight;
|
|
|
1007 }
|
|
|
1008
|
|
|
1009 #ifdef LOCAL_SHIPSTATS
|
|
|
1010 /* show just about anything next to ship on local display
|
|
|
1011 DSFAPWE - for each letter in statString, show a line for:
|
|
|
1012 Damage, Shields, Fuel, Armies, sPeed, Wtemp, Etemp
|
|
|
1013
|
|
|
1014 lower case = reverse length
|
|
|
1015 */
|
|
|
1016 static void
|
|
|
1017 doLocalShipstats()
|
|
|
1018 {
|
|
|
1019 char *sptr;
|
|
|
1020 int num=0, len, x=localStatsX, i;
|
|
|
1021 struct _clearzone *cz;
|
|
|
1022 W_Color color;
|
|
|
1023
|
|
|
1024 for(sptr=statString;*sptr;sptr++) {
|
|
|
1025 switch(toupper(*sptr)) {
|
|
|
1026 case 'W':
|
|
|
1027 len=(statHeight*me->p_wtemp) / me->p_ship->s_maxwpntemp;
|
|
|
1028 break;
|
|
|
1029 case 'E':
|
|
|
1030 len=(statHeight*me->p_etemp) / me->p_ship->s_maxegntemp;
|
|
|
1031 break;
|
|
|
1032 case 'P':
|
|
|
1033 len=(statHeight*me->p_speed)/me->p_ship->s_maxspeed;
|
|
|
1034 break;
|
|
|
1035 case 'D':
|
|
|
1036 len=(statHeight*me->p_damage)/me->p_ship->s_maxdamage;
|
|
|
1037 break;
|
|
|
1038 case 'S':
|
|
|
1039 len=statHeight - ((statHeight*me->p_shield)/me->p_ship->s_maxshield);
|
|
|
1040 break;
|
|
|
1041 case 'F':
|
|
|
1042 len=statHeight - ((statHeight*me->p_fuel)/me->p_ship->s_maxfuel);
|
|
|
1043 break;
|
|
|
1044 case 'A':
|
|
|
1045 len= me->p_ship->s_maxarmies ?
|
|
|
1046 (statHeight*me->p_armies)/me->p_ship->s_maxarmies : 0;
|
|
|
1047 break;
|
|
|
1048 default:
|
|
|
1049 continue;
|
|
|
1050 }
|
|
|
1051 if(islower(*sptr))
|
|
|
1052 len=statHeight - len;
|
|
|
1053 if(len>statHeight)
|
|
|
1054 len=statHeight;
|
|
|
1055
|
|
|
1056 if(len>2*(statHeight/3) || toupper(*sptr) == 'A')
|
|
|
1057 color=W_Red;
|
|
|
1058 else if(len<(statHeight/3))
|
|
|
1059 color=W_Green;
|
|
|
1060 else
|
|
|
1061 color=W_Yellow;
|
|
|
1062 if(len>0)
|
|
|
1063 W_CacheLine(w,x+W_Textwidth/2,localStatsY-len,x+W_Textwidth/2,localStatsY,color);
|
|
|
1064 W_MaskText(w,x,localStatsY+1,W_White,sptr,1,W_RegularFont);
|
|
|
1065 x+=W_Textwidth;
|
|
|
1066 }
|
|
|
1067 if(x>localStatsX) {
|
|
|
1068 W_CacheLine(w,localStatsX,localStatsY-statHeight,x,localStatsY-statHeight,W_White);
|
|
|
1069 W_CacheLine(w,localStatsX,localStatsY,x,localStatsY,W_White);
|
|
|
1070 cz=new_czone();
|
|
|
1071 cz->x=localStatsX;
|
|
|
1072 cz->y=localStatsY-statHeight+1;
|
|
|
1073 cz->width=x-localStatsX;
|
|
|
1074 cz->height=statHeight-2;
|
|
|
1075 }
|
|
|
1076 }
|
|
|
1077 #endif
|
|
|
1078
|
|
|
1079 static void
|
|
|
1080 local()
|
|
|
1081 {
|
|
|
1082 register int i;
|
|
|
1083 register struct player *j;
|
|
|
1084 register struct phaser *php;
|
|
|
1085 struct _clearzone *cz;
|
|
|
1086
|
|
|
1087 int dx, dy;
|
|
|
1088 int view;
|
|
|
1089 char idbuf[10];
|
|
|
1090 struct ship_shape *ship_bits;
|
|
|
1091 if (showKitchenSink) {
|
|
|
1092 cz = new_czone();
|
|
|
1093 cz->width = 76;
|
|
|
1094 cz->height = 60;
|
|
|
1095 cz->x = 500 - cz->width;
|
|
|
1096 cz->y = 0;
|
|
|
1097 W_WriteBitmap(cz->x, cz->y, kitchenSink, W_Grey);
|
|
|
1098 }
|
|
|
1099 /*
|
|
|
1100 Kludge to try to fix missing ID chars on tactical (short range)
|
|
|
1101 display.
|
|
|
1102 */
|
|
|
1103 idbuf[0] = '0';
|
|
|
1104 idbuf[1] = '\0';
|
|
|
1105 /* Draw Terrain */
|
|
|
1106 redraw_terrain();
|
|
|
1107 /* Draw Planets */
|
|
|
1108 redraw_all_planets();
|
|
|
1109 /* Draw ships */
|
|
|
1110 view = SCALE * WINSIDE / 2;
|
|
|
1111 for (i = 0, j = &players[i]; i < nplayers; i++, j++) {
|
|
|
1112 int tx, ty;
|
|
|
1113 if (me->p_x < 0)
|
|
|
1114 continue;
|
|
|
1115
|
|
|
1116 /* more efficient than using a separate loop for this */
|
|
|
1117 redraw_photon_torps(j);
|
|
|
1118 redraw_drones(j);
|
|
|
1119 redraw_plasma_torps(j);
|
|
|
1120
|
|
|
1121 if ((j->p_status != PALIVE) && (j->p_status != PEXPLODE))
|
|
|
1122 continue;
|
|
|
1123
|
|
|
1124 #ifdef UNIX_SOUND
|
|
|
1125 if (myPlayer(j) && (j->p_flags & PFCLOAK) &&
|
|
|
1126 (j->p_cloakphase == 0)) play_sound (SND_CLOAK);
|
|
|
1127 if (myPlayer(j) && (!(j->p_flags & PFCLOAK)) &&
|
|
|
1128 (j->p_cloakphase == 6)) play_sound (SND_CLOAK);
|
|
|
1129 #endif
|
|
|
1130
|
|
|
1131 if (j->p_flags & PFCLOAK) {
|
|
|
1132 if (j->p_cloakphase < (CLOAK_PHASES - 1)) {
|
|
|
1133 j->p_cloakphase++;
|
|
|
1134 }
|
|
|
1135 } else {
|
|
|
1136 if (j->p_cloakphase) {
|
|
|
1137 j->p_cloakphase--;
|
|
|
1138 }
|
|
|
1139 }
|
|
|
1140 dx = j->p_x - me->p_x;
|
|
|
1141 dy = j->p_y - me->p_y;
|
|
|
1142 if (ABS(dx) > view || ABS(dy) > view) {
|
|
|
1143 if(j->p_status == PEXPLODE)
|
|
|
1144 j->p_explode++;
|
|
|
1145 continue;
|
|
|
1146 }
|
|
|
1147 dx = dx / SCALE + WINSIDE / 2;
|
|
|
1148 dy = dy / SCALE + WINSIDE / 2;
|
|
|
1149 if (j->p_status == PALIVE) {
|
|
|
1150
|
|
|
1151 ship_bits = shape_of_ship(j->p_teami, j->p_ship->s_bitmap);
|
|
|
1152
|
|
|
1153 if (j->p_flags & PFCLOAK && (j->p_cloakphase == (CLOAK_PHASES - 1))) {
|
|
|
1154 if (myPlayer(j)) {
|
|
|
1155 W_WriteBitmap(dx - (cloak_width / 2), dy - (cloak_height / 2),
|
|
|
1156 cloakicon, myColor);
|
|
|
1157 cz = new_czone();
|
|
|
1158 cz->x = dx - (ship_bits->width / 2 + 1);
|
|
|
1159 cz->y = dy - (ship_bits->height / 2 + 1);
|
|
|
1160 cz->width = ship_bits->width + 2;
|
|
|
1161 cz->height = ship_bits->height + 2;
|
|
|
1162 doShields(dx, dy, ship_bits, j);
|
|
|
1163 #ifdef VARY_HULL
|
|
|
1164 doHull(dx, dy, ship_bits, j);
|
|
|
1165 #endif /* VARY_HULL */
|
|
|
1166 if (showMySpeed)
|
|
|
1167 doShowMySpeed(dx, dy, ship_bits, j);
|
|
|
1168 }
|
|
|
1169 continue;
|
|
|
1170 }
|
|
|
1171 cz = new_czone();
|
|
|
1172 #ifdef BEEPLITE
|
|
|
1173 if (emph_player_seq_n[j->p_no] > 0 &&
|
|
|
1174 ((F_beeplite_flags & LITE_PLAYERS_LOCAL) ||
|
|
|
1175 ((j == me) && (F_beeplite_flags & LITE_SELF)))) {
|
|
|
1176 int seq_n = emph_player_seq_n[j->p_no] % emph_player_seql_frames;
|
|
|
1177
|
|
|
1178 cz->x = dx - (emph_player_seql_width / 2);
|
|
|
1179 cz->y = dy - (emph_player_seql_height / 2);
|
|
|
1180 cz->width = emph_player_seql_width;
|
|
|
1181 cz->height = emph_player_seql_height;
|
|
|
1182
|
|
|
1183 W_WriteBitmap(dx - (emph_player_seql_width / 2),
|
|
|
1184 dy - (emph_player_seql_height / 2),
|
|
|
1185 emph_player_seql[seq_n],
|
|
|
1186 emph_player_color[j->p_no]);
|
|
|
1187 } else
|
|
|
1188 #endif
|
|
|
1189 {
|
|
|
1190 cz->x = dx - (ship_bits->width / 2);
|
|
|
1191 cz->y = dy - (ship_bits->height / 2);
|
|
|
1192 cz->width = ship_bits->width;
|
|
|
1193 cz->height = ship_bits->height;
|
|
|
1194 }
|
|
|
1195 W_WriteBitmap(dx - (ship_bits->width / 2),
|
|
|
1196 dy - (ship_bits->height / 2),
|
|
|
1197 ship_bits->bmap[rosette((int) j->p_dir,
|
|
|
1198 (int) ship_bits->nviews)], playerColor(j));
|
|
|
1199 if (j->p_cloakphase > 0) {
|
|
|
1200 W_WriteBitmap(dx - (cloak_width / 2),
|
|
|
1201 dy - (cloak_height / 2), cloakicon, playerColor(j));
|
|
|
1202 doShields(dx, dy, ship_bits, j);
|
|
|
1203 if (j == me) {
|
|
|
1204 #ifdef VARY_HULL
|
|
|
1205 doHull(dx, dy, ship_bits, j);
|
|
|
1206 #endif /* VARY_HULL */
|
|
|
1207 if (showMySpeed)
|
|
|
1208 doShowMySpeed(dx, dy, ship_bits, j);
|
|
|
1209 }
|
|
|
1210 continue;
|
|
|
1211 }
|
|
|
1212 if (showLock & 2) {
|
|
|
1213 if ((me->p_flags & PFPLOCK) && (me->p_playerl == j->p_no)) {
|
|
|
1214 W_WriteTriangle(w, dx, dy + (ship_bits->width / 2),
|
|
|
1215 4, 1, foreColor);
|
|
|
1216 cz = new_czone();
|
|
|
1217 cz->x = dx - 4;
|
|
|
1218 cz->y = dy + (ship_bits->height / 2);
|
|
|
1219 cz->width = 9;
|
|
|
1220 cz->height = 5;
|
|
|
1221 }
|
|
|
1222 }
|
|
|
1223 doShields(dx, dy, ship_bits, j);
|
|
|
1224 #ifdef VARY_HULL
|
|
|
1225 doHull(dx, dy, ship_bits, j);
|
|
|
1226 #endif /* VARY_HULL */
|
|
|
1227 if (showMySpeed && j == me)
|
|
|
1228 doShowMySpeed(dx, dy, ship_bits, j);
|
|
|
1229 else {
|
|
|
1230 int color = playerColor(j);
|
|
|
1231 idbuf[0] = *(shipnos + j->p_no);
|
|
|
1232
|
|
|
1233 W_MaskText(w, dx + (ship_bits->width / 2),
|
|
|
1234 dy - (ship_bits->height / 2), color,
|
|
|
1235 idbuf, 1, shipFont(j));
|
|
|
1236
|
|
|
1237 cz = new_czone();
|
|
|
1238 cz->x = dx + (ship_bits->width / 2);
|
|
|
1239 cz->y = dy - (ship_bits->height / 2);
|
|
|
1240 cz->width = W_Textwidth;
|
|
|
1241 cz->height = W_Textheight;
|
|
|
1242 }
|
|
|
1243 } else if (j->p_status == PEXPLODE) {
|
|
|
1244 int i;
|
|
|
1245 i = j->p_explode;
|
|
|
1246 if (i < EX_FRAMES || (i < SBEXPVIEWS && j->p_ship->s_type == STARBASE)) {
|
|
|
1247
|
|
|
1248 #ifdef SOUND
|
|
|
1249 if(i==0)
|
|
|
1250 S_PlaySound(S_EXPLOSION);
|
|
|
1251 #endif
|
|
|
1252 #ifdef UNIX_SOUND
|
|
|
1253 if (i==0)
|
|
|
1254 {
|
|
|
1255 if (j->p_ship->s_type == STARBASE)
|
|
|
1256 play_sound(SND_EXP_SB); /* Starbase Explode */
|
|
|
1257 else play_sound(SND_EXPLOSION); /* Ship Explosion */
|
|
|
1258 }
|
|
|
1259 #endif
|
|
|
1260
|
|
|
1261 cz = new_czone();
|
|
|
1262 if (j->p_ship->s_type == STARBASE) {
|
|
|
1263 W_WriteBitmap(dx - (sbexp_width / 2),
|
|
|
1264 dy - (sbexp_height / 2), sbexpview[i],
|
|
|
1265 playerColor(j));
|
|
|
1266 cz->x = dx - (sbexp_width / 2);
|
|
|
1267 cz->y = dy - (sbexp_height / 2);
|
|
|
1268 cz->width = sbexp_width;
|
|
|
1269 cz->height = sbexp_height;
|
|
|
1270 } else {
|
|
|
1271 W_WriteBitmap(dx - (ex_width / 2), dy - (ex_height / 2),
|
|
|
1272 expview[i], playerColor(j));
|
|
|
1273 cz->x = dx - (ex_width / 2);
|
|
|
1274 cz->y = dy - (ex_height / 2);
|
|
|
1275 cz->width = ex_width;
|
|
|
1276 cz->height = ex_height;
|
|
|
1277 }
|
|
|
1278 j->p_explode++;
|
|
|
1279 }
|
|
|
1280 }
|
|
|
1281 /* Now draw his phaser (if it exists) */
|
|
|
1282 php = &phasers[j->p_no];
|
|
|
1283 if (php->ph_status != PHFREE) {
|
|
|
1284 if (php->ph_status == PHMISS) {
|
|
|
1285 /* Here I will have to compute end coordinate */
|
|
|
1286 tx = j->p_x + j->p_ship->s_phaserrange * Cos[php->ph_dir];
|
|
|
1287 ty = j->p_y + j->p_ship->s_phaserrange * Sin[php->ph_dir];
|
|
|
1288 tx = (tx - me->p_x) / SCALE + WINSIDE / 2;
|
|
|
1289 ty = (ty - me->p_y) / SCALE + WINSIDE / 2;
|
|
|
1290 } else if (php->ph_status == PHHIT2) {
|
|
|
1291 tx = (php->ph_x - me->p_x) / SCALE + WINSIDE / 2;
|
|
|
1292 ty = (php->ph_y - me->p_y) / SCALE + WINSIDE / 2;
|
|
|
1293 } else { /* Start point is dx, dy */
|
|
|
1294 tx = (players[php->ph_target].p_x - me->p_x) /
|
|
|
1295 SCALE + WINSIDE / 2;
|
|
|
1296 ty = (players[php->ph_target].p_y - me->p_y) /
|
|
|
1297 SCALE + WINSIDE / 2;
|
|
|
1298 }
|
|
|
1299
|
|
|
1300
|
|
|
1301 php->ph_fuse++;
|
|
|
1302
|
|
|
1303 #ifdef CHECK_DROPPED
|
|
|
1304 if (php->ph_fuse > longest_ph_fuse + 1 && php->ph_status != PHGHOST) {
|
|
|
1305 if (reportDroppedPackets)
|
|
|
1306 printf("Dropped phaser free, player %d (fuse)\n", j->p_no);
|
|
|
1307 php->ph_status = PHGHOST;
|
|
|
1308 }
|
|
|
1309 if (php->ph_status != PHGHOST) {
|
|
|
1310 #endif
|
|
|
1311 #ifdef W_PHASERLINE
|
|
|
1312 /*
|
|
|
1313 * an old redraw.c I used for the Amiga port(not this port) had this.
|
|
|
1314 * Draws a dashed line instead of solid..different pattern from tractor
|
|
|
1315 * lines. At least that's what I guessed for amigawindow.c :-) -JR
|
|
|
1316 */
|
|
|
1317
|
|
|
1318 if (j->p_teami != me->p_teami)
|
|
|
1319 W_MakePhaserLine(w, dx, dy, tx, ty,
|
|
|
1320 (php->ph_fuse % 2 && php->ph_status != PHMISS) ?
|
|
|
1321 foreColor :
|
|
|
1322 shipCol[1 + j->p_teami],
|
|
|
1323 php->ph_fuse);
|
|
|
1324 else
|
|
|
1325 #endif
|
|
|
1326 {
|
|
|
1327 W_Color ph_col;
|
|
|
1328 if (jubileePhasers) {
|
|
|
1329
|
|
|
1330 switch (php->ph_fuse % 4) {
|
|
|
1331 case 0:
|
|
|
1332 ph_col = W_Red;
|
|
|
1333 break;
|
|
|
1334 case 1:
|
|
|
1335 ph_col = W_Yellow;
|
|
|
1336 break;
|
|
|
1337 case 2:
|
|
|
1338 ph_col = W_Green;
|
|
|
1339 break;
|
|
|
1340 case 3:
|
|
|
1341 ph_col = W_Cyan;
|
|
|
1342 break;
|
|
|
1343 }
|
|
|
1344 if (php->ph_status == PHMISS)
|
|
|
1345 ph_col = W_White;
|
|
|
1346 } else {
|
|
|
1347 ph_col = (php->ph_fuse % 2 && php->ph_status != PHMISS) ?
|
|
|
1348 foreColor :
|
|
|
1349 shipCol[1 + j->p_teami];
|
|
|
1350 }
|
|
|
1351 W_CacheLine(w, dx, dy, tx, ty, ph_col);
|
|
|
1352 }
|
|
|
1353 clearline[0][clearlcount] = dx;
|
|
|
1354 clearline[1][clearlcount] = dy;
|
|
|
1355 clearline[2][clearlcount] = tx;
|
|
|
1356 clearline[3][clearlcount] = ty;
|
|
|
1357 clearlcount++;
|
|
|
1358 #ifdef CHECK_DROPPED
|
|
|
1359 } /* PHGHOST */
|
|
|
1360 #endif
|
|
|
1361 }
|
|
|
1362 }
|
|
|
1363
|
|
|
1364 /* ATM - show tractor/pressor beams (modified by James Collins) */
|
|
|
1365 /* showTractorPressor is a variable set by xtrekrc. */
|
|
|
1366 /* modified to show all T/P's 1/28/94 [BDyess] */
|
|
|
1367 /* fixed display bug 1/29/94 [BDyess] */
|
|
|
1368 dx = WINSIDE / 2;
|
|
|
1369 dy = WINSIDE / 2;
|
|
|
1370 if (showTractorPressor) {
|
|
|
1371 double theta;
|
|
|
1372 unsigned char dir;
|
|
|
1373 int lx[2], ly[2], px, py, target_width;
|
|
|
1374 struct player *victim = &players[me->p_tractor];
|
|
|
1375 int last;
|
|
|
1376 if (paradise && showAllTractorPressor && allowShowAllTractorPressor) {
|
|
|
1377 /* check everybody */
|
|
|
1378 last = nplayers;
|
|
|
1379 j = &players[0];
|
|
|
1380 i = 0;
|
|
|
1381 } else {
|
|
|
1382 /* only check self */
|
|
|
1383 last = me->p_no + 1;
|
|
|
1384 j = me;
|
|
|
1385 i = me->p_no;
|
|
|
1386 }
|
|
|
1387 for (; i < last; i++, j++) {
|
|
|
1388 if (!(j->p_flags & (PFTRACT | PFPRESS) && isAlive(j)))
|
|
|
1389 continue;
|
|
|
1390 if (!paradise && RSA_Client > 0 && j != me)
|
|
|
1391 continue;
|
|
|
1392 victim = &players[j->p_tractor];
|
|
|
1393 if (victim->p_flags & PFCLOAK)
|
|
|
1394 break; /* can't see tractors on cloaked opponents */
|
|
|
1395 if (j == me) {
|
|
|
1396 dx = dy = WINSIDE / 2;
|
|
|
1397 } else {
|
|
|
1398 dx = (j->p_x - me->p_x) / SCALE + WINSIDE / 2;
|
|
|
1399 dy = (j->p_y - me->p_y) / SCALE + WINSIDE / 2;
|
|
|
1400 }
|
|
|
1401 if (PtOutsideWin(dx, dy))
|
|
|
1402 continue; /* he's off the screen */
|
|
|
1403 px = (victim->p_x - me->p_x) / SCALE + WINSIDE / 2;
|
|
|
1404 py = (victim->p_y - me->p_y) / SCALE + WINSIDE / 2;
|
|
|
1405 if (px == dx && py == dy)
|
|
|
1406 break;
|
|
|
1407 #define XPI 3.1415926
|
|
|
1408 theta = atan2((double) (px - dx), (double) (dy - py)) + XPI / 2.0;
|
|
|
1409 dir = (unsigned char) (theta / XPI * 128.0);
|
|
|
1410 target_width = shape_of_ship(victim->p_teami,
|
|
|
1411 victim->p_ship->s_bitmap)->width;
|
|
|
1412 if (!(victim->p_flags & PFSHIELD))
|
|
|
1413 target_width /= 2;
|
|
|
1414 lx[0] = px + (Cos[dir] * (target_width / 2));
|
|
|
1415 ly[0] = py + (Sin[dir] * (target_width / 2));
|
|
|
1416 lx[1] = px - (Cos[dir] * (target_width / 2));
|
|
|
1417 ly[1] = py - (Sin[dir] * (target_width / 2));
|
|
|
1418 #undef XPI
|
|
|
1419 if (j->p_flags & PFPRESS) {
|
|
|
1420 W_MakeTractLine(w, dx, dy, lx[0], ly[0], W_Yellow);
|
|
|
1421 W_MakeTractLine(w, dx, dy, lx[1], ly[1], W_Yellow);
|
|
|
1422 } else {
|
|
|
1423 W_MakeTractLine(w, dx, dy, lx[0], ly[0], W_Green);
|
|
|
1424 W_MakeTractLine(w, dx, dy, lx[1], ly[1], W_Green);
|
|
|
1425 }
|
|
|
1426 /*
|
|
|
1427 keeping track of tractors seperately from other lines allows
|
|
|
1428 clearing them diffently. Clearing them the same as other
|
|
|
1429 solid lines caused occasional bits to be left on the screen.
|
|
|
1430 This is the fix. [BDyess]
|
|
|
1431 */
|
|
|
1432 if (tractcurrent == NULL) { /* just starting */
|
|
|
1433 tractcurrent = tracthead = (Tractor *) malloc(sizeof(Tractor));
|
|
|
1434 tracthead->next = NULL;
|
|
|
1435 }
|
|
|
1436 tractcurrent->sx = dx;
|
|
|
1437 tractcurrent->sy = dy;
|
|
|
1438 tractcurrent->d1x = lx[0];
|
|
|
1439 tractcurrent->d1y = ly[0];
|
|
|
1440 tractcurrent->d2x = lx[1];
|
|
|
1441 tractcurrent->d2y = ly[1];
|
|
|
1442 /* get ready for the next run through */
|
|
|
1443 if (tractcurrent->next) { /* already malloc'd before */
|
|
|
1444 tractcurrent = tractcurrent->next;
|
|
|
1445 } else { /* new maximum, create a new struct */
|
|
|
1446 tractcurrent->next = (Tractor *) malloc(sizeof(Tractor));
|
|
|
1447 tractcurrent = tractcurrent->next;
|
|
|
1448 tractcurrent->next = NULL;
|
|
|
1449 }
|
|
|
1450 }
|
|
|
1451 }
|
|
|
1452 /* changed torps/drones/plasmas to one call per player, in the above loop */
|
|
|
1453 /* still have leftover drones to draw: */
|
|
|
1454 redraw_other_drones();
|
|
|
1455
|
|
|
1456 /* Draw Edges */
|
|
|
1457 if (me->p_x < (WINSIDE / 2) * SCALE) {
|
|
|
1458 int sy, ey;
|
|
|
1459 dx = (WINSIDE / 2) - (me->p_x) / SCALE;
|
|
|
1460 sy = (WINSIDE / 2) + (0 - me->p_y) / SCALE;
|
|
|
1461 ey = (WINSIDE / 2) + (blk_gwidth - me->p_y) / SCALE;
|
|
|
1462 if (sy < 0)
|
|
|
1463 sy = 0;
|
|
|
1464 if (ey > WINSIDE - 1)
|
|
|
1465 ey = WINSIDE - 1;
|
|
|
1466 /* XFIX */
|
|
|
1467 W_CacheLine(w, dx, sy, dx, ey, warningColor);
|
|
|
1468 /*
|
|
|
1469 W_MakeLine(w, dx, sy, dx, ey, warningColor);
|
|
|
1470 */
|
|
|
1471 clearline[0][clearlcount] = dx;
|
|
|
1472 clearline[1][clearlcount] = sy;
|
|
|
1473 clearline[2][clearlcount] = dx;
|
|
|
1474 clearline[3][clearlcount] = ey;
|
|
|
1475 clearlcount++;
|
|
|
1476 }
|
|
|
1477 if ((blk_gwidth - me->p_x) < (WINSIDE / 2) * SCALE) {
|
|
|
1478 int sy, ey;
|
|
|
1479 dx = (WINSIDE / 2) + (blk_gwidth - me->p_x) / SCALE;
|
|
|
1480 sy = (WINSIDE / 2) + (0 - me->p_y) / SCALE;
|
|
|
1481 ey = (WINSIDE / 2) + (blk_gwidth - me->p_y) / SCALE;
|
|
|
1482 if (sy < 0)
|
|
|
1483 sy = 0;
|
|
|
1484 if (ey > WINSIDE - 1)
|
|
|
1485 ey = WINSIDE - 1;
|
|
|
1486 /* XFIX */
|
|
|
1487 W_CacheLine(w, dx, sy, dx, ey, warningColor);
|
|
|
1488 /*
|
|
|
1489 W_MakeLine(w, dx, sy, dx, ey, warningColor);
|
|
|
1490 */
|
|
|
1491 clearline[0][clearlcount] = dx;
|
|
|
1492 clearline[1][clearlcount] = sy;
|
|
|
1493 clearline[2][clearlcount] = dx;
|
|
|
1494 clearline[3][clearlcount] = ey;
|
|
|
1495 clearlcount++;
|
|
|
1496 }
|
|
|
1497 if (me->p_y < (WINSIDE / 2) * SCALE) {
|
|
|
1498 int sx, ex;
|
|
|
1499 dy = (WINSIDE / 2) - (me->p_y) / SCALE;
|
|
|
1500 sx = (WINSIDE / 2) + (0 - me->p_x) / SCALE;
|
|
|
1501 ex = (WINSIDE / 2) + (blk_gwidth - me->p_x) / SCALE;
|
|
|
1502 if (sx < 0)
|
|
|
1503 sx = 0;
|
|
|
1504 if (ex > WINSIDE - 1)
|
|
|
1505 ex = WINSIDE - 1;
|
|
|
1506 /* XFIX */
|
|
|
1507 W_CacheLine(w, sx, dy, ex, dy, warningColor);
|
|
|
1508 /*
|
|
|
1509 W_MakeLine(w, sx, dy, ex, dy, warningColor);
|
|
|
1510 */
|
|
|
1511 clearline[0][clearlcount] = sx;
|
|
|
1512 clearline[1][clearlcount] = dy;
|
|
|
1513 clearline[2][clearlcount] = ex;
|
|
|
1514 clearline[3][clearlcount] = dy;
|
|
|
1515 clearlcount++;
|
|
|
1516 }
|
|
|
1517 if ((blk_gwidth - me->p_y) < (WINSIDE / 2) * SCALE) {
|
|
|
1518 int sx, ex;
|
|
|
1519 dy = (WINSIDE / 2) + (blk_gwidth - me->p_y) / SCALE;
|
|
|
1520 sx = (WINSIDE / 2) + (0 - me->p_x) / SCALE;
|
|
|
1521 ex = (WINSIDE / 2) + (blk_gwidth - me->p_x) / SCALE;
|
|
|
1522 if (sx < 0)
|
|
|
1523 sx = 0;
|
|
|
1524 if (ex > WINSIDE - 1)
|
|
|
1525 ex = WINSIDE - 1;
|
|
|
1526 /* XFIX */
|
|
|
1527 W_CacheLine(w, sx, dy, ex, dy, warningColor);
|
|
|
1528 /*
|
|
|
1529 W_MakeLine(w, sx, dy, ex, dy, warningColor);
|
|
|
1530 */
|
|
|
1531 clearline[0][clearlcount] = sx;
|
|
|
1532 clearline[1][clearlcount] = dy;
|
|
|
1533 clearline[2][clearlcount] = ex;
|
|
|
1534 clearline[3][clearlcount] = dy;
|
|
|
1535 clearlcount++;
|
|
|
1536 }
|
|
|
1537 /* Change border color to signify alert status */
|
|
|
1538
|
|
|
1539 #ifdef UNIX_SOUND
|
|
|
1540 if (oldalert != (me->p_flags & (PFGREEN | PFYELLOW | PFRED)))
|
|
|
1541 {
|
|
|
1542 if (me->p_flags & PFRED)
|
|
|
1543 maybe_play_sound (SND_REDALERT); /* Red Alert, play ONLY once */
|
|
|
1544 else sound_completed (SND_REDALERT); /* Done with Red Alert */
|
|
|
1545 }
|
|
|
1546 #endif
|
|
|
1547
|
|
|
1548 if (oldalert != (me->p_flags & (PFGREEN | PFYELLOW | PFRED))) {
|
|
|
1549 if(paradise && auto_zoom_timer<udcounter && (autoZoom || autoUnZoom)) {
|
|
|
1550 int old_zoom=blk_zoom;
|
|
|
1551 switch(autoZoom) {
|
|
|
1552 case 1:
|
|
|
1553 if(me->p_flags & (PFYELLOW | PFRED))
|
|
|
1554 blk_zoom = 1;
|
|
|
1555 break;
|
|
|
1556 case 2:
|
|
|
1557 if(me->p_flags & (PFRED))
|
|
|
1558 blk_zoom = 1;
|
|
|
1559 break;
|
|
|
1560 }
|
|
|
1561 switch(autoUnZoom) {
|
|
|
1562 case 1:
|
|
|
1563 if(me->p_flags & (PFGREEN))
|
|
|
1564 blk_zoom = 0;
|
|
|
1565 break;
|
|
|
1566 case 2:
|
|
|
1567 if(me->p_flags & (PFYELLOW | PFGREEN))
|
|
|
1568 blk_zoom = 0;
|
|
|
1569 break;
|
|
|
1570 }
|
|
|
1571 if(old_zoom != blk_zoom)
|
|
|
1572 redrawall=1;
|
|
|
1573 }
|
|
|
1574 oldalert = (me->p_flags & (PFGREEN | PFYELLOW | PFRED));
|
|
|
1575 if (infoIcon && iconified)
|
|
|
1576 drawIcon();
|
|
|
1577 switch (oldalert) {
|
|
|
1578 case PFGREEN:
|
|
|
1579 if (extraBorder)
|
|
|
1580 W_ChangeBorder(w, gColor);
|
|
|
1581 W_ChangeBorder(baseWin, gColor);
|
|
|
1582 W_ChangeBorder(iconWin, gColor);
|
|
|
1583 break;
|
|
|
1584 case PFYELLOW:
|
|
|
1585 if (extraBorder)
|
|
|
1586 W_ChangeBorder(w, yColor);
|
|
|
1587 W_ChangeBorder(baseWin, yColor);
|
|
|
1588 W_ChangeBorder(iconWin, yColor);
|
|
|
1589 break;
|
|
|
1590 case PFRED:
|
|
|
1591 if (extraBorder)
|
|
|
1592 W_ChangeBorder(w, rColor);
|
|
|
1593 W_ChangeBorder(baseWin, rColor);
|
|
|
1594 W_ChangeBorder(iconWin, rColor);
|
|
|
1595 break;
|
|
|
1596 }
|
|
|
1597 }
|
|
|
1598 /* draw stars */
|
|
|
1599
|
|
|
1600 if (blk_showStars)
|
|
|
1601 drawStars();
|
|
|
1602
|
|
|
1603 #ifdef LOCAL_SHIPSTATS
|
|
|
1604 if(localShipStats)
|
|
|
1605 doLocalShipstats();
|
|
|
1606 #endif
|
|
|
1607
|
|
|
1608
|
|
|
1609 }
|
|
|
1610 #define DRAWGRID 4
|
|
|
1611
|
|
|
1612 int
|
|
|
1613 zoom_offset(v)
|
|
|
1614 int v;
|
|
|
1615 {
|
|
|
1616 if (blk_zoom) {
|
|
|
1617 register gwidth, ov;
|
|
|
1618 /* dimension of zoom area */
|
|
|
1619 gwidth = blk_gwidth / 2;
|
|
|
1620 /* offset to bring us into new zoom area */
|
|
|
1621 ov = (v / (int) gwidth) * gwidth;
|
|
|
1622 if (blk_zoom > 1)
|
|
|
1623 return ov;
|
|
|
1624 else
|
|
|
1625 /* sector offset into new zoom area */
|
|
|
1626 return ov + (((v - ov) / GRIDSIZE) * GRIDSIZE) - GRIDSIZE;
|
|
|
1627 } else
|
|
|
1628 return v;
|
|
|
1629 }
|
|
|
1630
|
|
|
1631 #ifdef HOCKEY
|
|
|
1632 void galactic_hockey P((void));
|
|
|
1633 #endif
|
|
|
1634
|
|
|
1635 #ifndef COW_HAS_IT_WHY_SHOULDNT_WE
|
|
|
1636 static
|
|
|
1637 #endif
|
|
|
1638 void
|
|
|
1639 map()
|
|
|
1640 {
|
|
|
1641 int nplan;
|
|
|
1642 register int i, k, tmp = blk_gwidth/250;
|
|
|
1643 register struct player *j;
|
|
|
1644 register struct planet *l;
|
|
|
1645 register int dx, dy, odx, ody;
|
|
|
1646 static osx = 0, osy = 0; /* old square */
|
|
|
1647 static last_offsetx, last_offsety;
|
|
|
1648 static int grid_fuse; /* TSH */
|
|
|
1649 register int gwidth, offsetx, offsety;
|
|
|
1650 int color, pl = 0;
|
|
|
1651 /*
|
|
|
1652 last_lock is used to hold the begin/end point for lock line; [0] holds
|
|
|
1653 me->; [1] holds target lock; lockx[2] holds status of line so we can
|
|
|
1654 erase if line is there but lock if off
|
|
|
1655 */
|
|
|
1656 static last_lockx[3] = {0, 0, 0}, last_locky[2];
|
|
|
1657 int me_galx, me_galy;
|
|
|
1658
|
|
|
1659 grid_fuse++; /* we only draw the grids every DRAWGRID
|
|
|
1660 interval */
|
|
|
1661
|
|
|
1662 /* set number of planets for later */
|
|
|
1663 nplan = (paradise) ? nplanets : 40;
|
|
|
1664
|
|
|
1665 if (reinitPlanets) {
|
|
|
1666 initPlanets();
|
|
|
1667 reinitPlanets = 0;
|
|
|
1668 #ifdef HOCKEY
|
|
|
1669 /* planets moved so the lines need updating [BDyess] */
|
|
|
1670 if(hockey) hockeyInit();
|
|
|
1671 #endif /*HOCKEY*/
|
|
|
1672 }
|
|
|
1673
|
|
|
1674 #ifdef HOCKEY
|
|
|
1675 galactic_hockey();
|
|
|
1676 #endif /*HOCKEY*/
|
|
|
1677
|
|
|
1678 if (blk_zoom) {
|
|
|
1679 gwidth = blk_gwidth / 2;
|
|
|
1680 offsetx = zoom_offset(me->p_x);
|
|
|
1681 offsety = zoom_offset(me->p_y);
|
|
|
1682
|
|
|
1683 if (offsetx != last_offsetx || offsety != last_offsety)
|
|
|
1684 redrawall = 1;
|
|
|
1685
|
|
|
1686 last_offsetx = offsetx;
|
|
|
1687 last_offsety = offsety;
|
|
|
1688 } else {
|
|
|
1689 gwidth = blk_gwidth;
|
|
|
1690 offsetx = 0;
|
|
|
1691 offsety = 0;
|
|
|
1692 }
|
|
|
1693
|
|
|
1694 me_galx = (me->p_x - offsetx) * WINSIDE / gwidth;
|
|
|
1695 me_galy = (me->p_y - offsety) * WINSIDE / gwidth;
|
|
|
1696
|
|
|
1697 /* draw asteroid dots -- this is a test only. MDM */
|
|
|
1698 if( received_terrain_info && paradise ){
|
|
|
1699 /* but avoid that SEGV! */
|
|
|
1700 for( i = 0; i < 250; i++ ){
|
|
|
1701 for( k = udcounter%10; k < 250; k += 10){
|
|
|
1702 if(terrainInfo[i*250+k].types & T_ASTEROIDS) {
|
|
|
1703 W_DrawPoint( mapw,
|
|
|
1704 (i*tmp - offsetx) * WINSIDE / gwidth,
|
|
|
1705 (k*tmp - offsety) * WINSIDE / gwidth,
|
|
|
1706 W_White);
|
|
|
1707 }
|
|
|
1708 if (terrainInfo[i*250+k].types & T_NEBULA) {
|
|
|
1709 W_DrawPoint( mapw,
|
|
|
1710 ((i*tmp - offsetx) * WINSIDE / gwidth) + 1,
|
|
|
1711 ((k*tmp - offsety) * WINSIDE / gwidth) + 1,
|
|
|
1712 W_Red);
|
|
|
1713 }
|
|
|
1714 }
|
|
|
1715 }
|
|
|
1716 }
|
|
|
1717
|
|
|
1718 if (redrawall)
|
|
|
1719 W_ClearWindow(mapw);
|
|
|
1720
|
|
|
1721 /* draw grid on galactic */
|
|
|
1722 if ((redrawall || (grid_fuse % DRAWGRID) == 0) && (paradise) && (drawgrid)) {
|
|
|
1723 int x, y, w, h, grid;
|
|
|
1724 char numbuf[1];
|
|
|
1725 grid = GRIDSIZE * WINSIDE / gwidth;
|
|
|
1726 for (i = 1; i <= 6 / (blk_zoom ? 2 : 1); i++) {
|
|
|
1727 /* looks nasty but we only have to do it 3 times if blk_zoom */
|
|
|
1728
|
|
|
1729 /* horizontal line */
|
|
|
1730 x = 0;
|
|
|
1731 y = i * grid;
|
|
|
1732 w = WINSIDE;
|
|
|
1733 numbuf[0] = '0' + (char) i;
|
|
|
1734 if (blk_zoom) {
|
|
|
1735 /* we might have to clip */
|
|
|
1736 dy = i * GRIDSIZE + offsety;
|
|
|
1737 if (dy >= 0 && dy <= blk_gwidth + 2 * GRIDSIZE) {
|
|
|
1738 if (offsetx < 0) {
|
|
|
1739 x = grid;
|
|
|
1740 w = 2 * x;
|
|
|
1741 } else if (offsetx + 3 * GRIDSIZE > blk_gwidth) {
|
|
|
1742 w = 2 * grid;
|
|
|
1743 }
|
|
|
1744 W_MakeTractLine(mapw, x, y, x + w, y, W_Grey);
|
|
|
1745 }
|
|
|
1746 if (sectorNums) {
|
|
|
1747 numbuf[0] = '0' + (char) (i + offsety / 33333);
|
|
|
1748 if ((numbuf[0] == '0') || (numbuf[0] == '7'))
|
|
|
1749 numbuf[0] = ' ';
|
|
|
1750 if (i == 1) /* so numbers dont overwrite in 1st box */
|
|
|
1751 W_WriteText(mapw, x + 2, y - grid + 11, W_Grey, numbuf, 1,
|
|
|
1752 W_RegularFont);
|
|
|
1753 else
|
|
|
1754 W_WriteText(mapw, x + 2, y - grid + 2, W_Grey, numbuf, 1,
|
|
|
1755 W_RegularFont);
|
|
|
1756 }
|
|
|
1757 } else {
|
|
|
1758 W_MakeTractLine(mapw, x, y, x + w, y, W_Grey);
|
|
|
1759 if (sectorNums) {
|
|
|
1760 W_WriteText(mapw, x + 2, y - grid + 2, W_Grey, numbuf, 1, W_RegularFont);
|
|
|
1761 }
|
|
|
1762 }
|
|
|
1763 /* vertical line */
|
|
|
1764 x = i * grid;
|
|
|
1765 y = 0;
|
|
|
1766 h = WINSIDE;
|
|
|
1767
|
|
|
1768 if (blk_zoom) {
|
|
|
1769 /* we might have to clip */
|
|
|
1770 dx = i * GRIDSIZE + offsetx;
|
|
|
1771 if (dx >= 0 && dx <= blk_gwidth + 2 * GRIDSIZE) {
|
|
|
1772 if (offsety < 0) {
|
|
|
1773 y = grid;
|
|
|
1774 h = 2 * y;
|
|
|
1775 } else if (offsety + 3 * GRIDSIZE > blk_gwidth) {
|
|
|
1776 h = 2 * grid;
|
|
|
1777 }
|
|
|
1778 W_MakeTractLine(mapw, x, y, x, y + h, W_Grey);
|
|
|
1779 }
|
|
|
1780 if (sectorNums) {
|
|
|
1781 numbuf[0] = '0' + (char) (i + offsetx / 33333);
|
|
|
1782 if ((numbuf[0] == '0') || (numbuf[0] == '7'))
|
|
|
1783 numbuf[0] = ' ';
|
|
|
1784 if (i == 1)
|
|
|
1785 W_WriteText(mapw, x - grid + 11, y + 2, W_Grey, numbuf, 1,
|
|
|
1786 W_RegularFont);
|
|
|
1787 else
|
|
|
1788 W_WriteText(mapw, x - grid + 2, y + 2, W_Grey, numbuf, 1,
|
|
|
1789 W_RegularFont);
|
|
|
1790 }
|
|
|
1791 } else {
|
|
|
1792 W_MakeTractLine(mapw, x, y, x, y + h, W_Grey);
|
|
|
1793 if (sectorNums) {
|
|
|
1794 W_WriteText(mapw, x - grid + 2, y + 2, W_Grey, numbuf, 1,
|
|
|
1795 W_RegularFont);
|
|
|
1796 }
|
|
|
1797 }
|
|
|
1798 }
|
|
|
1799
|
|
|
1800 dx = ((me->p_x - offsetx) / GRIDSIZE) * GRIDSIZE;
|
|
|
1801 dy = ((me->p_y - offsety) / GRIDSIZE) * GRIDSIZE;
|
|
|
1802 if (!redrawall && ((osx != dx) || (osy != dy))) {
|
|
|
1803
|
|
|
1804 /* clear old sector */
|
|
|
1805 x = osx * WINSIDE / gwidth;
|
|
|
1806 y = osy * WINSIDE / gwidth;
|
|
|
1807 w = h = grid;
|
|
|
1808
|
|
|
1809 W_DrawSectorHighlight(mapw, x, y, w, h, backColor);
|
|
|
1810
|
|
|
1811 osx = dx;
|
|
|
1812 osy = dy;
|
|
|
1813 }
|
|
|
1814 /* draw our current sector */
|
|
|
1815 x = dx * WINSIDE / gwidth;
|
|
|
1816 w = h = grid;
|
|
|
1817 y = dy * WINSIDE / gwidth;
|
|
|
1818
|
|
|
1819 W_DrawSectorHighlight(mapw, x, y, w, h, yColor);
|
|
|
1820 }
|
|
|
1821 /* Erase ships */
|
|
|
1822 for (i = 0, j = &players[i]; i < nplayers; i++, j++) {
|
|
|
1823 lastUpdate[i]++;
|
|
|
1824 /*
|
|
|
1825 Erase the guy if: redrawPlayer[i] is set and the mapmode setting
|
|
|
1826 allows it.
|
|
|
1827 */
|
|
|
1828 if (!redrawPlayer[i] || (mapmode == GMAP_INFREQUENT && lastUpdate[i] < 5))
|
|
|
1829 continue;
|
|
|
1830 lastUpdate[i] = 0;
|
|
|
1831 /* Clear his old image... */
|
|
|
1832 if (mclearzone[2][i]) {
|
|
|
1833 /* XFIX */
|
|
|
1834 if (!redrawall) {
|
|
|
1835 W_ClearArea(mapw, mclearzone[0][i], mclearzone[1][i],
|
|
|
1836 mclearzone[2][i], mclearzone[3][i]);
|
|
|
1837 /* Redraw the hole just left next update */
|
|
|
1838 checkRedraw(mclearzone[4][i], mclearzone[5][i]);
|
|
|
1839 }
|
|
|
1840 mclearzone[2][i] = 0;
|
|
|
1841 }
|
|
|
1842 }
|
|
|
1843 /* Draw Planets */
|
|
|
1844 #ifdef HOCKEY
|
|
|
1845 if(! (hockey && cleanHockeyGalactic)) {
|
|
|
1846 #endif
|
|
|
1847 for (i = 0, l = &planets[i]; i < nplan; i++, l++) {
|
|
|
1848 char buf[4];
|
|
|
1849 int color;
|
|
|
1850 if (!(l->pl_flags & PLREDRAW) && (!redrawall))
|
|
|
1851 continue;
|
|
|
1852 l->pl_flags &= ~PLREDRAW; /* Turn redraw flag off! */
|
|
|
1853
|
|
|
1854 dx = (l->pl_x - offsetx) * WINSIDE / gwidth;
|
|
|
1855 dy = (l->pl_y - offsety) * WINSIDE / gwidth;
|
|
|
1856
|
|
|
1857 if (PtOutsideWin(dx, dy))
|
|
|
1858 continue;
|
|
|
1859
|
|
|
1860 if (0 == strncmp(l->pl_name, "New ", 4)) {
|
|
|
1861 strncpy(buf, l->pl_name + 4, 3);
|
|
|
1862 } else if (0 == strncmp(l->pl_name, "Planet ", 7)) {
|
|
|
1863 strncpy(buf, l->pl_name + 7, 3);
|
|
|
1864 } else
|
|
|
1865 strncpy(buf, l->pl_name, 3);
|
|
|
1866
|
|
|
1867 /* moving planets */
|
|
|
1868 if (pl_update[l->pl_no].plu_update == 1) {
|
|
|
1869 odx = (pl_update[l->pl_no].plu_x - offsetx) * WINSIDE / gwidth;
|
|
|
1870 ody = (pl_update[l->pl_no].plu_y - offsety) * WINSIDE / gwidth;
|
|
|
1871
|
|
|
1872 /* XFIX */
|
|
|
1873 W_ClearArea(mapw, odx - (mplanet_width / 2), ody - (mplanet_height / 2),
|
|
|
1874 mplanet_width, mplanet_height);
|
|
|
1875
|
|
|
1876 W_WriteText(mapw, odx - (mplanet_width / 2), ody + (mplanet_height / 2),
|
|
|
1877 backColor, buf, 3, planetFont(l));
|
|
|
1878
|
|
|
1879 pl_update[l->pl_no].plu_update = 0;
|
|
|
1880 }
|
|
|
1881 #if 0
|
|
|
1882 /* not necessary, pl_update is now set whenever a planet needs to be
|
|
|
1883 * erased. -JR
|
|
|
1884 */
|
|
|
1885 else {
|
|
|
1886
|
|
|
1887 /* XFIX */
|
|
|
1888 W_ClearArea(mapw, dx - (mplanet_width / 2), dy - (mplanet_height / 2),
|
|
|
1889 mplanet_width, mplanet_height);
|
|
|
1890 }
|
|
|
1891 #endif
|
|
|
1892 color = ((paradise) && (l->pl_flags & (PLSTAR | PLWHOLE))) ?
|
|
|
1893 textColor : planetColor(l);
|
|
|
1894 #ifdef BEEPLITE
|
|
|
1895 if (UseLite && emph_planet_seq_n[l->pl_no] > 0 &&
|
|
|
1896 (F_beeplite_flags & LITE_PLANETS)) {
|
|
|
1897 int seq_n = emph_planet_seq_n[l->pl_no] % emph_planet_seq_frames;
|
|
|
1898
|
|
|
1899 if ((emph_planet_seq_n[l->pl_no] -= 1) > 0)
|
|
|
1900 W_OverlayBitmap(dx - (emph_planet_seq_width / 2),
|
|
|
1901 dy - (emph_planet_seq_height / 2),
|
|
|
1902 emph_planet_seq[seq_n],
|
|
|
1903 emph_planet_color[l->pl_no]);
|
|
|
1904 else
|
|
|
1905 W_ClearArea(mapw, dx - (emph_planet_seq_width / 2),
|
|
|
1906 dy - (emph_planet_seq_height / 2),
|
|
|
1907 emph_planet_seq_width, emph_planet_seq_height);
|
|
|
1908 W_WriteBitmap(dx - (mplanet_width / 2), dy - (mplanet_height / 2),
|
|
|
1909 planetmBitmap(l), color);
|
|
|
1910 l->pl_flags |= PLREDRAW; /* Leave redraw on until done
|
|
|
1911 highlighting */
|
|
|
1912 pl_update[l->pl_no].plu_update = 1;
|
|
|
1913 } else
|
|
|
1914 #endif
|
|
|
1915 if (!(PL_TYPE(*l) == PLWHOLE)) { /* non wormholes */
|
|
|
1916 W_WriteBitmap(dx - (mplanet_width / 2), dy - (mplanet_height / 2),
|
|
|
1917 planetmBitmap(l), color);
|
|
|
1918 W_WriteText(mapw, dx - (mplanet_width / 2), dy + (mplanet_height / 2),
|
|
|
1919 color, buf, ((strlen(buf) >= 3) ? 3 : strlen(buf)),
|
|
|
1920 planetFont(l));
|
|
|
1921 #ifdef SHOW_IND
|
|
|
1922 if (showIND && (l->pl_info & idx_to_mask(me->p_teami)) && (l->pl_owner == NOBODY) && l->pl_flags & PLPLANET)
|
|
|
1923 {
|
|
|
1924 W_MakeLine (mapw, dx + (mplanet_width / 2 - 1), dy + (mplanet_height / 2 - 1),
|
|
|
1925 dx - (mplanet_width / 2), dy - (mplanet_height / 2),
|
|
|
1926 W_White);
|
|
|
1927 W_MakeLine (mapw, dx - (mplanet_width / 2), dy + (mplanet_height / 2 - 1),
|
|
|
1928 dx + (mplanet_width / 2 - 1), dy - (mplanet_height / 2),
|
|
|
1929 W_White);
|
|
|
1930 }
|
|
|
1931 #endif
|
|
|
1932 }
|
|
|
1933 #ifdef VISIBLE_WORMHOLES
|
|
|
1934 else { /* wormholes show when scouted [BDyess] */
|
|
|
1935 if(l->pl_info & idx_to_mask(me->p_teami)) { /* have info [BDyess]*/
|
|
|
1936 printf("l->pl_info == %d\n",l->pl_info);
|
|
|
1937 W_WriteBitmap(dx - (mplanet_width / 2),
|
|
|
1938 dy - (mplanet_height / 2),
|
|
|
1939 planetmBitmap(l),
|
|
|
1940 color);
|
|
|
1941 }
|
|
|
1942 }
|
|
|
1943 #endif /*VISIBLE_WORMHOLES*/
|
|
|
1944 #ifdef HOCKEY
|
|
|
1945 }
|
|
|
1946 #endif
|
|
|
1947 /* Draw ships */
|
|
|
1948 for (i = 0, j = &players[i]; i < nplayers; i++, j++) {
|
|
|
1949 /*
|
|
|
1950 We draw the guy if redrawall, or we just erased him. Also, we
|
|
|
1951 redraw if we haven't drawn for 30 frames. (in case he was erased
|
|
|
1952 by other ships).
|
|
|
1953 */
|
|
|
1954 if (lastUpdate[i] != 0 && (!redrawall) && lastUpdate[i] < 30)
|
|
|
1955 continue;
|
|
|
1956 if (j->p_status != PALIVE)
|
|
|
1957 continue;
|
|
|
1958 lastUpdate[i] = 0;
|
|
|
1959 dx = (j->p_x - offsetx) * WINSIDE / gwidth;
|
|
|
1960 dy = (j->p_y - offsety) * WINSIDE / gwidth;
|
|
|
1961
|
|
|
1962 if ((showLock & 1) && !(j->p_flags & PFCLOAK)) {
|
|
|
1963 if ((me->p_flags & PFPLOCK) && (me->p_playerl == j->p_no)) {
|
|
|
1964 if (lockLine) {
|
|
|
1965 if ((last_lockx[0] != me_galx) || (last_locky[0] != me_galx) ||
|
|
|
1966 (last_lockx[1] != dx) || (last_locky[1] != dy)) {
|
|
|
1967 W_MakeTractLine(mapw, last_lockx[0], last_locky[0],
|
|
|
1968 last_lockx[1], last_locky[1], backColor);
|
|
|
1969 last_lockx[0] = me_galx;
|
|
|
1970 last_locky[0] = me_galy;
|
|
|
1971 last_lockx[1] = dx;
|
|
|
1972 last_locky[1] = dy;
|
|
|
1973 last_lockx[2] = 1;
|
|
|
1974 W_MakeTractLine(mapw, last_lockx[0], last_locky[0],
|
|
|
1975 last_lockx[1], last_locky[1], W_Green);
|
|
|
1976
|
|
|
1977 }
|
|
|
1978 }
|
|
|
1979 W_WriteTriangle(mapw, dx, dy + 6, 4, 1, foreColor);
|
|
|
1980 pl = 1;
|
|
|
1981 }
|
|
|
1982 }
|
|
|
1983 if (PtOutsideWin(dx, dy))
|
|
|
1984 continue;
|
|
|
1985
|
|
|
1986 if (blk_friendlycloak == 1) {
|
|
|
1987 if (j->p_flags & PFCLOAK) {
|
|
|
1988 if (myPlayer(j))
|
|
|
1989 color = myColor;
|
|
|
1990 else if (friendlyPlayer(j))
|
|
|
1991 color = playerColor(j);
|
|
|
1992 else
|
|
|
1993 color = unColor;
|
|
|
1994 } else
|
|
|
1995 color = playerColor(j);
|
|
|
1996
|
|
|
1997 pl = 0;
|
|
|
1998 if (j->p_flags & PFCLOAK)
|
|
|
1999 W_WriteText(mapw, dx - W_Textwidth * cloakcharslen / 2,
|
|
|
2000 dy - W_Textheight / 2, color, cloakchars, cloakcharslen,
|
|
|
2001 W_RegularFont);
|
|
|
2002 else
|
|
|
2003 W_WriteText(mapw, dx - W_Textwidth,
|
|
|
2004 dy - W_Textheight / 2, color, j->p_mapchars, 2,
|
|
|
2005 shipFont(j));
|
|
|
2006 } else {
|
|
|
2007 if (j->p_flags & PFCLOAK) {
|
|
|
2008 W_WriteText(mapw, dx - W_Textwidth * cloakcharslen / 2,
|
|
|
2009 dy - W_Textheight / 2, unColor, cloakchars, cloakcharslen,
|
|
|
2010 W_RegularFont);
|
|
|
2011 } else {
|
|
|
2012 W_WriteText(mapw, dx - W_Textwidth,
|
|
|
2013 dy - W_Textheight / 2, playerColor(j), j->p_mapchars, 2,
|
|
|
2014 shipFont(j));
|
|
|
2015 }
|
|
|
2016 }
|
|
|
2017
|
|
|
2018 #ifdef BEEPLITE
|
|
|
2019 if (UseLite && emph_player_seq_n[i] > 0 &&
|
|
|
2020 (F_beeplite_flags & LITE_PLAYERS_MAP)) {
|
|
|
2021 int seq_n = emph_player_seq_n[i] % emph_player_seq_frames;
|
|
|
2022
|
|
|
2023 W_WriteBitmap(dx - (emph_player_seq_width / 2 - 1),
|
|
|
2024 dy - (emph_player_seq_height / 2 + 1),
|
|
|
2025 emph_player_seq[seq_n],
|
|
|
2026 emph_player_color[i]);
|
|
|
2027 emph_player_seq_n[i] -= 1;
|
|
|
2028 mclearzone[0][i] = dx - (emph_player_seq_width / 2 - 1);
|
|
|
2029 mclearzone[1][i] = dy - (emph_player_seq_height / 2 + 1);
|
|
|
2030 mclearzone[2][i] = emph_player_seq_width;
|
|
|
2031 mclearzone[3][i] = emph_player_seq_height;
|
|
|
2032 mclearzone[4][i] = j->p_x;
|
|
|
2033 mclearzone[5][i] = j->p_y;
|
|
|
2034 /*
|
|
|
2035 Force redraw for this guy no matter what. Even if stationary.
|
|
|
2036 */
|
|
|
2037 lastUpdate[i] = 30;
|
|
|
2038 /* Leave redraw on until done highlighting */
|
|
|
2039 redrawPlayer[i] = 1;
|
|
|
2040 } else
|
|
|
2041 #endif
|
|
|
2042 {
|
|
|
2043 if (j->p_flags & PFCLOAK) {
|
|
|
2044 mclearzone[0][i] = dx - W_Textwidth * cloakcharslen / 2;
|
|
|
2045 mclearzone[1][i] = dy - W_Textheight / 2;
|
|
|
2046 mclearzone[2][i] = W_Textwidth * cloakcharslen;
|
|
|
2047 } else {
|
|
|
2048 mclearzone[0][i] = dx - W_Textwidth;
|
|
|
2049 mclearzone[1][i] = dy - W_Textheight / 2;
|
|
|
2050 mclearzone[2][i] = W_Textwidth * 2;
|
|
|
2051 }
|
|
|
2052 if (pl)
|
|
|
2053 mclearzone[3][i] = W_Textheight + 8;
|
|
|
2054 else
|
|
|
2055 mclearzone[3][i] = W_Textheight;
|
|
|
2056 /* Set these so we can checkRedraw() next time */
|
|
|
2057 mclearzone[4][i] = j->p_x;
|
|
|
2058 mclearzone[5][i] = j->p_y;
|
|
|
2059 redrawPlayer[i] = 0;
|
|
|
2060 }
|
|
|
2061 }
|
|
|
2062 /* draw viewBox if wanted [BDyess] */
|
|
|
2063 #define VIEWDIST SCALE * WINSIDE * WINSIDE / (gwidth * 2)
|
|
|
2064 #define REDRAWDIST SCALE * WINSIDE / 2
|
|
|
2065 if (viewBox && allowViewBox) {
|
|
|
2066 static int viewx = 0, viewy = 0;
|
|
|
2067
|
|
|
2068 dx = (me->p_x - offsetx) * WINSIDE / gwidth;
|
|
|
2069 dy = (me->p_y - offsety) * WINSIDE / gwidth;
|
|
|
2070 if (viewx != dx || viewy != dy || redrawall) {
|
|
|
2071 /* clear old dots - placed here for less flicker */
|
|
|
2072 W_DrawPoint(mapw, viewx + VIEWDIST, viewy + VIEWDIST, backColor);
|
|
|
2073 W_DrawPoint(mapw, viewx + VIEWDIST, viewy - VIEWDIST, backColor);
|
|
|
2074 W_DrawPoint(mapw, viewx - VIEWDIST, viewy + VIEWDIST, backColor);
|
|
|
2075 W_DrawPoint(mapw, viewx - VIEWDIST, viewy - VIEWDIST, backColor);
|
|
|
2076 /* redraw any planets they overwrote */
|
|
|
2077 viewx *= gwidth / WINSIDE + offsetx; /* correct from view
|
|
|
2078 scale */
|
|
|
2079 viewy *= gwidth / WINSIDE + offsety;
|
|
|
2080 checkRedraw(viewx + REDRAWDIST, viewy + REDRAWDIST);
|
|
|
2081 checkRedraw(viewx + REDRAWDIST, viewy - REDRAWDIST);
|
|
|
2082 checkRedraw(viewx - REDRAWDIST, viewy + REDRAWDIST);
|
|
|
2083 checkRedraw(viewx - REDRAWDIST, viewy - REDRAWDIST);
|
|
|
2084 /* draw the new points */
|
|
|
2085 W_DrawPoint(mapw, dx + VIEWDIST, dy + VIEWDIST, W_White);
|
|
|
2086 W_DrawPoint(mapw, dx + VIEWDIST, dy - VIEWDIST, W_White);
|
|
|
2087 W_DrawPoint(mapw, dx - VIEWDIST, dy + VIEWDIST, W_White);
|
|
|
2088 W_DrawPoint(mapw, dx - VIEWDIST, dy - VIEWDIST, W_White);
|
|
|
2089 viewx = dx; /* store the points for later */
|
|
|
2090 viewy = dy; /* clearing */
|
|
|
2091 }
|
|
|
2092 }
|
|
|
2093 #undef VIEWDIST
|
|
|
2094 #undef REDRAWDIST
|
|
|
2095
|
|
|
2096 if (clearlmcount) {
|
|
|
2097 W_WriteTriangle(mapw, clearlmark[0], clearlmark[1], 4, 0, backColor);
|
|
|
2098 clearlmcount--;
|
|
|
2099 }
|
|
|
2100 if (showLock & 1) {
|
|
|
2101 /* for now draw this everytime */
|
|
|
2102 if ((me->p_flags & PFPLLOCK) && (me->p_status != POBSERVE)) {
|
|
|
2103 struct planet *l = &planets[me->p_planet];
|
|
|
2104 dx = (l->pl_x - offsetx) * WINSIDE / gwidth;
|
|
|
2105 dy = (l->pl_y - offsety) * WINSIDE / gwidth;
|
|
|
2106
|
|
|
2107 if (lockLine) {
|
|
|
2108 if ((last_lockx[0] != me_galx) || (last_locky[0] != me_galx) ||
|
|
|
2109 (last_lockx[1] != dx) || (last_locky[1] != dy)) {
|
|
|
2110 W_MakeTractLine(mapw, last_lockx[0], last_locky[0],
|
|
|
2111 last_lockx[1], last_locky[1], backColor);
|
|
|
2112 last_lockx[0] = me_galx;
|
|
|
2113 last_locky[0] = me_galy;
|
|
|
2114 last_lockx[1] = dx;
|
|
|
2115 last_locky[1] = dy;
|
|
|
2116 last_lockx[2] = 1;
|
|
|
2117 W_MakeTractLine(mapw, last_lockx[0], last_locky[0],
|
|
|
2118 last_lockx[1], last_locky[1], W_Green);
|
|
|
2119 }
|
|
|
2120 }
|
|
|
2121 if (!PtOutsideWin(dx, dy)) {
|
|
|
2122 W_WriteTriangle(mapw, dx, dy - (mplanet_height) / 2 - 4, 4, 0,
|
|
|
2123 foreColor);
|
|
|
2124 clearlmark[0] = dx;
|
|
|
2125 clearlmark[1] = dy - (mplanet_height) / 2 - 4;
|
|
|
2126 clearlmcount++;
|
|
|
2127 }
|
|
|
2128 }
|
|
|
2129 }
|
|
|
2130 /* if lock line is drawn but no lock; erase lock line */
|
|
|
2131 if (lockLine && ((me->p_flags & (PFPLLOCK | PFPLOCK)) == 0) && last_lockx[2]) {
|
|
|
2132 W_MakeTractLine(mapw, last_lockx[0], last_locky[0], last_lockx[1],
|
|
|
2133 last_locky[1], backColor);
|
|
|
2134 last_lockx[2] = 0;
|
|
|
2135 }
|
|
|
2136 /* redraw warp beacon routes */
|
|
|
2137
|
|
|
2138 for (i = 0; i < ngthingies; i += 2) {
|
|
|
2139 struct thingy *k = &thingies[i + nplayers * npthingies];
|
|
|
2140 if (k[0].t_shape == SHP_WARP_BEACON &&
|
|
|
2141 k[1].t_shape == SHP_WARP_BEACON) {
|
|
|
2142 W_MakeLine(mapw, (k[0].t_x - offsetx) * WINSIDE / gwidth,
|
|
|
2143 (k[0].t_y - offsety) * WINSIDE / gwidth,
|
|
|
2144 (k[1].t_x - offsetx) * WINSIDE / gwidth,
|
|
|
2145 (k[1].t_y - offsety) * WINSIDE / gwidth,
|
|
|
2146 W_Grey);
|
|
|
2147 }
|
|
|
2148 }
|
|
|
2149 }
|
|
|
2150 redrawall = 0;
|
|
|
2151 }
|
|
|
2152
|
|
|
2153 #define TWODIGIT_L(p, val) \
|
|
|
2154 { \
|
|
|
2155 if ((val)<10) { \
|
|
|
2156 (p)[0] = (val)+'0'; \
|
|
|
2157 (p)[1] = ' '; \
|
|
|
2158 } else { \
|
|
|
2159 (p)[0] = (val)/10 + '0'; \
|
|
|
2160 (p)[1] = (val)%10 + '0'; \
|
|
|
2161 } \
|
|
|
2162 }
|
|
|
2163
|
|
|
2164 #define TWODIGIT_R(p, val) \
|
|
|
2165 { \
|
|
|
2166 if ((val)<10) { \
|
|
|
2167 (p)[0] = ' '; \
|
|
|
2168 (p)[1] = (val)+'0'; \
|
|
|
2169 } else { \
|
|
|
2170 (p)[0] = (val)/10 + '0'; \
|
|
|
2171 (p)[1] = (val)%10 + '0'; \
|
|
|
2172 } \
|
|
|
2173 }
|
|
|
2174
|
|
|
2175 #define THREEDIGIT_C(p, val) \
|
|
|
2176 { \
|
|
|
2177 if ((val)<10) { \
|
|
|
2178 (p)[0] = ' '; (p)[1] = (val)+'0'; (p)[2] = ' '; \
|
|
|
2179 } else if ((val)<100) { \
|
|
|
2180 (p)[0] = (val)/10 + '0'; \
|
|
|
2181 (p)[1] = (val)%10 + '0'; \
|
|
|
2182 (p)[2] = ' '; \
|
|
|
2183 } else { \
|
|
|
2184 (p)[0] = (val)/100 + '0'; \
|
|
|
2185 (p)[1] = ((val)/10 %10) + '0'; \
|
|
|
2186 (p)[2] = (val)%10 + '0'; \
|
|
|
2187 } \
|
|
|
2188 }
|
|
|
2189
|
|
|
2190 #define THREEDIGIT_R(p, val) \
|
|
|
2191 { \
|
|
|
2192 if ((val)<10) { \
|
|
|
2193 (p)[0] = ' '; (p)[1] = ' '; (p)[2] = (val)+'0'; \
|
|
|
2194 } else if ((val)<100) { \
|
|
|
2195 (p)[0] = ' '; \
|
|
|
2196 (p)[1] = (val)/10 + '0'; \
|
|
|
2197 (p)[2] = (val)%10 + '0'; \
|
|
|
2198 } else { \
|
|
|
2199 (p)[0] = (val)/100 + '0'; \
|
|
|
2200 (p)[1] = ((val)/10 %10) + '0'; \
|
|
|
2201 (p)[2] = (val)%10 + '0'; \
|
|
|
2202 } \
|
|
|
2203 }
|
|
|
2204
|
|
|
2205 #define FOURDIGIT_R(p, val) \
|
|
|
2206 { \
|
|
|
2207 if ((val)<10) { \
|
|
|
2208 (p)[0] = ' '; \
|
|
|
2209 (p)[1] = ' '; \
|
|
|
2210 (p)[2] = ' '; \
|
|
|
2211 (p)[3] = (val)+'0'; \
|
|
|
2212 } else if ((val)<100) { \
|
|
|
2213 (p)[0] = ' '; \
|
|
|
2214 (p)[1] = ' '; \
|
|
|
2215 (p)[2] = (val)/10 + '0'; \
|
|
|
2216 (p)[3] = (val)%10 + '0'; \
|
|
|
2217 } else if ((val)<1000) { \
|
|
|
2218 (p)[0] = ' '; \
|
|
|
2219 (p)[1] = (val)/100 + '0'; \
|
|
|
2220 (p)[2] = ((val)/10 %10) + '0'; \
|
|
|
2221 (p)[3] = (val)%10 + '0'; \
|
|
|
2222 } else { \
|
|
|
2223 (p)[0] = (val)/1000 + '0'; \
|
|
|
2224 (p)[1] = ((val)/100 %10) + '0'; \
|
|
|
2225 (p)[2] = ((val)/10 %10) + '0'; \
|
|
|
2226 (p)[3] = (val)%10 + '0'; \
|
|
|
2227 } \
|
|
|
2228 }
|
|
|
2229
|
|
|
2230 #define SIXDIGIT_R(p, val) \
|
|
|
2231 { \
|
|
|
2232 if ((val)<10) { \
|
|
|
2233 (p)[0] = ' '; \
|
|
|
2234 (p)[1] = ' '; \
|
|
|
2235 (p)[2] = ' '; \
|
|
|
2236 (p)[3] = ' '; \
|
|
|
2237 (p)[4] = ' '; \
|
|
|
2238 (p)[5] = (val)+'0'; \
|
|
|
2239 } else if ((val)<100) { \
|
|
|
2240 (p)[0] = ' '; \
|
|
|
2241 (p)[1] = ' '; \
|
|
|
2242 (p)[2] = ' '; \
|
|
|
2243 (p)[3] = ' '; \
|
|
|
2244 (p)[4] = (val)/10 + '0'; \
|
|
|
2245 (p)[5] = (val)%10 + '0'; \
|
|
|
2246 } else if ((val)<1000) { \
|
|
|
2247 (p)[0] = ' '; \
|
|
|
2248 (p)[1] = ' '; \
|
|
|
2249 (p)[2] = ' '; \
|
|
|
2250 (p)[3] = (val)/100 + '0'; \
|
|
|
2251 (p)[4] = ((val)/10 %10) + '0'; \
|
|
|
2252 (p)[5] = (val)%10 + '0'; \
|
|
|
2253 } else if ((val)<10000) { \
|
|
|
2254 (p)[0] = ' '; \
|
|
|
2255 (p)[1] = ' '; \
|
|
|
2256 (p)[2] = ((val)/1000 %10) + '0'; \
|
|
|
2257 (p)[3] = ((val)/100 %10) + '0'; \
|
|
|
2258 (p)[4] = ((val)/10 %10) + '0'; \
|
|
|
2259 (p)[5] = (val)%10 + '0'; \
|
|
|
2260 } else if ((val)<100000) { \
|
|
|
2261 (p)[0] = ' '; \
|
|
|
2262 (p)[1] = ((val)/10000 %10) + '0'; \
|
|
|
2263 (p)[2] = ((val)/1000 %10) + '0'; \
|
|
|
2264 (p)[3] = ((val)/100 %10) + '0'; \
|
|
|
2265 (p)[4] = ((val)/10 %10) + '0'; \
|
|
|
2266 (p)[5] = (val)%10 + '0'; \
|
|
|
2267 } else { \
|
|
|
2268 (p)[0] = (val)/100000 + '0'; \
|
|
|
2269 (p)[1] = ((val)/10000 %10) + '0'; \
|
|
|
2270 (p)[2] = ((val)/1000 %10) + '0'; \
|
|
|
2271 (p)[3] = ((val)/100 %10) + '0'; \
|
|
|
2272 (p)[4] = ((val)/10 %10) + '0'; \
|
|
|
2273 (p)[5] = (val)%10 + '0'; \
|
|
|
2274 } \
|
|
|
2275 }
|
|
|
2276
|
|
|
2277 #define SIXnTWOf_R(p, val) \
|
|
|
2278 { \
|
|
|
2279 (p)[3] = '.'; \
|
|
|
2280 (p)[4] = ((int) (10*(val))) %10 + '0'; \
|
|
|
2281 (p)[5] = ((int) (100*(val))) %10 + '0'; \
|
|
|
2282 if ((val)<10) { \
|
|
|
2283 (p)[0] = ' '; \
|
|
|
2284 (p)[1] = ' '; \
|
|
|
2285 (p)[2] = ((int)(val))+'0'; \
|
|
|
2286 } else if ((val)<100) { \
|
|
|
2287 (p)[0] = ' '; \
|
|
|
2288 (p)[1] = ((int)(val))/10 + '0'; \
|
|
|
2289 (p)[2] = ((int)(val))%10 + '0'; \
|
|
|
2290 } else { \
|
|
|
2291 (p)[0] = ((int)(val))/100 + '0'; \
|
|
|
2292 (p)[1] = (((int)(val))/10 %10) + '0'; \
|
|
|
2293 (p)[2] = ((int)(val))%10 + '0'; \
|
|
|
2294 } \
|
|
|
2295 }
|
|
|
2296
|
|
|
2297 #if 0
|
|
|
2298
|
|
|
2299 static void
|
|
|
2300 stline(flag)
|
|
|
2301 int flag;
|
|
|
2302 {
|
|
|
2303 static char buf1[80];
|
|
|
2304 static char buf2[80];
|
|
|
2305 static char whichbuf = 0;
|
|
|
2306 static int lastnewDashboard;
|
|
|
2307 register char *buf, *oldbuf;
|
|
|
2308 register char *s;
|
|
|
2309 register int i, j;
|
|
|
2310 int k;
|
|
|
2311 /* if you don't do something like this, then switching in the options menu
|
|
|
2312 is 'entertaining' */
|
|
|
2313 if (newDashboard != lastnewDashboard) {
|
|
|
2314 lastnewDashboard = newDashboard;
|
|
|
2315 redrawTstats();
|
|
|
2316 return;
|
|
|
2317 }
|
|
|
2318 /* use the new dashboard if we can */
|
|
|
2319
|
|
|
2320
|
|
|
2321
|
|
|
2322
|
|
|
2323
|
|
|
2324
|
|
|
2325 if (newDashboard) {
|
|
|
2326 db_redraw(flag);
|
|
|
2327 return;
|
|
|
2328 }
|
|
|
2329 /* Instead of one sprintf, we do all this by hand for optimization */
|
|
|
2330
|
|
|
2331 if (flag)
|
|
|
2332 whichbuf = 0; /* We must completely refresh */
|
|
|
2333
|
|
|
2334 if (whichbuf != 2) {
|
|
|
2335 buf = buf1;
|
|
|
2336 oldbuf = buf2;
|
|
|
2337 } else {
|
|
|
2338 buf = buf2;
|
|
|
2339 oldbuf = buf1;
|
|
|
2340 }
|
|
|
2341 buf[0] = (me->p_flags & PFSHIELD ? 'S' : ' ');
|
|
|
2342 if (me->p_flags & PFGREEN)
|
|
|
2343 buf[1] = 'G';
|
|
|
2344 else if (me->p_flags & PFYELLOW)
|
|
|
2345 buf[1] = 'Y';
|
|
|
2346 else if (me->p_flags & PFRED)
|
|
|
2347 buf[1] = 'R';
|
|
|
2348 buf[2] = (me->p_flags & (PFPLLOCK | PFPLOCK) ? 'L' : ' ');
|
|
|
2349 buf[3] = (me->p_flags & PFREPAIR ? 'R' : ' ');
|
|
|
2350 buf[4] = (me->p_flags & PFBOMB ? 'B' : ' ');
|
|
|
2351 buf[5] = (me->p_flags & PFORBIT ? 'O' : ' ');
|
|
|
2352 buf[6] = (me->p_flags & PFDOCKOK ? 'D' : ' ');
|
|
|
2353 /* buf[6] = (me->p_flags & PFDOCK ? 'D' : ' ');*/
|
|
|
2354 buf[7] = (me->p_flags & PFCLOAK ? 'C' : ' ');
|
|
|
2355 buf[8] = (me->p_flags & PFWEP ? 'W' : ' ');
|
|
|
2356 buf[9] = (me->p_flags & PFENG ? 'E' : ' ');
|
|
|
2357 if (me->p_flags & PFPRESS)
|
|
|
2358 buf[10] = 'P';
|
|
|
2359 else if (me->p_flags & PFTRACT)
|
|
|
2360 buf[10] = 'T';
|
|
|
2361 else
|
|
|
2362 buf[10] = ' ';
|
|
|
2363 if (me->p_flags & PFBEAMUP)
|
|
|
2364 buf[11] = 'u';
|
|
|
2365 else if (me->p_flags & PFBEAMDOWN)
|
|
|
2366 buf[11] = 'd';
|
|
|
2367 else
|
|
|
2368 buf[11] = ' ';
|
|
|
2369 if (!paradise)
|
|
|
2370 buf[12] = (status->tourn) ? 't' : ' ';
|
|
|
2371 else
|
|
|
2372 buf[12] = (status2->tourn) ? 't' : ' ';
|
|
|
2373
|
|
|
2374 buf[13] = ' ';
|
|
|
2375
|
|
|
2376 #if 1
|
|
|
2377 /* w/i indicator is a kludge - it just guesses based on the speed of
|
|
|
2378 the ship */
|
|
|
2379 sprintf(buf + 14, "%2d%c %3d %3d %1d %6.2f %3d %6d %4d %4d ",
|
|
|
2380 me->p_speed, (me->p_speed > me->p_ship->s_maxspeed + 2) ? 'w' : 'i',
|
|
|
2381 me->p_damage, me->p_shield, me->p_ntorp, me->p_kills,
|
|
|
2382 me->p_armies, me->p_fuel, me->p_wtemp, me->p_etemp);
|
|
|
2383 #else
|
|
|
2384 #if 0
|
|
|
2385 TWODIGIT_L(&buf[14], me->p_speed);
|
|
|
2386 buf[16] = 'i';
|
|
|
2387 buf[17] = ' ';
|
|
|
2388 buf[18] = ' ';
|
|
|
2389 buf[19] = ' ';
|
|
|
2390 THREEDIGIT_R(&buf[20], me->p_damage);
|
|
|
2391 buf[23] = ' ';
|
|
|
2392 THREEDIGIT_R(&buf[24], me->p_shield);
|
|
|
2393 buf[27] = ' ';
|
|
|
2394 TWODIGIT_R(&buf[28], me->p_ntorp);
|
|
|
2395 buf[30] = ' ';
|
|
|
2396 buf[31] = ' ';
|
|
|
2397 SIXnTWOf_R(&buf[32], me->p_kills);
|
|
|
2398 buf[38] = ' ';
|
|
|
2399 THREEDIGIT_C(&buf[39], me->p_armies);
|
|
|
2400 buf[42] = ' ';
|
|
|
2401 SIXDIGIT_R(&buf[43], me->p_fuel);
|
|
|
2402 buf[49] = ' ';
|
|
|
2403 buf[50] = ' ';
|
|
|
2404 FOURDIGIT_R(&buf[51], me->p_wtemp / 10);
|
|
|
2405 buf[55] = ' ';
|
|
|
2406 FOURDIGIT_R(&buf[56], me->p_etemp / 10);
|
|
|
2407 buf[60] = ' ';
|
|
|
2408 buf[61] = ' ';
|
|
|
2409 #else
|
|
|
2410 buf[14] = '0' + ((me->p_speed % 100) / 10);
|
|
|
2411 if (buf[14] == '0')
|
|
|
2412 buf[14] = ' ';
|
|
|
2413 buf[15] = '0' + (me->p_speed % 10); /* speed */
|
|
|
2414 buf[16] = ' ';
|
|
|
2415 buf[17] = ' ';
|
|
|
2416 buf[18] = '0' + (me->p_damage / 100);
|
|
|
2417 if (buf[18] == '0')
|
|
|
2418 buf[18] = ' ';
|
|
|
2419 buf[19] = '0' + ((me->p_damage % 100) / 10);
|
|
|
2420 if ((buf[19] == '0') && (me->p_damage < 100))
|
|
|
2421 buf[19] = ' ';
|
|
|
2422 buf[20] = '0' + (me->p_damage % 10);
|
|
|
2423 buf[21] = ' ';
|
|
|
2424 buf[22] = '0' + (me->p_shield / 100);
|
|
|
2425 if (buf[22] == '0')
|
|
|
2426 buf[22] = ' ';
|
|
|
2427 buf[23] = '0' + ((me->p_shield % 100) / 10);
|
|
|
2428 if ((buf[23] == '0') && (me->p_shield < 100))
|
|
|
2429 buf[23] = ' ';
|
|
|
2430 buf[24] = '0' + (me->p_shield % 10);
|
|
|
2431 buf[25] = ' ';
|
|
|
2432 buf[26] = ' ';
|
|
|
2433 buf[27] = '0' + ((me->p_ntorp % 100) / 10);
|
|
|
2434 if (buf[27] == '0')
|
|
|
2435 buf[27] = ' ';
|
|
|
2436 buf[28] = '0' + (me->p_ntorp % 10);
|
|
|
2437 buf[29] = ' ';
|
|
|
2438 buf[30] = ' ';
|
|
|
2439 buf[31] = ' ';
|
|
|
2440 buf[32] = ' ';
|
|
|
2441 buf[33] = '0' + ((int) (me->p_kills / 10));
|
|
|
2442 if (buf[33] == '0')
|
|
|
2443 buf[33] = ' ';
|
|
|
2444 buf[34] = '0' + (((int) me->p_kills) % 10);
|
|
|
2445 buf[35] = '.';
|
|
|
2446 buf[36] = '0' + (((int) (me->p_kills * 10)) % 10);
|
|
|
2447 buf[37] = '0' + (((int) (me->p_kills * 100)) % 10);
|
|
|
2448 buf[38] = ' ';
|
|
|
2449 buf[39] = ' ';
|
|
|
2450 buf[40] = ' ';
|
|
|
2451 buf[41] = '0' + ((me->p_armies % 100) / 10);
|
|
|
2452 if (buf[41] == '0')
|
|
|
2453 buf[41] = ' ';
|
|
|
2454 buf[42] = '0' + (me->p_armies % 10);
|
|
|
2455 buf[43] = ' ';
|
|
|
2456 buf[44] = ' ';
|
|
|
2457 buf[45] = ' ';
|
|
|
2458
|
|
|
2459 buf[46] = '0' + (me->p_fuel / 100000);
|
|
|
2460 if (buf[46] == '0')
|
|
|
2461 buf[46] = ' ';
|
|
|
2462 buf[47] = '0' + ((me->p_fuel % 100000) / 10000);
|
|
|
2463 if ((buf[47] == '0') && (me->p_fuel < 100000))
|
|
|
2464 buf[47] = ' ';
|
|
|
2465 buf[48] = '0' + ((me->p_fuel % 10000) / 1000);
|
|
|
2466 if ((buf[48] == '0') && (me->p_fuel < 10000))
|
|
|
2467 buf[48] = ' ';
|
|
|
2468 buf[49] = '0' + ((me->p_fuel % 1000) / 100);
|
|
|
2469 if ((buf[49] == '0') && (me->p_fuel < 1000))
|
|
|
2470 buf[49] = ' ';
|
|
|
2471 buf[50] = '0' + ((me->p_fuel % 100) / 10);
|
|
|
2472 if ((buf[50] == '0') && (me->p_fuel < 100))
|
|
|
2473 buf[50] = ' ';
|
|
|
2474 buf[51] = '0' + (me->p_fuel % 10);
|
|
|
2475 buf[52] = ' ';
|
|
|
2476 buf[53] = ' ';
|
|
|
2477 buf[54] = ' ';
|
|
|
2478
|
|
|
2479 buf[55] = '0' + ((me->p_wtemp / 10) / 100);
|
|
|
2480 if (buf[55] == '0')
|
|
|
2481 buf[55] = ' ';
|
|
|
2482 buf[56] = '0' + (((me->p_wtemp / 10) % 100) / 10);
|
|
|
2483 if ((buf[56] == '0') && (me->p_wtemp < 1000))
|
|
|
2484 buf[56] = ' ';
|
|
|
2485 buf[57] = '0' + ((me->p_wtemp / 10) % 10);
|
|
|
2486
|
|
|
2487 buf[58] = ' ';
|
|
|
2488 buf[59] = ' ';
|
|
|
2489 buf[60] = ' ';
|
|
|
2490 buf[61] = '0' + ((me->p_etemp / 10) / 1000);
|
|
|
2491 if (buf[61] == '0')
|
|
|
2492 buf[61] = ' ';
|
|
|
2493 buf[62] = '0' + (((me->p_etemp / 10) % 1000) / 100);
|
|
|
2494 if (buf[62] == '0' && me->p_etemp < 1000)
|
|
|
2495 buf[62] = ' ';
|
|
|
2496 buf[63] = '0' + (((me->p_etemp / 10) % 100) / 10);
|
|
|
2497 if ((buf[63] == '0') && (me->p_etemp < 1000))
|
|
|
2498 buf[63] = ' ';
|
|
|
2499 buf[64] = '0' + ((me->p_etemp / 10) % 10);
|
|
|
2500 buf[65] = ' ';
|
|
|
2501 #endif
|
|
|
2502 #endif
|
|
|
2503
|
|
|
2504 if (whichbuf == 0) {
|
|
|
2505 /* Draw status line */
|
|
|
2506 W_WriteText(tstatw, TSTATW_BASEX, 16, textColor, buf, 66, W_RegularFont);
|
|
|
2507 whichbuf = 1;
|
|
|
2508 } else { /* Hacks to make it print only what is
|
|
|
2509 necessary */
|
|
|
2510 whichbuf = 3 - whichbuf;
|
|
|
2511 j = -1;
|
|
|
2512 for (i = 0; i < 66; i++) {
|
|
|
2513 if (*(buf++) != *(oldbuf++)) {
|
|
|
2514 /* Different string */
|
|
|
2515 if (j == -1) {
|
|
|
2516 k = i;
|
|
|
2517 s = buf - 1;
|
|
|
2518 }
|
|
|
2519 j = 0;
|
|
|
2520 } else {
|
|
|
2521 /* Same string */
|
|
|
2522 if (j == -1)
|
|
|
2523 continue;
|
|
|
2524 j++;
|
|
|
2525 if (j == 20) { /* Random number */
|
|
|
2526 W_WriteText(tstatw, TSTATW_BASEX + W_Textwidth * k, 16, textColor,
|
|
|
2527 s, i - k - 19, W_RegularFont);
|
|
|
2528 j = -1;
|
|
|
2529 }
|
|
|
2530 }
|
|
|
2531 }
|
|
|
2532 if (j != -1) {
|
|
|
2533 W_WriteText(tstatw, TSTATW_BASEX + W_Textwidth * k, 16, textColor, s, i - k - j,
|
|
|
2534 W_RegularFont);
|
|
|
2535 }
|
|
|
2536 }
|
|
|
2537 }
|
|
|
2538
|
|
|
2539 void
|
|
|
2540 redrawTstats()
|
|
|
2541 {
|
|
|
2542 char buf[100];
|
|
|
2543 W_ClearWindow(tstatw);
|
|
|
2544 /* use new dashboard if possible */
|
|
|
2545 if (newDashboard) {
|
|
|
2546 db_redraw(1);
|
|
|
2547 return;
|
|
|
2548 }
|
|
|
2549 stline(1); /* This is for refresh. We redraw player
|
|
|
2550 stats too */
|
|
|
2551 strcpy(buf, "Flags Speed Dam Shd Trp Kills Ams Fuel Wtmp Etmp Special" /* "Flags Warp
|
|
|
2552 Dam Shd Torps Kills
|
|
|
2553 Armies Fuel Wtemp
|
|
|
2554 Etemp" */ );
|
|
|
2555 W_WriteText(tstatw, TSTATW_BASEX, 5, textColor, buf, strlen(buf), W_RegularFont);
|
|
|
2556 sprintf(buf,
|
|
|
2557 "Maximum: %2d %3d %3d 8 %3d %6d %4d %4d ",
|
|
|
2558 me->p_ship->s_maxspeed, me->p_ship->s_maxdamage,
|
|
|
2559 me->p_ship->s_maxshield, me->p_ship->s_maxarmies,
|
|
|
2560 me->p_ship->s_maxfuel, me->p_ship->s_maxwpntemp / 10,
|
|
|
2561 me->p_ship->s_maxegntemp / 10);
|
|
|
2562 W_WriteText(tstatw, TSTATW_BASEX, 27, textColor, buf, strlen(buf), W_RegularFont);
|
|
|
2563 }
|
|
|
2564 #endif
|
