|
3
|
1 /* $Id: gameconf.c,v 1.1.1.1 1997/12/06 05:41:29 darius Exp $ */
|
|
|
2
|
|
|
3 #include <stdio.h>
|
|
|
4 #include <string.h>
|
|
|
5 #include <sys/types.h>
|
|
|
6 #include <netinet/in.h>
|
|
|
7 #include <time.h>
|
|
|
8 #ifndef hpux
|
|
|
9 #include <sys/time.h>
|
|
|
10 #endif
|
|
|
11 #ifdef __STDC__
|
|
|
12 #include <stdlib.h>
|
|
|
13 #endif
|
|
|
14
|
|
|
15 #include "gameconf.h"
|
|
|
16 #include "defaultlogos.h"
|
|
|
17 #include "data.h"
|
|
|
18 #include "gppackets.h"
|
|
|
19
|
|
|
20 int number_of_teams;
|
|
|
21
|
|
|
22 struct teaminfo_s *teaminfo = 0;
|
|
|
23
|
|
|
24 void
|
|
|
25 load_default_teams()
|
|
|
26 {
|
|
|
27 number_of_teams = 4;
|
|
|
28
|
|
|
29 /* independent is teaminfo[-1], allteam is teaminfo[4] */
|
|
|
30 teaminfo = 1 + (struct teaminfo_s *) malloc(sizeof(*teaminfo) * (number_of_teams + 2));
|
|
|
31
|
|
|
32 strcpy(teaminfo[-1].name, "Independant");
|
|
|
33 teaminfo[-1].letter = 'I';
|
|
|
34 strcpy(teaminfo[-1].shortname, "IND");
|
|
|
35
|
|
|
36 strcpy(teaminfo[0].name, "Federation");
|
|
|
37 teaminfo[0].letter = 'F';
|
|
|
38 strcpy(teaminfo[0].shortname, "FED");
|
|
|
39
|
|
|
40
|
|
|
41 strcpy(teaminfo[1].name, "Romulan");
|
|
|
42 teaminfo[1].letter = 'R';
|
|
|
43 strcpy(teaminfo[1].shortname, "ROM");
|
|
|
44
|
|
|
45
|
|
|
46 strcpy(teaminfo[2].name, "Klingon");
|
|
|
47 teaminfo[2].letter = 'K';
|
|
|
48 strcpy(teaminfo[2].shortname, "KLI");
|
|
|
49
|
|
|
50
|
|
|
51 strcpy(teaminfo[3].name, "Orion");
|
|
|
52 teaminfo[3].letter = 'O';
|
|
|
53 strcpy(teaminfo[3].shortname, "ORI");
|
|
|
54
|
|
|
55 strcpy(teaminfo[4].name, "None");
|
|
|
56 teaminfo[4].letter = '-';
|
|
|
57 strcpy(teaminfo[4].shortname, "NON");
|
|
|
58 }
|
|
|
59
|
|
|
60 void
|
|
|
61 load_default_teamlogos()
|
|
|
62 {
|
|
|
63 if (number_of_teams < 1)
|
|
|
64 return;
|
|
|
65 teaminfo[0].shield_logo = W_StoreBitmap(fedshield_width, fedshield_height,
|
|
|
66 fedshield_bits, teamWin[0]);
|
|
|
67 if (number_of_teams < 2)
|
|
|
68 return;
|
|
|
69 teaminfo[1].shield_logo = W_StoreBitmap(romshield_width, romshield_height,
|
|
|
70 romshield_bits, teamWin[1]);
|
|
|
71 if (number_of_teams < 3)
|
|
|
72 return;
|
|
|
73 teaminfo[2].shield_logo = W_StoreBitmap(klishield_width, klishield_height,
|
|
|
74 klishield_bits, teamWin[2]);
|
|
|
75 if (number_of_teams < 4)
|
|
|
76 return;
|
|
|
77 teaminfo[3].shield_logo = W_StoreBitmap(orishield_width, orishield_height,
|
|
|
78 orishield_bits, teamWin[3]);
|
|
|
79 }
|
|
|
80
|
|
|
81 void
|
|
|
82 load_generic_teams()
|
|
|
83 {
|
|
|
84 /*
|
|
|
85 reserved letters: A G T
|
|
|
86 */
|
|
|
87 int i;
|
|
|
88
|
|
|
89 /* independent is teaminfo[-1] */
|
|
|
90 teaminfo = 1 + (struct teaminfo_s *) malloc(sizeof(*teaminfo) * (number_of_teams + 1));
|
|
|
91
|
|
|
92 strcpy(teaminfo[-1].name, "Independant");
|
|
|
93 teaminfo[-1].letter = 'I';
|
|
|
94 strcpy(teaminfo[-1].shortname, "IND");
|
|
|
95
|
|
|
96 load_default_teamlogos(); /* loads the first 4 team logos */
|
|
|
97
|
|
|
98 for (i = 0; i < number_of_teams; i++) {
|
|
|
99 sprintf(teaminfo[i].name, "Team #%d", i);
|
|
|
100 teaminfo[i].letter = 'J' + i; /* I, J through P */
|
|
|
101 sprintf(teaminfo[i].shortname, "T%02d", i);
|
|
|
102
|
|
|
103 #if 0
|
|
|
104 /* we should draw something nifty here */
|
|
|
105 if (i >= 4) /* the first 4 have been loaded already. */
|
|
|
106 teaminfo[i].shield_logo = W_StoreBitmap(1, 1, &i, teamWin[i]);
|
|
|
107 /* XXX uh-oh if more than 4 teams */
|
|
|
108
|
|
|
109 /* exactly. If there are more than 4 teams the above will SEGV because
|
|
|
110 of the &i (which should be a char * bitmap array).
|
|
|
111 */
|
|
|
112 #endif
|
|
|
113
|
|
|
114 }
|
|
|
115 }
|
|
|
116
|
|
|
117 void
|
|
|
118 initialize_thingies()
|
|
|
119 {
|
|
|
120 int i;
|
|
|
121 int n = (npthingies * nplayers + ngthingies);
|
|
|
122 thingies = (struct thingy *) malloc(sizeof(*thingies) * n);
|
|
|
123 for (i = 0; i < n; i++) {
|
|
|
124 thingies[i].t_shape = SHP_BLANK;
|
|
|
125 thingies[i].t_no = i;
|
|
|
126 thingies[i].t_owner = (i >= npthingies * nplayers) ? -1 : (i / npthingies);
|
|
|
127 }
|
|
|
128 }
|
|
|
129
|
|
|
130 void
|
|
|
131 initialize_players()
|
|
|
132 {
|
|
|
133 int i;
|
|
|
134
|
|
|
135 players = (struct player *) malloc(sizeof(*players) * nplayers);
|
|
|
136
|
|
|
137 bzero(players, sizeof(struct player) * nplayers);
|
|
|
138
|
|
|
139 for (i = 0; i < nplayers; i++) {
|
|
|
140 players[i].p_status = PFREE;
|
|
|
141 players[i].p_cloakphase = 0;
|
|
|
142 players[i].p_no = i;
|
|
|
143 players[i].p_ntorp = 0;
|
|
|
144 players[i].p_ndrone = 0;/* TSH */
|
|
|
145 players[i].p_explode = 1;
|
|
|
146 players[i].p_stats.st_tticks = 1;
|
|
|
147 players[i].p_ship = shiptypes->ship;
|
|
|
148 }
|
|
|
149 }
|
|
|
150
|
|
|
151 void
|
|
|
152 initialize_torps()
|
|
|
153 {
|
|
|
154 int i;
|
|
|
155
|
|
|
156 torps = (struct torp *) malloc(sizeof(*torps) * nplayers * ntorps);
|
|
|
157
|
|
|
158 for (i = 0; i < nplayers * ntorps; i++) {
|
|
|
159 torps[i].t_status = TFREE;
|
|
|
160 torps[i].t_no = i;
|
|
|
161 torps[i].t_owner = (i / ntorps);
|
|
|
162 }
|
|
|
163 }
|
|
|
164
|
|
|
165 void
|
|
|
166 initialize_plasmas()
|
|
|
167 {
|
|
|
168 int i;
|
|
|
169
|
|
|
170 plasmatorps = (struct plasmatorp *) malloc(sizeof(*plasmatorps) * nplayers * nplasmas);
|
|
|
171
|
|
|
172 for (i = 0; i < nplayers * nplasmas; i++) {
|
|
|
173 plasmatorps[i].pt_status = PTFREE;
|
|
|
174 plasmatorps[i].pt_no = i;
|
|
|
175 plasmatorps[i].pt_owner = (i / nplasmas);
|
|
|
176 }
|
|
|
177 }
|
|
|
178
|
|
|
179 void
|
|
|
180 initialize_phasers()
|
|
|
181 {
|
|
|
182 int i;
|
|
|
183
|
|
|
184 phasers = (struct phaser *) malloc(sizeof(*phasers) * nplayers * nphasers);
|
|
|
185
|
|
|
186 for (i = 0; i < nplayers * nphasers; i++) {
|
|
|
187 phasers[i].ph_status = PHFREE;
|
|
|
188 phasers[i].ph_fuse = 0;
|
|
|
189 }
|
|
|
190 }
|
|
|
191
|
|
|
192 void
|
|
|
193 initialize_planets()
|
|
|
194 {
|
|
|
195 int i;
|
|
|
196
|
|
|
197 planets = (struct planet *) malloc(sizeof(*planets) * nplanets);
|
|
|
198
|
|
|
199 for (i = 0; i < nplanets; i++) {
|
|
|
200 struct planet *curr = &planets[i];
|
|
|
201 curr->pl_no = i;
|
|
|
202 curr->pl_flags = 0;
|
|
|
203 curr->pl_owner = 0;
|
|
|
204 curr->pl_x = curr->pl_y = -10000;
|
|
|
205 sprintf(curr->pl_name, "planet%d", i);
|
|
|
206 curr->pl_namelen = strlen(curr->pl_name);
|
|
|
207 curr->pl_armies = 0;
|
|
|
208 curr->pl_info = 0;
|
|
|
209 curr->pl_deadtime = 0;
|
|
|
210 curr->pl_couptime = 0;
|
|
|
211 curr->pl_timestamp = 0;
|
|
|
212
|
|
|
213 /* initialize planet redraw for moving planets */
|
|
|
214 pl_update[i].plu_update = -1;
|
|
|
215 }
|
|
|
216 }
|
|
|
217
|
|
|
218 void
|
|
|
219 init_ranks()
|
|
|
220 {
|
|
|
221 ranks2 = (struct rank2 *) malloc(sizeof(*ranks2) * nranks2);
|
|
|
222 ranks2[0].genocides = 0;
|
|
|
223 ranks2[0].di = 0;
|
|
|
224 ranks2[0].battle = 0.0;
|
|
|
225 ranks2[0].strategy = 0.0;
|
|
|
226 ranks2[0].specship = 0.0;
|
|
|
227 ranks2[0].name = strdup("Recruit");
|
|
|
228
|
|
|
229 ranks2[1].genocides = 1;
|
|
|
230 ranks2[1].di = 10;
|
|
|
231 ranks2[1].battle = 0.30;
|
|
|
232 ranks2[1].strategy = 0.3;
|
|
|
233 ranks2[1].specship = 0.0;
|
|
|
234 ranks2[1].name = strdup("Specialist");
|
|
|
235
|
|
|
236 ranks2[2].genocides = 2;
|
|
|
237 ranks2[2].di = 25;
|
|
|
238 ranks2[2].battle = 0.40;
|
|
|
239 ranks2[2].strategy = 0.6;
|
|
|
240 ranks2[2].specship = 0.0;
|
|
|
241 ranks2[2].name = strdup("Cadet");
|
|
|
242
|
|
|
243 ranks2[3].genocides = 3;
|
|
|
244 ranks2[3].di = 45;
|
|
|
245 ranks2[3].battle = 0.50;
|
|
|
246 ranks2[3].strategy = 0.9;
|
|
|
247 ranks2[3].specship = 0.0;
|
|
|
248 ranks2[3].name = strdup("Midshipman");
|
|
|
249
|
|
|
250 ranks2[4].genocides = 4;
|
|
|
251 ranks2[4].di = 70;
|
|
|
252 ranks2[4].battle = 0.70;
|
|
|
253 ranks2[4].strategy = 1.2;
|
|
|
254 ranks2[4].specship = 0.0;
|
|
|
255 ranks2[4].name = strdup("Ensn. J.G.");
|
|
|
256
|
|
|
257 ranks2[5].genocides = 5;
|
|
|
258 ranks2[5].di = 100;
|
|
|
259 ranks2[5].battle = 0.90;
|
|
|
260 ranks2[5].strategy = 1.5;
|
|
|
261 ranks2[5].specship = 0.0;
|
|
|
262 ranks2[5].name = strdup("Ensign");
|
|
|
263
|
|
|
264 ranks2[6].genocides = 6;
|
|
|
265 ranks2[6].di = 140;
|
|
|
266 ranks2[6].battle = 1.10;
|
|
|
267 ranks2[6].strategy = 2.0;
|
|
|
268 ranks2[6].specship = 0.0;
|
|
|
269 ranks2[6].name = strdup("Lt. J.G.");
|
|
|
270
|
|
|
271 ranks2[7].genocides = 8;
|
|
|
272 ranks2[7].di = 190;
|
|
|
273 ranks2[7].battle = 1.30;
|
|
|
274 ranks2[7].strategy = 2.5;
|
|
|
275 ranks2[7].specship = 0.0;
|
|
|
276 ranks2[7].name = strdup("Lieutenant");
|
|
|
277
|
|
|
278 ranks2[8].genocides = 10;
|
|
|
279 ranks2[8].di = 250;
|
|
|
280 ranks2[8].battle = 1.50;
|
|
|
281 ranks2[8].strategy = 3.0;
|
|
|
282 ranks2[8].specship = 0.5;
|
|
|
283 ranks2[8].name = strdup("Lt. Cmdr.");
|
|
|
284
|
|
|
285 ranks2[9].genocides = 15;
|
|
|
286 ranks2[9].di = 300;
|
|
|
287 ranks2[9].battle = 1.80;
|
|
|
288 ranks2[9].strategy = 3.5;
|
|
|
289 ranks2[9].specship = 0.7;
|
|
|
290 ranks2[9].name = strdup("Commander");
|
|
|
291
|
|
|
292 ranks2[10].genocides = 18;
|
|
|
293 ranks2[10].di = 350;
|
|
|
294 ranks2[10].battle = 2.00;
|
|
|
295 ranks2[10].strategy = 4.0;
|
|
|
296 ranks2[10].specship = 1.0;
|
|
|
297 ranks2[10].name = strdup("Captain");
|
|
|
298
|
|
|
299 ranks2[11].genocides = 25;
|
|
|
300 ranks2[11].di = 400;
|
|
|
301 ranks2[11].battle = 2.10;
|
|
|
302 ranks2[11].strategy = 4.3;
|
|
|
303 ranks2[11].specship = 2.5;
|
|
|
304 ranks2[11].name = strdup("Fleet Capt.");
|
|
|
305
|
|
|
306 ranks2[12].genocides = 50;
|
|
|
307 ranks2[12].di = 500;
|
|
|
308 ranks2[12].battle = 2.15;
|
|
|
309 ranks2[12].strategy = 4.8;
|
|
|
310 ranks2[12].specship = 3.0;
|
|
|
311 ranks2[12].name = strdup("Commodore");
|
|
|
312
|
|
|
313 ranks2[13].genocides = 75;
|
|
|
314 ranks2[13].di = 700;
|
|
|
315 ranks2[13].battle = 2.20;
|
|
|
316 ranks2[13].strategy = 5.3;
|
|
|
317 ranks2[13].specship = 3.3;
|
|
|
318 ranks2[13].name = strdup("Moff");
|
|
|
319
|
|
|
320 ranks2[14].genocides = 100;
|
|
|
321 ranks2[14].di = 900;
|
|
|
322 ranks2[14].battle = 2.25;
|
|
|
323 ranks2[14].strategy = 5.7;
|
|
|
324 ranks2[14].specship = 3.6;
|
|
|
325 ranks2[14].name = strdup("Grand Moff");
|
|
|
326
|
|
|
327 ranks2[15].genocides = 300;
|
|
|
328 ranks2[15].di = 1200;
|
|
|
329 ranks2[15].battle = 2.30;
|
|
|
330 ranks2[15].strategy = 6.0;
|
|
|
331 ranks2[15].specship = 3.8;
|
|
|
332 ranks2[15].name = strdup("Rear Adml.");
|
|
|
333
|
|
|
334 ranks2[16].genocides = 700;
|
|
|
335 ranks2[16].di = 1700;
|
|
|
336 ranks2[16].battle = 2.35;
|
|
|
337 ranks2[16].strategy = 6.1;
|
|
|
338 ranks2[16].specship = 4.0;
|
|
|
339 ranks2[16].name = strdup("Admiral");
|
|
|
340
|
|
|
341 ranks2[17].genocides = 1000;
|
|
|
342 ranks2[17].di = 2500;
|
|
|
343 ranks2[17].battle = 2.40;
|
|
|
344 ranks2[17].strategy = 6.2;
|
|
|
345 ranks2[17].specship = 4.2;
|
|
|
346 ranks2[17].name = strdup("Grand Adml.");
|
|
|
347 }
|
|
|
348
|
|
|
349 void
|
|
|
350 init_royal()
|
|
|
351 {
|
|
|
352 royal = (struct royalty *) malloc(sizeof(*royal) * nroyals);
|
|
|
353
|
|
|
354 royal[0].name = strdup("none");
|
|
|
355 royal[1].name = strdup("Wesley");
|
|
|
356 royal[2].name = strdup("Centurion");
|
|
|
357 royal[3].name = strdup("Praetor");
|
|
|
358 royal[4].name = strdup("Emperor");
|
|
|
359 #if 0
|
|
|
360 royal[5].name = strdup("Wizard");
|
|
|
361 royal[6].name = strdup("Duke");
|
|
|
362 royal[7].name = strdup("Count");
|
|
|
363 royal[8].name = strdup("Baron");
|
|
|
364 royal[9].name = strdup("Knight");
|
|
|
365 royal[10].name = strdup("Dread");
|
|
|
366 royal[11].name = strdup("Lord of Destruction");
|
|
|
367 royal[12].name = strdup("BlitzMeister");
|
|
|
368 royal[13].name = strdup("Hitler");
|
|
|
369 royal[14].name = strdup("Terminator");
|
|
|
370 royal[15].name = strdup("Kamikaze");
|
|
|
371 royal[16].name = strdup("Speed Kamikaze");
|
|
|
372 royal[17].name = strdup("Carpet Bomber");
|
|
|
373 royal[18].name = strdup("NukeMeister");
|
|
|
374 royal[19].name = strdup("Terrorist");
|
|
|
375 royal[20].name = strdup("Democrat");
|
|
|
376 royal[21].name = strdup("Executioner");
|
|
|
377 royal[22].name = strdup("DooshMeister");
|
|
|
378 royal[23].name = strdup("Diplomat");
|
|
|
379 royal[24].name = strdup("speed Diplomat");
|
|
|
380 royal[25].name = strdup("Addict");
|
|
|
381 #endif /* 0 */
|
|
|
382 }
|
|
|
383
|
|
|
384 void
|
|
|
385 reinit_ranks()
|
|
|
386 {
|
|
|
387 int i;
|
|
|
388 ranks2 = (struct rank2 *) malloc(sizeof(*ranks2) * nranks2);
|
|
|
389
|
|
|
390 for (i = 0; i < nranks2; i++) {
|
|
|
391 ranks2[i].name = strdup("blank");
|
|
|
392 }
|
|
|
393 }
|
|
|
394
|
|
|
395 void
|
|
|
396 reinit_royal()
|
|
|
397 {
|
|
|
398 int i;
|
|
|
399 royal = (struct royalty *) malloc(sizeof(*royal) * nroyals);
|
|
|
400
|
|
|
401 for (i = 0; i < nroyals; i++) {
|
|
|
402 royal[i].name = strdup("blank");
|
|
|
403 }
|
|
|
404 }
|
|
|
405
|
|
|
406
|
|
|
407 void
|
|
|
408 resize_players()
|
|
|
409 {
|
|
|
410 int me_no;
|
|
|
411
|
|
|
412 if (me)
|
|
|
413 me_no = me->p_no;
|
|
|
414 players = (struct player *) realloc(players, sizeof(*players) * nplayers);
|
|
|
415 if (me) {
|
|
|
416 me = &players[me_no];
|
|
|
417 myship = me->p_ship;
|
|
|
418 }
|
|
|
419 }
|
|
|
420
|
|
|
421 void
|
|
|
422 free_teams()
|
|
|
423 {
|
|
|
424 int i;
|
|
|
425 for (i = 0; i < number_of_teams; i++) {
|
|
|
426 W_FreeBitmap(teaminfo[i].shield_logo);
|
|
|
427 }
|
|
|
428 /* we offsetted by 1 to make room for IND */
|
|
|
429 free(teaminfo - 1);
|
|
|
430 teaminfo = 0;
|
|
|
431 }
|
|
|
432
|
|
|
433 void
|
|
|
434 free_torps()
|
|
|
435 {
|
|
|
436 free(torps);
|
|
|
437 torps = 0;
|
|
|
438 }
|
|
|
439
|
|
|
440 void
|
|
|
441 free_phasers()
|
|
|
442 {
|
|
|
443 free(phasers);
|
|
|
444 phasers = 0;
|
|
|
445 }
|
|
|
446
|
|
|
447 void
|
|
|
448 free_plasmas()
|
|
|
449 {
|
|
|
450 free(plasmatorps);
|
|
|
451 plasmatorps = 0;
|
|
|
452 }
|
|
|
453
|
|
|
454 void
|
|
|
455 free_thingies()
|
|
|
456 {
|
|
|
457 free(thingies);
|
|
|
458 thingies = 0;
|
|
|
459 }
|
|
|
460
|
|
|
461 void
|
|
|
462 free_ranks()
|
|
|
463 {
|
|
|
464 int i;
|
|
|
465 for (i = 0; i < nranks2; i++)
|
|
|
466 if (ranks2[i].name)
|
|
|
467 free(ranks2[i].name);
|
|
|
468 free(ranks2);
|
|
|
469 ranks2 = 0;
|
|
|
470 }
|
|
|
471
|
|
|
472 void
|
|
|
473 free_royal()
|
|
|
474 {
|
|
|
475 int i;
|
|
|
476 for (i = 0; i < nroyals; i++)
|
|
|
477 if (royal[i].name)
|
|
|
478 free(royal[i].name);
|
|
|
479
|
|
|
480 free(royal);
|
|
|
481 royal = 0;
|
|
|
482 }
|
|
|
483
|
|
|
484 /*
|
|
|
485 */
|
|
|
486
|
|
|
487 void
|
|
|
488 build_default_configuration()
|
|
|
489 {
|
|
|
490 load_default_teams();
|
|
|
491 /* can't load logos until we have some windows */
|
|
|
492
|
|
|
493 init_shiptypes();
|
|
|
494 initialize_players();
|
|
|
495 initialize_torps();
|
|
|
496 initialize_thingies();
|
|
|
497 initialize_plasmas();
|
|
|
498 initialize_planets();
|
|
|
499 initialize_phasers();
|
|
|
500
|
|
|
501
|
|
|
502 init_ranks();
|
|
|
503 init_royal();
|
|
|
504 }
|
|
|
505
|
|
|
506 /*
|
|
|
507 */
|
|
|
508
|
|
|
509
|
|
|
510 int
|
|
|
511 compute_gameparam_size(buf)
|
|
|
512 char *buf;
|
|
|
513 {
|
|
|
514 struct gameparam_spacket *pkt = (struct gameparam_spacket *) buf;
|
|
|
515
|
|
|
516 if (*buf != SP_GPARAM)
|
|
|
517 return -1;
|
|
|
518
|
|
|
519 switch (pkt->subtype) {
|
|
|
520 case 0:
|
|
|
521 return sizeof(struct gp_sizes_spacket);
|
|
|
522 case 1:
|
|
|
523 return sizeof(struct gp_team_spacket);
|
|
|
524 case 2:
|
|
|
525 return sizeof(struct gp_teamlogo_spacket);
|
|
|
526 case 3:
|
|
|
527 return sizeof(struct gp_shipshape_spacket);
|
|
|
528 case 4:
|
|
|
529 return sizeof(struct gp_shipbitmap_spacket);
|
|
|
530 case 5:
|
|
|
531 return sizeof(struct gp_rank_spacket);
|
|
|
532 case 6:
|
|
|
533 return sizeof(struct gp_royal_spacket);
|
|
|
534 case 7:
|
|
|
535 return sizeof(struct gp_teamplanet_spacket);
|
|
|
536 default:
|
|
|
537 return -1;
|
|
|
538 }
|
|
|
539 }
|
|
|
540
|
|
|
541 void
|
|
|
542 handleGPsizes(pkt)
|
|
|
543 struct gp_sizes_spacket *pkt;
|
|
|
544 {
|
|
|
545 free_ranks();
|
|
|
546 free_royal();
|
|
|
547
|
|
|
548 free_teams();
|
|
|
549 free_torps();
|
|
|
550 free_phasers();
|
|
|
551 free_plasmas();
|
|
|
552 free_thingies();
|
|
|
553
|
|
|
554 free_shipshapes();
|
|
|
555
|
|
|
556 nplayers = pkt->nplayers;
|
|
|
557 number_of_teams = pkt->nteams;
|
|
|
558 /* shiptypes */
|
|
|
559 nranks2 = pkt->nranks;
|
|
|
560 nroyals = pkt->nroyal;
|
|
|
561 nphasers = pkt->nphasers;
|
|
|
562 ntorps = pkt->ntorps;
|
|
|
563 nplasmas = pkt->nplasmas;
|
|
|
564 npthingies = pkt->nthingies;
|
|
|
565 ngthingies = pkt->gthingies;
|
|
|
566
|
|
|
567 /* gwidth */
|
|
|
568 /* flags */
|
|
|
569
|
|
|
570 load_generic_teams();
|
|
|
571
|
|
|
572 reinit_ranks();
|
|
|
573 reinit_royal();
|
|
|
574
|
|
|
575 resize_players();
|
|
|
576 initialize_torps();
|
|
|
577 initialize_phasers();
|
|
|
578 initialize_plasmas();
|
|
|
579 initialize_thingies();
|
|
|
580
|
|
|
581 slurp_ship_bitmaps();
|
|
|
582 }
|
|
|
583
|
|
|
584 void
|
|
|
585 handleGPteam(pkt)
|
|
|
586 struct gp_team_spacket *pkt;
|
|
|
587 {
|
|
|
588 struct teaminfo_s *currteam;
|
|
|
589
|
|
|
590 if ((int) pkt->index >= number_of_teams) {
|
|
|
591 fprintf(stderr, "Team #%d %s is out of range (0..%d)\n", pkt->index,
|
|
|
592 pkt->teamname, number_of_teams);
|
|
|
593 return;
|
|
|
594 }
|
|
|
595 currteam = &teaminfo[pkt->index];
|
|
|
596
|
|
|
597 currteam->letter = pkt->letter;
|
|
|
598
|
|
|
599 strncpy(currteam->shortname, pkt->shortname, 3);
|
|
|
600 currteam->shortname[3] = 0;
|
|
|
601
|
|
|
602 strncpy(currteam->name, pkt->teamname, sizeof(currteam->name) - 1);
|
|
|
603 currteam->name[sizeof(currteam->name) - 1] = 0;;
|
|
|
604 }
|
|
|
605
|
|
|
606 void
|
|
|
607 handleGPteamlogo(pkt)
|
|
|
608 struct gp_teamlogo_spacket *pkt;
|
|
|
609 {
|
|
|
610 static char buf[13 * 99]; /* 99x99 */
|
|
|
611 static int curr_height = 0;
|
|
|
612 static int lwidth, lheight;
|
|
|
613 static int teamindex;
|
|
|
614 int pwidth;
|
|
|
615
|
|
|
616 if ((unsigned) pkt->teamindex >= number_of_teams) {
|
|
|
617 fprintf(stderr, "Team #%d is out of range (0..%d)\n", pkt->teamindex,
|
|
|
618 number_of_teams);
|
|
|
619 return;
|
|
|
620 }
|
|
|
621 if (pkt->y != curr_height) {
|
|
|
622 fprintf(stderr, "Bad gp_teamlogo packet sequence y(%d) != curr_height(%d)\n",
|
|
|
623 pkt->y, curr_height);
|
|
|
624 curr_height = 0;
|
|
|
625 return;
|
|
|
626 }
|
|
|
627 if (curr_height) {
|
|
|
628 if (lwidth != pkt->logowidth || lheight != pkt->logoheight ||
|
|
|
629 teamindex != pkt->teamindex) {
|
|
|
630 fprintf(stderr, "gp_teamlogo packet sequence error, %d!=%d || %d!=%d || %d!=%d\n",
|
|
|
631 lwidth, pkt->logowidth, lheight, pkt->logoheight,
|
|
|
632 teamindex, pkt->teamindex);
|
|
|
633 curr_height = 0;
|
|
|
634 return;
|
|
|
635 }
|
|
|
636 } else {
|
|
|
637 teamindex = pkt->teamindex;
|
|
|
638 lwidth = pkt->logowidth;
|
|
|
639 lheight = pkt->logoheight;
|
|
|
640 if (lwidth > 99 || lheight > 99) {
|
|
|
641 fprintf(stderr, "logo too big (%dx%d), rejecting\n", lwidth, lheight);
|
|
|
642 curr_height = 0;
|
|
|
643 return;
|
|
|
644 }
|
|
|
645 }
|
|
|
646 pwidth = (lwidth - 1) / 8 + 1;
|
|
|
647 memcpy(buf + pwidth * curr_height, pkt->data, pwidth * pkt->thisheight);
|
|
|
648 curr_height += pkt->thisheight;
|
|
|
649
|
|
|
650 if (curr_height >= lheight) {
|
|
|
651 W_FreeBitmap(teaminfo[teamindex].shield_logo);
|
|
|
652 teaminfo[teamindex].shield_logo = W_StoreBitmap(lwidth, lheight, buf,
|
|
|
653 teamWin[teamindex]);
|
|
|
654 curr_height = 0;
|
|
|
655 }
|
|
|
656 }
|
|
|
657
|
|
|
658 void
|
|
|
659 handleGPshipshape(pkt)
|
|
|
660 struct gp_shipshape_spacket *pkt;
|
|
|
661 {
|
|
|
662 if (pkt->race < -1 || pkt->race >= number_of_teams) {
|
|
|
663 fprintf(stderr, "race #%d out of range (-1..%d)\n", pkt->race,
|
|
|
664 number_of_teams - 1);
|
|
|
665 return;
|
|
|
666 }
|
|
|
667 if ( /* pkt->shipno<0 || */ (int) pkt->shipno >= nshiptypes) {
|
|
|
668 fprintf(stderr, "ship class #%d out of range (0..%d)\n", pkt->shipno,
|
|
|
669 nshiptypes - 1);
|
|
|
670 return;
|
|
|
671 }
|
|
|
672 replace_shipshape(pkt->race, pkt->shipno, pkt->nviews,
|
|
|
673 pkt->width, pkt->height);
|
|
|
674 }
|
|
|
675
|
|
|
676 void
|
|
|
677 handleGPshipbitmap(pkt)
|
|
|
678 struct gp_shipbitmap_spacket *pkt;
|
|
|
679 {
|
|
|
680 if (pkt->race < -1 || pkt->race >= number_of_teams) {
|
|
|
681 fprintf(stderr, "race #%d out of range (-1..%d)\n", pkt->race,
|
|
|
682 number_of_teams - 1);
|
|
|
683 return;
|
|
|
684 }
|
|
|
685 if ( /* pkt->shipno<0 || */ (int) pkt->shipno >= nshiptypes) {
|
|
|
686 fprintf(stderr, "ship class #%d out of range (0..%d)\n", pkt->shipno,
|
|
|
687 nshiptypes - 1);
|
|
|
688 return;
|
|
|
689 }
|
|
|
690 replace_ship_bitmap(pkt->race, pkt->shipno, pkt->thisview, pkt->bitmapdata);
|
|
|
691 }
|
|
|
692
|
|
|
693 void
|
|
|
694 handleGPrank(pkt)
|
|
|
695 struct gp_rank_spacket *pkt;
|
|
|
696 {
|
|
|
697 struct rank2 *curr;
|
|
|
698 if (pkt->rankn >= nranks2) {
|
|
|
699 fprintf(stderr, "rank #%d %s out of range (0..%d)\n", pkt->rankn,
|
|
|
700 pkt->name, nranks2 - 1);
|
|
|
701 return;
|
|
|
702 }
|
|
|
703 curr = &ranks2[pkt->rankn];
|
|
|
704 free(curr->name);
|
|
|
705
|
|
|
706 curr->genocides = htonl(pkt->genocides);
|
|
|
707 curr->di = htonl(pkt->milliDI) / 1000.0;
|
|
|
708 curr->battle = htonl(pkt->millibattle) / 1000.0;
|
|
|
709 curr->strategy = htonl(pkt->millistrat) / 1000.0;
|
|
|
710 curr->specship = htonl(pkt->millispec) / 1000.0;
|
|
|
711 curr->name = strdup(pkt->name);
|
|
|
712 }
|
|
|
713
|
|
|
714 void
|
|
|
715 handleGProyal(pkt)
|
|
|
716 struct gp_royal_spacket *pkt;
|
|
|
717 {
|
|
|
718 if ((int) pkt->rankn >= nroyals) {
|
|
|
719 fprintf(stderr, "Royalty #%d %s out of range (0..%d)\n", pkt->rankn,
|
|
|
720 pkt->name, nroyals - 1);
|
|
|
721 return;
|
|
|
722 }
|
|
|
723 free(royal[pkt->rankn].name);
|
|
|
724 royal[pkt->rankn].name = strdup(pkt->name);
|
|
|
725 }
|
|
|
726
|
|
|
727 static unsigned char mplanet_bits[] = {
|
|
|
728 0xe0, 0x03, 0x18, 0x0c, 0x04, 0x10, 0x02, 0x20, 0x02, 0x20, 0x01, 0x40,
|
|
|
729 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x02, 0x20, 0x02, 0x20,
|
|
|
730 0x04, 0x10, 0x18, 0x0c, 0xe0, 0x03, 0x00, 0x00};
|
|
|
731 static unsigned char planet_bits[] = {
|
|
|
732 0x00, 0xf8, 0x03, 0x00, 0x00, 0x07, 0x1c, 0x00, 0xc0, 0x00, 0x60, 0x00,
|
|
|
733 0x20, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x02,
|
|
|
734 0x04, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x08,
|
|
|
735 0x02, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x10,
|
|
|
736 0x01, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00, 0x10,
|
|
|
737 0x01, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00, 0x10,
|
|
|
738 0x02, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x08,
|
|
|
739 0x04, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x04, 0x08, 0x00, 0x00, 0x02,
|
|
|
740 0x10, 0x00, 0x00, 0x01, 0x20, 0x00, 0x80, 0x00, 0xc0, 0x00, 0x60, 0x00,
|
|
|
741 0x00, 0x07, 0x1c, 0x00, 0x00, 0xf8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00};
|
|
|
742
|
|
|
743 void
|
|
|
744 handleGPteamplanet(pkt)
|
|
|
745 struct gp_teamplanet_spacket *pkt;
|
|
|
746 {
|
|
|
747 {
|
|
|
748 #define TACTICALSIZE sizeof(pkt->tactical)
|
|
|
749 unsigned char tactical[TACTICALSIZE];
|
|
|
750 int i;
|
|
|
751 int race = pkt->teamn;
|
|
|
752
|
|
|
753 if (race < -1 || race >= number_of_teams) {
|
|
|
754 fprintf(stderr, "race #%d out of range (-1..%d)\n", race,
|
|
|
755 number_of_teams - 1);
|
|
|
756 return;
|
|
|
757 }
|
|
|
758 for (i = 0; i < TACTICALSIZE; i++) {
|
|
|
759 tactical[i] = (pkt->tactical[i] & pkt->tacticalM[i]) |
|
|
|
760 (planet_bits[i] & ~pkt->tacticalM[i]);
|
|
|
761 }
|
|
|
762
|
|
|
763 W_FreeBitmap(bplanets[race + 1]);
|
|
|
764 bplanets[race + 1] = W_StoreBitmap(30, 30, tactical, w);
|
|
|
765
|
|
|
766 #undef TACTICALSIZE
|
|
|
767 }
|
|
|
768
|
|
|
769 {
|
|
|
770 #define GALACTICSIZE sizeof(pkt->galactic)
|
|
|
771 unsigned char galactic[GALACTICSIZE];
|
|
|
772 int i;
|
|
|
773 int race = pkt->teamn;
|
|
|
774
|
|
|
775 if (race < -1 || race >= number_of_teams) {
|
|
|
776 fprintf(stderr, "race #%d out of range (-1..%d)\n", race,
|
|
|
777 number_of_teams - 1);
|
|
|
778 return;
|
|
|
779 }
|
|
|
780 for (i = 0; i < GALACTICSIZE; i++) {
|
|
|
781 galactic[i] = (pkt->galactic[i] & pkt->galacticM[i]) |
|
|
|
782 (mplanet_bits[i] & ~pkt->galacticM[i]);
|
|
|
783 }
|
|
|
784
|
|
|
785 W_FreeBitmap(mbplanets[race + 1]);
|
|
|
786 mbplanets[race + 1] = W_StoreBitmap(16, 16, galactic, mapw);
|
|
|
787
|
|
|
788 #undef GALACTICSIZE
|
|
|
789 }
|
|
|
790 }
|
|
|
791
|
|
|
792 void
|
|
|
793 handleGameparams(pkt)
|
|
|
794 struct gameparam_spacket *pkt;
|
|
|
795 {
|
|
|
796 switch (pkt->subtype) {
|
|
|
797 case 0:
|
|
|
798 handleGPsizes((struct gp_sizes_spacket *) pkt);
|
|
|
799 break;
|
|
|
800 case 1:
|
|
|
801 handleGPteam((struct gp_team_spacket *) pkt);
|
|
|
802 break;
|
|
|
803 case 2:
|
|
|
804 handleGPteamlogo((struct gp_teamlogo_spacket *) pkt);
|
|
|
805 break;
|
|
|
806 case 3:
|
|
|
807 handleGPshipshape((struct gp_shipshape_spacket *) pkt);
|
|
|
808 break;
|
|
|
809 case 4:
|
|
|
810 handleGPshipbitmap((struct gp_shipbitmap_spacket *) pkt);
|
|
|
811 break;
|
|
|
812 case 5:
|
|
|
813 handleGPrank((struct gp_rank_spacket *) pkt);
|
|
|
814 break;
|
|
|
815 case 6:
|
|
|
816 handleGProyal((struct gp_royal_spacket *) pkt);
|
|
|
817 break;
|
|
|
818 case 7:
|
|
|
819 handleGPteamplanet((struct gp_teamplanet_spacket *) pkt);
|
|
|
820 break;
|
|
|
821 default:
|
|
|
822 fprintf(stderr, "Gameparams packet subtype %d not yet implemented\n",
|
|
|
823 pkt->subtype);
|
|
|
824 }
|
|
|
825 }
|
