|
3
|
1 /* $Id: shipbitmaps.c,v 1.1.1.1 1997/12/06 05:41:30 darius Exp $ */
|
|
|
2
|
|
|
3 /* with this file, now the user can define and develop new ship bitmap
|
|
|
4 sets ('albums') more easily.
|
|
|
5
|
|
|
6 The user need only create a file in the proper directory with the
|
|
|
7 proper name with the proper format. The directory is specified by the
|
|
|
8 shipBitmapPath resource in the .xtrekrc. Its default is
|
|
|
9 /usr/games/lib/netrek. The name of the file is "R%d.C%d" where the
|
|
|
10 first integer is the race number and the second is the ship class
|
|
|
11 number.
|
|
|
12
|
|
|
13 The format of the file is: 3 4-byte integers in network byte order.
|
|
|
14 The first is the number of views in the file (this field is currently
|
|
|
15 ignored but should have the value 16). The second integer is the
|
|
|
16 width and the third is the height. Then follows raw bitmap data. I
|
|
|
17 don't know what the format is, but it's basically a binary version of
|
|
|
18 the X bitmap file format. Translate those hex numbers to raw bytes
|
|
|
19 and you have it. I can tell you that each line is padded to 8 bits.
|
|
|
20
|
|
|
21 */
|
|
|
22
|
|
|
23 #include <stdio.h>
|
|
|
24 #ifndef AMIGA
|
|
|
25 #include <sys/param.h>
|
|
|
26 #include <netinet/in.h>
|
|
|
27 #endif
|
|
|
28 #include <errno.h>
|
|
|
29
|
|
|
30 #ifdef m_flags
|
|
|
31 /* appears under HPUX */
|
|
|
32 #undef m_flags
|
|
|
33 #endif
|
|
|
34
|
|
|
35 #include "Wlib.h"
|
|
|
36 #include "defs.h"
|
|
|
37 #include "struct.h"
|
|
|
38 #include "data.h"
|
|
|
39 #include "gameconf.h"
|
|
|
40
|
|
|
41 #ifdef NOSHIPBITMAPS
|
|
|
42 #include "bitmaps_CASB.h"
|
|
|
43 #else
|
|
|
44 #include "bitmaps_NEW.h"
|
|
|
45 #ifdef HOCKEY
|
|
|
46 #include "puck.h"
|
|
|
47 #endif /*HOCKEY*/
|
|
|
48 #endif
|
|
|
49
|
|
|
50 static int
|
|
|
51 get_ship_width(team, shipn)
|
|
|
52 int team, shipn;
|
|
|
53 {
|
|
|
54 #ifndef NOSHIPBITMAPS
|
|
|
55 if (shipn == ATT && paradise)
|
|
|
56 return att_width;
|
|
|
57 switch (team) {
|
|
|
58 case 0:
|
|
|
59 switch (shipn) {
|
|
|
60 #ifdef HOCKEY
|
|
|
61 case PUCK:
|
|
|
62 return puck_width;
|
|
|
63 #endif /*HOCKEY*/
|
|
|
64 case SCOUT:
|
|
|
65 return fed_scout_width;
|
|
|
66 case DESTROYER:
|
|
|
67 return fed_destroyer_width;
|
|
|
68 case CRUISER:
|
|
|
69 return fed_cruiser_width;
|
|
|
70 case BATTLESHIP:
|
|
|
71 return fed_battleship_width;
|
|
|
72 case ASSAULT:
|
|
|
73 return fed_assault_width;
|
|
|
74 case STARBASE:
|
|
|
75 return fed_starbase_width;
|
|
|
76 case JUMPSHIP:
|
|
|
77 return fed_jumpship_width;
|
|
|
78 case FLAGSHIP:
|
|
|
79 return fed_galaxy_width;
|
|
|
80 case GALAXY:
|
|
|
81 return fed_galaxy_width;
|
|
|
82 case WARBASE:
|
|
|
83 return fed_warbase_width;
|
|
|
84 case LIGHTCRUISER:
|
|
|
85 return fed_lightcruiser_width;
|
|
|
86 case CARRIER:
|
|
|
87 return fed_carrier_height;
|
|
|
88 case UTILITY:
|
|
|
89 return fed_utility_width;
|
|
|
90 case PATROL:
|
|
|
91 return fed_patrol_width;
|
|
|
92 }
|
|
|
93 case 1:
|
|
|
94 switch (shipn) {
|
|
|
95 #ifdef HOCKEY
|
|
|
96 case PUCK:
|
|
|
97 return puck_width;
|
|
|
98 #endif /*HOCKEY*/
|
|
|
99 case SCOUT:
|
|
|
100 return rom_scout_width;
|
|
|
101 case DESTROYER:
|
|
|
102 return rom_destroyer_width;
|
|
|
103 case CRUISER:
|
|
|
104 return rom_cruiser_width;
|
|
|
105 case BATTLESHIP:
|
|
|
106 return rom_battleship_width;
|
|
|
107 case ASSAULT:
|
|
|
108 return rom_assault_width;
|
|
|
109 case STARBASE:
|
|
|
110 return rom_starbase_width;
|
|
|
111 case JUMPSHIP:
|
|
|
112 return rom_jumpship_width;
|
|
|
113 case FLAGSHIP:
|
|
|
114 return rom_galaxy_width;
|
|
|
115 case GALAXY:
|
|
|
116 return rom_galaxy_width;
|
|
|
117 case WARBASE:
|
|
|
118 return rom_warbase_width;
|
|
|
119 case LIGHTCRUISER:
|
|
|
120 return rom_lightcruiser_width;
|
|
|
121 case CARRIER:
|
|
|
122 return rom_carrier_height;
|
|
|
123 case UTILITY:
|
|
|
124 return rom_utility_width;
|
|
|
125 case PATROL:
|
|
|
126 return rom_patrol_width;
|
|
|
127 }
|
|
|
128 case 2:
|
|
|
129 switch (shipn) {
|
|
|
130 #ifdef HOCKEY
|
|
|
131 case PUCK:
|
|
|
132 return puck_width;
|
|
|
133 #endif /*HOCKEY*/
|
|
|
134 case SCOUT:
|
|
|
135 return kli_scout_width;
|
|
|
136 case DESTROYER:
|
|
|
137 return kli_destroyer_width;
|
|
|
138 case CRUISER:
|
|
|
139 return kli_cruiser_width;
|
|
|
140 case BATTLESHIP:
|
|
|
141 return kli_battleship_width;
|
|
|
142 case ASSAULT:
|
|
|
143 return kli_assault_width;
|
|
|
144 case STARBASE:
|
|
|
145 return kli_starbase_width;
|
|
|
146 case JUMPSHIP:
|
|
|
147 return kli_jumpship_width;
|
|
|
148 case FLAGSHIP:
|
|
|
149 return kli_galaxy_width;
|
|
|
150 case GALAXY:
|
|
|
151 return kli_galaxy_width;
|
|
|
152 case WARBASE:
|
|
|
153 return kli_warbase_width;
|
|
|
154 case LIGHTCRUISER:
|
|
|
155 return kli_lightcruiser_width;
|
|
|
156 case CARRIER:
|
|
|
157 return kli_carrier_height;
|
|
|
158 case UTILITY:
|
|
|
159 return kli_utility_width;
|
|
|
160 case PATROL:
|
|
|
161 return kli_patrol_width;
|
|
|
162 }
|
|
|
163 case 3:
|
|
|
164 switch (shipn) {
|
|
|
165 #ifdef HOCKEY
|
|
|
166 case PUCK:
|
|
|
167 return puck_width;
|
|
|
168 #endif /*HOCKEY*/
|
|
|
169 case SCOUT:
|
|
|
170 return ori_scout_width;
|
|
|
171 case DESTROYER:
|
|
|
172 return ori_destroyer_width;
|
|
|
173 case CRUISER:
|
|
|
174 return ori_cruiser_width;
|
|
|
175 case BATTLESHIP:
|
|
|
176 return ori_battleship_width;
|
|
|
177 case ASSAULT:
|
|
|
178 return ori_assault_width;
|
|
|
179 case STARBASE:
|
|
|
180 return ori_starbase_width;
|
|
|
181 case JUMPSHIP:
|
|
|
182 return ori_jumpship_width;
|
|
|
183 case FLAGSHIP:
|
|
|
184 return ori_galaxy_width;
|
|
|
185 case GALAXY:
|
|
|
186 return ori_galaxy_width;
|
|
|
187 case WARBASE:
|
|
|
188 return ori_warbase_width;
|
|
|
189 case LIGHTCRUISER:
|
|
|
190 return ori_lightcruiser_width;
|
|
|
191 case CARRIER:
|
|
|
192 return ori_carrier_height;
|
|
|
193 case UTILITY:
|
|
|
194 return ori_utility_width;
|
|
|
195 case PATROL:
|
|
|
196 return ori_patrol_width;
|
|
|
197 }
|
|
|
198 case -1:
|
|
|
199 switch (shipn) {
|
|
|
200 #ifdef HOCKEY
|
|
|
201 case PUCK:
|
|
|
202 return puck_width;
|
|
|
203 #endif /*HOCKEY*/
|
|
|
204 case SCOUT:
|
|
|
205 return ind_scout_width;
|
|
|
206 case DESTROYER:
|
|
|
207 return ind_destroyer_width;
|
|
|
208 case CRUISER:
|
|
|
209 return ind_cruiser_width;
|
|
|
210 case BATTLESHIP:
|
|
|
211 return ind_battleship_width;
|
|
|
212 case ASSAULT:
|
|
|
213 return ind_assault_width;
|
|
|
214 case STARBASE:
|
|
|
215 return ind_starbase_width;
|
|
|
216 case JUMPSHIP:
|
|
|
217 return ind_starbase_width;
|
|
|
218 case FLAGSHIP:
|
|
|
219 return ind_galaxy_width;
|
|
|
220 case GALAXY:
|
|
|
221 return ind_galaxy_width;
|
|
|
222 case WARBASE:
|
|
|
223 return ind_starbase_width;
|
|
|
224 case LIGHTCRUISER:
|
|
|
225 return ind_lightcruiser_width;
|
|
|
226 case CARRIER:
|
|
|
227 return ind_carrier_height;
|
|
|
228 case UTILITY:
|
|
|
229 return ind_utility_width;
|
|
|
230 case PATROL:
|
|
|
231 return ind_patrol_width;
|
|
|
232 }
|
|
|
233 }
|
|
|
234 #endif /* NOSHIPBITMAPS */
|
|
|
235 return 20;
|
|
|
236 }
|
|
|
237
|
|
|
238
|
|
|
239 static int
|
|
|
240 get_ship_height(team, shipn)
|
|
|
241 int team, shipn;
|
|
|
242 {
|
|
|
243 #ifndef NOSHIPBITMAPS
|
|
|
244 if (shipn == ATT && paradise)
|
|
|
245 return att_height;
|
|
|
246 switch (team) {
|
|
|
247 case 0:
|
|
|
248 switch (shipn) {
|
|
|
249 #ifdef HOCKEY
|
|
|
250 case PUCK:
|
|
|
251 return puck_height;
|
|
|
252 #endif /*HOCKEY*/
|
|
|
253 case SCOUT:
|
|
|
254 return fed_scout_height;
|
|
|
255 case DESTROYER:
|
|
|
256 return fed_destroyer_height;
|
|
|
257 case CRUISER:
|
|
|
258 return fed_cruiser_height;
|
|
|
259 case BATTLESHIP:
|
|
|
260 return fed_battleship_height;
|
|
|
261 case ASSAULT:
|
|
|
262 return fed_assault_height;
|
|
|
263 case STARBASE:
|
|
|
264 return fed_starbase_height;
|
|
|
265 case JUMPSHIP:
|
|
|
266 return fed_jumpship_height;
|
|
|
267 case FLAGSHIP:
|
|
|
268 return fed_galaxy_height;
|
|
|
269 case GALAXY:
|
|
|
270 return fed_galaxy_height;
|
|
|
271 case WARBASE:
|
|
|
272 return fed_warbase_height;
|
|
|
273 case LIGHTCRUISER:
|
|
|
274 return fed_lightcruiser_height;
|
|
|
275 case CARRIER:
|
|
|
276 return fed_carrier_height;
|
|
|
277 case UTILITY:
|
|
|
278 return fed_utility_height;
|
|
|
279 case PATROL:
|
|
|
280 return fed_patrol_height;
|
|
|
281 }
|
|
|
282 case 1:
|
|
|
283 switch (shipn) {
|
|
|
284 #ifdef HOCKEY
|
|
|
285 case PUCK:
|
|
|
286 return puck_height;
|
|
|
287 #endif /*HOCKEY*/
|
|
|
288 case SCOUT:
|
|
|
289 return rom_scout_height;
|
|
|
290 case DESTROYER:
|
|
|
291 return rom_destroyer_height;
|
|
|
292 case CRUISER:
|
|
|
293 return rom_cruiser_height;
|
|
|
294 case BATTLESHIP:
|
|
|
295 return rom_battleship_height;
|
|
|
296 case ASSAULT:
|
|
|
297 return rom_assault_height;
|
|
|
298 case STARBASE:
|
|
|
299 return rom_starbase_height;
|
|
|
300 case JUMPSHIP:
|
|
|
301 return rom_jumpship_height;
|
|
|
302 case FLAGSHIP:
|
|
|
303 return rom_galaxy_height;
|
|
|
304 case GALAXY:
|
|
|
305 return rom_galaxy_height;
|
|
|
306 case WARBASE:
|
|
|
307 return rom_warbase_height;
|
|
|
308 case LIGHTCRUISER:
|
|
|
309 return rom_lightcruiser_height;
|
|
|
310 case CARRIER:
|
|
|
311 return rom_carrier_height;
|
|
|
312 case UTILITY:
|
|
|
313 return rom_utility_height;
|
|
|
314 case PATROL:
|
|
|
315 return rom_patrol_height;
|
|
|
316 }
|
|
|
317 case 2:
|
|
|
318 switch (shipn) {
|
|
|
319 #ifdef HOCKEY
|
|
|
320 case PUCK:
|
|
|
321 return puck_height;
|
|
|
322 #endif /*HOCKEY*/
|
|
|
323 case SCOUT:
|
|
|
324 return kli_scout_height;
|
|
|
325 case DESTROYER:
|
|
|
326 return kli_destroyer_height;
|
|
|
327 case CRUISER:
|
|
|
328 return kli_cruiser_height;
|
|
|
329 case BATTLESHIP:
|
|
|
330 return kli_battleship_height;
|
|
|
331 case ASSAULT:
|
|
|
332 return kli_assault_height;
|
|
|
333 case STARBASE:
|
|
|
334 return kli_starbase_height;
|
|
|
335 case JUMPSHIP:
|
|
|
336 return kli_jumpship_height;
|
|
|
337 case FLAGSHIP:
|
|
|
338 return kli_galaxy_height;
|
|
|
339 case GALAXY:
|
|
|
340 return kli_galaxy_height;
|
|
|
341 case WARBASE:
|
|
|
342 return kli_warbase_height;
|
|
|
343 case LIGHTCRUISER:
|
|
|
344 return kli_lightcruiser_height;
|
|
|
345 case CARRIER:
|
|
|
346 return kli_carrier_height;
|
|
|
347 case UTILITY:
|
|
|
348 return kli_utility_height;
|
|
|
349 case PATROL:
|
|
|
350 return kli_patrol_height;
|
|
|
351 }
|
|
|
352 case 3:
|
|
|
353 switch (shipn) {
|
|
|
354 #ifdef HOCKEY
|
|
|
355 case PUCK:
|
|
|
356 return puck_height;
|
|
|
357 #endif /*HOCKEY*/
|
|
|
358 case SCOUT:
|
|
|
359 return ori_scout_height;
|
|
|
360 case DESTROYER:
|
|
|
361 return ori_destroyer_height;
|
|
|
362 case CRUISER:
|
|
|
363 return ori_cruiser_height;
|
|
|
364 case BATTLESHIP:
|
|
|
365 return ori_battleship_height;
|
|
|
366 case ASSAULT:
|
|
|
367 return ori_assault_height;
|
|
|
368 case STARBASE:
|
|
|
369 return ori_starbase_height;
|
|
|
370 case JUMPSHIP:
|
|
|
371 return ori_jumpship_height;
|
|
|
372 case FLAGSHIP:
|
|
|
373 return ori_galaxy_height;
|
|
|
374 case GALAXY:
|
|
|
375 return ori_galaxy_height;
|
|
|
376 case WARBASE:
|
|
|
377 return ori_warbase_height;
|
|
|
378 case LIGHTCRUISER:
|
|
|
379 return ori_lightcruiser_height;
|
|
|
380 case CARRIER:
|
|
|
381 return ori_carrier_height;
|
|
|
382 case UTILITY:
|
|
|
383 return ori_utility_height;
|
|
|
384 case PATROL:
|
|
|
385 return ori_patrol_height;
|
|
|
386 }
|
|
|
387 case -1:
|
|
|
388 switch (shipn) {
|
|
|
389 #ifdef HOCKEY
|
|
|
390 case PUCK:
|
|
|
391 return puck_height;
|
|
|
392 #endif /*HOCKEY*/
|
|
|
393 case SCOUT:
|
|
|
394 return ind_scout_height;
|
|
|
395 case DESTROYER:
|
|
|
396 return ind_destroyer_height;
|
|
|
397 case CRUISER:
|
|
|
398 return ind_cruiser_height;
|
|
|
399 case BATTLESHIP:
|
|
|
400 return ind_battleship_height;
|
|
|
401 case ASSAULT:
|
|
|
402 return ind_assault_height;
|
|
|
403 case STARBASE:
|
|
|
404 return ind_starbase_height;
|
|
|
405 case JUMPSHIP:
|
|
|
406 return ind_starbase_height;
|
|
|
407 case FLAGSHIP:
|
|
|
408 return ind_galaxy_height;
|
|
|
409 case GALAXY:
|
|
|
410 return ind_galaxy_height;
|
|
|
411 case WARBASE:
|
|
|
412 return ind_starbase_height;
|
|
|
413 case LIGHTCRUISER:
|
|
|
414 return ind_lightcruiser_height;
|
|
|
415 case CARRIER:
|
|
|
416 return ind_carrier_height;
|
|
|
417 case UTILITY:
|
|
|
418 return ind_utility_height;
|
|
|
419 case PATROL:
|
|
|
420 return ind_patrol_height;
|
|
|
421 }
|
|
|
422 }
|
|
|
423 #endif /* NOSHIPBITMAPS */
|
|
|
424 return 20;
|
|
|
425 }
|
|
|
426
|
|
|
427 static int
|
|
|
428 get_ship_nviews(shipn)
|
|
|
429 int shipn;
|
|
|
430 {
|
|
|
431 if (shipn == STARBASE ||
|
|
|
432 shipn == WARBASE ||
|
|
|
433 shipn == JUMPSHIP
|
|
|
434 #ifdef HOCKEY
|
|
|
435 || shipn == PUCK
|
|
|
436 #endif /*HOCKEY*/
|
|
|
437 )
|
|
|
438 return 1;
|
|
|
439 else
|
|
|
440 return 16;
|
|
|
441 }
|
|
|
442
|
|
|
443 static unsigned char *
|
|
|
444 get_ship_bits(team, shipn, view)
|
|
|
445 int team, shipn;
|
|
|
446 int view;
|
|
|
447 {
|
|
|
448 #ifndef NOSHIPBITMAPS
|
|
|
449 if (shipn == ATT && paradise) {
|
|
|
450 if (view > 0)
|
|
|
451 view = 0;
|
|
|
452 return att_bits[view];
|
|
|
453 }
|
|
|
454 #endif
|
|
|
455 if (view > 16)
|
|
|
456 view = 0;
|
|
|
457 switch (team) {
|
|
|
458 case 0:
|
|
|
459 #ifndef NOSHIPBITMAPS
|
|
|
460 switch (shipn) {
|
|
|
461 #ifdef HOCKEY
|
|
|
462 case PUCK:
|
|
|
463 return puck_bits;
|
|
|
464 #endif /*HOCKEY*/
|
|
|
465 case SCOUT:
|
|
|
466 return fed_scout_bits[view];
|
|
|
467 case DESTROYER:
|
|
|
468 return fed_destroyer_bits[view];
|
|
|
469 case CRUISER:
|
|
|
470 return fed_cruiser_bits[view];
|
|
|
471 case BATTLESHIP:
|
|
|
472 return fed_battleship_bits[view];
|
|
|
473 case ASSAULT:
|
|
|
474 return fed_assault_bits[view];
|
|
|
475 case STARBASE:
|
|
|
476 return fed_starbase_bits;
|
|
|
477 case JUMPSHIP:
|
|
|
478 return fed_jumpship_bits;
|
|
|
479 case FLAGSHIP:
|
|
|
480 return fed_galaxy_bits[view];
|
|
|
481 case GALAXY:
|
|
|
482 return fed_galaxy_bits[view];
|
|
|
483 case WARBASE:
|
|
|
484 return fed_warbase_bits;
|
|
|
485 case LIGHTCRUISER:
|
|
|
486 return fed_lightcruiser_bits[view];
|
|
|
487 case CARRIER:
|
|
|
488 return fed_carrier_bits[view];
|
|
|
489 case UTILITY:
|
|
|
490 return fed_utility_bits[view];
|
|
|
491 case PATROL:
|
|
|
492 return fed_patrol_bits[view];
|
|
|
493 }
|
|
|
494 #else
|
|
|
495 if (get_ship_nviews(shipn) == 1)
|
|
|
496 return fed_starbase_bits;
|
|
|
497 else
|
|
|
498 return fed_cruiser_bits[view];
|
|
|
499 #endif
|
|
|
500 case 1:
|
|
|
501 #ifndef NOSHIPBITMAPS
|
|
|
502 switch (shipn) {
|
|
|
503 #ifdef HOCKEY
|
|
|
504 case PUCK:
|
|
|
505 return puck_bits;
|
|
|
506 #endif /*HOCKEY*/
|
|
|
507 case SCOUT:
|
|
|
508 return rom_scout_bits[view];
|
|
|
509 case DESTROYER:
|
|
|
510 return rom_destroyer_bits[view];
|
|
|
511 case CRUISER:
|
|
|
512 return rom_cruiser_bits[view];
|
|
|
513 case BATTLESHIP:
|
|
|
514 return rom_battleship_bits[view];
|
|
|
515 case ASSAULT:
|
|
|
516 return rom_assault_bits[view];
|
|
|
517 case STARBASE:
|
|
|
518 return rom_starbase_bits;
|
|
|
519 case JUMPSHIP:
|
|
|
520 return rom_jumpship_bits;
|
|
|
521 case FLAGSHIP:
|
|
|
522 return rom_galaxy_bits[view];
|
|
|
523 case GALAXY:
|
|
|
524 return rom_galaxy_bits[view];
|
|
|
525 case WARBASE:
|
|
|
526 return rom_warbase_bits;
|
|
|
527 case LIGHTCRUISER:
|
|
|
528 return rom_lightcruiser_bits[view];
|
|
|
529 case CARRIER:
|
|
|
530 return rom_carrier_bits[view];
|
|
|
531 case UTILITY:
|
|
|
532 return rom_utility_bits[view];
|
|
|
533 case PATROL:
|
|
|
534 return rom_patrol_bits[view];
|
|
|
535 }
|
|
|
536 #else
|
|
|
537 if (get_ship_nviews(shipn) == 1)
|
|
|
538 return rom_starbase_bits;
|
|
|
539 else
|
|
|
540 return rom_cruiser_bits[view];
|
|
|
541 #endif
|
|
|
542 case 2:
|
|
|
543 #ifndef NOSHIPBITMAPS
|
|
|
544 switch (shipn) {
|
|
|
545 #ifdef HOCKEY
|
|
|
546 case PUCK:
|
|
|
547 return puck_bits;
|
|
|
548 #endif /*HOCKEY*/
|
|
|
549 case SCOUT:
|
|
|
550 return kli_scout_bits[view];
|
|
|
551 case DESTROYER:
|
|
|
552 return kli_destroyer_bits[view];
|
|
|
553 case CRUISER:
|
|
|
554 return kli_cruiser_bits[view];
|
|
|
555 case BATTLESHIP:
|
|
|
556 return kli_battleship_bits[view];
|
|
|
557 case ASSAULT:
|
|
|
558 return kli_assault_bits[view];
|
|
|
559 case STARBASE:
|
|
|
560 return kli_starbase_bits;
|
|
|
561 case JUMPSHIP:
|
|
|
562 return kli_jumpship_bits;
|
|
|
563 case FLAGSHIP:
|
|
|
564 return kli_galaxy_bits[view];
|
|
|
565 case GALAXY:
|
|
|
566 return kli_galaxy_bits[view];
|
|
|
567 case WARBASE:
|
|
|
568 return kli_warbase_bits;
|
|
|
569 case LIGHTCRUISER:
|
|
|
570 return kli_lightcruiser_bits[view];
|
|
|
571 case CARRIER:
|
|
|
572 return kli_carrier_bits[view];
|
|
|
573 case UTILITY:
|
|
|
574 return kli_utility_bits[view];
|
|
|
575 case PATROL:
|
|
|
576 return kli_patrol_bits[view];
|
|
|
577 }
|
|
|
578 #else
|
|
|
579 if (get_ship_nviews(shipn) == 1)
|
|
|
580 return kli_starbase_bits;
|
|
|
581 else
|
|
|
582 return kli_cruiser_bits[view];
|
|
|
583 #endif
|
|
|
584 case 3:
|
|
|
585 #ifndef NOSHIPBITMAPS
|
|
|
586 switch (shipn) {
|
|
|
587 #ifdef HOCKEY
|
|
|
588 case PUCK:
|
|
|
589 return puck_bits;
|
|
|
590 #endif /*HOCKEY*/
|
|
|
591 case SCOUT:
|
|
|
592 return ori_scout_bits[view];
|
|
|
593 case DESTROYER:
|
|
|
594 return ori_destroyer_bits[view];
|
|
|
595 case CRUISER:
|
|
|
596 return ori_cruiser_bits[view];
|
|
|
597 case BATTLESHIP:
|
|
|
598 return ori_battleship_bits[view];
|
|
|
599 case ASSAULT:
|
|
|
600 return ori_assault_bits[view];
|
|
|
601 case STARBASE:
|
|
|
602 return ori_starbase_bits;
|
|
|
603 case JUMPSHIP:
|
|
|
604 return ori_jumpship_bits;
|
|
|
605 case FLAGSHIP:
|
|
|
606 return ori_galaxy_bits[view];
|
|
|
607 case GALAXY:
|
|
|
608 return ori_galaxy_bits[view];
|
|
|
609 case WARBASE:
|
|
|
610 return ori_warbase_bits;
|
|
|
611 case LIGHTCRUISER:
|
|
|
612 return ori_lightcruiser_bits[view];
|
|
|
613 case CARRIER:
|
|
|
614 return ori_carrier_bits[view];
|
|
|
615 case UTILITY:
|
|
|
616 return ori_utility_bits[view];
|
|
|
617 case PATROL:
|
|
|
618 return ori_patrol_bits[view];
|
|
|
619 }
|
|
|
620 #else
|
|
|
621 if (get_ship_nviews(shipn) == 1)
|
|
|
622 return ori_starbase_bits;
|
|
|
623 else
|
|
|
624 return ori_cruiser_bits[view];
|
|
|
625 #endif
|
|
|
626 case -1:
|
|
|
627 #ifndef NOSHIPBITMAPS
|
|
|
628 switch (shipn) {
|
|
|
629 #ifdef HOCKEY
|
|
|
630 case PUCK:
|
|
|
631 return puck_bits;
|
|
|
632 #endif /*HOCKEY*/
|
|
|
633 case SCOUT:
|
|
|
634 return ind_scout_bits[view];
|
|
|
635 case DESTROYER:
|
|
|
636 return ind_destroyer_bits[view];
|
|
|
637 case CRUISER:
|
|
|
638 return ind_cruiser_bits[view];
|
|
|
639 case BATTLESHIP:
|
|
|
640 return ind_battleship_bits[view];
|
|
|
641 case ASSAULT:
|
|
|
642 return ind_assault_bits[view];
|
|
|
643 case STARBASE:
|
|
|
644 return ind_starbase_bits;
|
|
|
645 case JUMPSHIP:
|
|
|
646 return ind_starbase_bits;
|
|
|
647 case FLAGSHIP:
|
|
|
648 return ind_galaxy_bits[view];
|
|
|
649 case GALAXY:
|
|
|
650 return ind_galaxy_bits[view];
|
|
|
651 case WARBASE:
|
|
|
652 return ind_starbase_bits;
|
|
|
653 case LIGHTCRUISER:
|
|
|
654 return ind_lightcruiser_bits[view];
|
|
|
655 case CARRIER:
|
|
|
656 return ind_carrier_bits[view];
|
|
|
657 case UTILITY:
|
|
|
658 return ind_utility_bits[view];
|
|
|
659 case PATROL:
|
|
|
660 return ind_patrol_bits[view];
|
|
|
661 }
|
|
|
662 #else
|
|
|
663 if (get_ship_nviews(shipn) == 1)
|
|
|
664 return fed_starbase_bits;
|
|
|
665 else
|
|
|
666 return fed_cruiser_bits[view];
|
|
|
667 #endif
|
|
|
668 }
|
|
|
669 return fed_cruiser_bits[view];
|
|
|
670 }
|
|
|
671
|
|
|
672
|
|
|
673 /* points at the beginning of the fed ship shapes. Independent are
|
|
|
674 at negative indices */
|
|
|
675 static struct ship_shape *all_ship_shapes = 0;
|
|
|
676
|
|
|
677 struct ship_shape *
|
|
|
678 shape_of_ship(team, shipclass)
|
|
|
679 int team, shipclass;
|
|
|
680 {
|
|
|
681 if (team < -1 || team >= number_of_teams ||
|
|
|
682 shipclass < 0 || shipclass >= nshiptypes)
|
|
|
683 return &all_ship_shapes[-nshiptypes];
|
|
|
684 return &all_ship_shapes[team * nshiptypes + shipclass];
|
|
|
685 }
|
|
|
686
|
|
|
687 void
|
|
|
688 clear_one_ship_shape(shp)
|
|
|
689 struct ship_shape *shp;
|
|
|
690 {
|
|
|
691 int j;
|
|
|
692 for (j = 0; j < shp->nviews; j++) {
|
|
|
693 W_FreeBitmap(shp->bmap[j]);
|
|
|
694 }
|
|
|
695 shp->nviews = 0;
|
|
|
696 free(shp->bmap);
|
|
|
697 shp->bmap = 0;
|
|
|
698 W_FreeBitmap(shp->shield);
|
|
|
699 shp->shield = 0;
|
|
|
700 }
|
|
|
701
|
|
|
702 void
|
|
|
703 free_shipshapes()
|
|
|
704 {
|
|
|
705 /* don't forget that IND offset */
|
|
|
706 int race, i;
|
|
|
707 if (!all_ship_shapes) /* if nothing there to begin with */
|
|
|
708 return;
|
|
|
709 for (race = -1; race < number_of_teams; race++) {
|
|
|
710 for (i = 0; i < nshiptypes; i++) {
|
|
|
711 clear_one_ship_shape(shape_of_ship(race, i));
|
|
|
712 }
|
|
|
713 }
|
|
|
714 free(all_ship_shapes - nshiptypes);
|
|
|
715 all_ship_shapes = 0;
|
|
|
716 }
|
|
|
717
|
|
|
718 void
|
|
|
719 slurp_ship_bitmaps()
|
|
|
720 {
|
|
|
721 int i, race, k;
|
|
|
722 int width, height, size = 0;
|
|
|
723 int nviews; /* NYI */
|
|
|
724 unsigned char *buf = 0, *buf2;
|
|
|
725 char *freeme;
|
|
|
726 char *mainbitmapdir, *bitmapdir;
|
|
|
727 static char path[MAXPATHLEN];
|
|
|
728
|
|
|
729 if (all_ship_shapes == 0) {
|
|
|
730 all_ship_shapes = nshiptypes + (struct ship_shape *)
|
|
|
731 malloc(sizeof(*all_ship_shapes) * (number_of_teams + 1) * nshiptypes);
|
|
|
732 }
|
|
|
733 mainbitmapdir = stringDefault("shipBitmapPath",
|
|
|
734 #ifndef AMIGA /* worked this way, sort of... was annoying. */
|
|
|
735 "/usr/games/lib/netrek"
|
|
|
736 #else
|
|
|
737 "netrek:graphics"
|
|
|
738 #endif /* AMIGA */
|
|
|
739 );
|
|
|
740 mainbitmapdir = expandFilename(mainbitmapdir);
|
|
|
741
|
|
|
742 for (race = -1 /* IND */ ; race < number_of_teams; race++) {
|
|
|
743 freeme = NULL;
|
|
|
744 /* you can now have a different bitmapDir for each race [BDyess] */
|
|
|
745 sprintf(path, "shipBitmapPath.%d", race);
|
|
|
746 if ((bitmapdir = getdefault(path)) == NULL)
|
|
|
747 bitmapdir = mainbitmapdir;
|
|
|
748 else
|
|
|
749 bitmapdir = freeme = expandFilename((char *) strdup(bitmapdir));
|
|
|
750 for (k = 0; k < nshiptypes; k++) {
|
|
|
751 struct ship_shape *curr_shape = shape_of_ship(race, k);
|
|
|
752 FILE *fp;
|
|
|
753 sprintf(path, "%s/R%d.C%d", bitmapdir, race, k);
|
|
|
754
|
|
|
755 fp = fopen(path, "r");
|
|
|
756 if (fp == 0) {
|
|
|
757 if (errno != ENOENT) {
|
|
|
758 fprintf(stderr, "Error accessing ship bitmap file %s:", path);
|
|
|
759 perror("");
|
|
|
760 }
|
|
|
761 nviews = get_ship_nviews(k, 0);
|
|
|
762 width = get_ship_width(race, k, 0);
|
|
|
763 height = get_ship_height(race, k, 0);
|
|
|
764 } else {
|
|
|
765 fread(&nviews, sizeof(nviews), 1, fp);
|
|
|
766 nviews = ntohl(nviews);
|
|
|
767 fread(&width, sizeof(width), 1, fp);
|
|
|
768 width = ntohl(width);
|
|
|
769 fread(&height, sizeof(height), 1, fp);
|
|
|
770 height = ntohl(height);
|
|
|
771 if (nviews > get_ship_nviews(k, 0))
|
|
|
772 nviews = get_ship_nviews(k, 0);
|
|
|
773 size = (width + 7) / 8 * height;
|
|
|
774 buf = (unsigned char *) malloc(size);
|
|
|
775 }
|
|
|
776
|
|
|
777 curr_shape->nviews = nviews /* nviews */ ;
|
|
|
778 curr_shape->width = width;
|
|
|
779 curr_shape->height = height;
|
|
|
780 curr_shape->shield = W_MakeShieldBitmap(width, height, w);
|
|
|
781
|
|
|
782 curr_shape->bmap = (W_Icon *) malloc(sizeof(*curr_shape->bmap) *
|
|
|
783 nviews);
|
|
|
784
|
|
|
785 for (i = 0; i < nviews; i++) {
|
|
|
786 if (fp) {
|
|
|
787 fread(buf, size, 1, fp);
|
|
|
788 curr_shape->bmap[i] =
|
|
|
789 W_StoreBitmap(width, height, buf, w);
|
|
|
790 } else {
|
|
|
791 buf2 = get_ship_bits(race, k, i);
|
|
|
792 curr_shape->bmap[i] =
|
|
|
793 W_StoreBitmap(width, height, buf2, w);
|
|
|
794 }
|
|
|
795
|
|
|
796 #if 0
|
|
|
797 /* these widths and heights are not necessarily correct */
|
|
|
798 if (fp)
|
|
|
799 buf2 = get_ship_bits(race, k, i, blk_altbits);
|
|
|
800 else
|
|
|
801 buf2 = get_ship_bits(race, k, i, !blk_altbits);
|
|
|
802
|
|
|
803 curr_shape->bmap[i + (blk_altbits ? 0 : nviews)] =
|
|
|
804 W_StoreBitmap(width, height, buf2, w);
|
|
|
805 #endif
|
|
|
806 }
|
|
|
807
|
|
|
808 if (fp) {
|
|
|
809 free(buf);
|
|
|
810 fclose(fp);
|
|
|
811 }
|
|
|
812 }
|
|
|
813 if (freeme)
|
|
|
814 free(freeme);
|
|
|
815 }
|
|
|
816 }
|
|
|
817
|
|
|
818 void
|
|
|
819 replace_shipshape(race, shiptype, nviews, width, height)
|
|
|
820 int race, shiptype, nviews, width, height;
|
|
|
821 {
|
|
|
822 struct ship_shape *shp = shape_of_ship(race, shiptype);
|
|
|
823 int i;
|
|
|
824
|
|
|
825 clear_one_ship_shape(shp);
|
|
|
826
|
|
|
827 shp->nviews = nviews;
|
|
|
828 shp->bmap = (W_Icon *) malloc(sizeof(*shp->bmap) * nviews);
|
|
|
829 shp->width = width;
|
|
|
830 shp->height = height;
|
|
|
831 shp->shield = W_MakeShieldBitmap(width, height, w);
|
|
|
832 for (i = 0; i < nviews; i++) {
|
|
|
833 /* we really should check the files again. */
|
|
|
834 shp->bmap[i] = W_StoreBitmap(get_ship_width(race, shiptype),
|
|
|
835 get_ship_height(race, shiptype),
|
|
|
836 get_ship_bits(race, shiptype, i, 0),
|
|
|
837 w);
|
|
|
838 #if 0
|
|
|
839 shp->bmap[i + nviews] = W_StoreBitmap(get_ship_width(race, shiptype),
|
|
|
840 get_ship_height(race, shiptype),
|
|
|
841 get_ship_bits(race, shiptype, i, 0),
|
|
|
842 w);
|
|
|
843 #endif
|
|
|
844 }
|
|
|
845 }
|
|
|
846
|
|
|
847
|
|
|
848 void
|
|
|
849 replace_ship_bitmap(race, shiptype, view, bits)
|
|
|
850 int race, shiptype, view;
|
|
|
851 unsigned char *bits;
|
|
|
852 {
|
|
|
853 struct ship_shape *shp = shape_of_ship(race, shiptype);
|
|
|
854
|
|
|
855 if (view >= shp->nviews) {
|
|
|
856 fprintf(stderr, "race %d, ship class %d: view %d out of range (0..%d)\n",
|
|
|
857 race, shiptype, view, shp->nviews - 1);
|
|
|
858 return;
|
|
|
859 }
|
|
|
860 W_FreeBitmap(shp->bmap[view]);
|
|
|
861 /* store the bitmaps into the auxiliary view */
|
|
|
862 shp->bmap[view] = W_StoreBitmap(shp->width, shp->height, bits, w);
|
|
|
863 }
|
