~mdw / newkind / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Proper Subversion configuration.
[newkind] / docked.c
1 /*
2 * Elite - The New Kind.
3 *
4 * Reverse engineered from the BBC disk version of Elite.
5 * Additional material by C.J.Pinder.
6 *
7 * The original Elite code is (C) I.Bell & D.Braben 1984.
8 * This version re-engineered in C by C.J.Pinder 1999-2001.
9 *
10 * email: <christian@newkind.co.uk>
11 *
12 *
13 */
14
15
16 #include <string.h>
17 #include <stdlib.h>
18 #include <stdio.h>
19 #include <math.h>
20 #include <ctype.h>
21
22 #include "config.h"
23 #include "gfx.h"
24 #include "elite.h"
25 #include "planet.h"
26 #include "shipdata.h"
27 #include "space.h"
28 #include "keyboard.h"
29
30
31
32
33 char *economy_type[] = {"Rich Industrial",
34 "Average Industrial",
35 "Poor Industrial",
36 "Mainly Industrial",
37 "Mainly Agricultural",
38 "Rich Agricultural",
39 "Average Agricultural",
40 "Poor Agricultural"};
41
42 char *government_type[] = { "Anarchy",
43 "Feudal",
44 "Multi-Government",
45 "Dictatorship",
46 "Communist",
47 "Confederacy",
48 "Democracy",
49 "Corporate State"};
50
51
52
53
54
55
56 int cross_x = 0;
57 int cross_y = 0;
58
59
60
61
62
63
64
65 void draw_fuel_limit_circle (int cx, int cy)
66 {
67 int radius;
68 int cross_size;
69
70 if (current_screen == SCR_GALACTIC_CHART)
71 {
72 radius = cmdr.fuel / 4 * GFX_SCALE;
73 cross_size = 7 * GFX_SCALE;
74 }
75 else
76 {
77 radius = cmdr.fuel * GFX_SCALE;
78 cross_size = 16 * GFX_SCALE;
79 }
80
81 gfx_draw_circle (cx, cy, radius, GFX_COL_GREEN_1);
82
83 gfx_draw_line (cx, cy - cross_size, cx, cy + cross_size);
84 gfx_draw_line (cx - cross_size, cy, cx + cross_size, cy);
85 }
86
87
88
89
90
91 int calc_distance_to_planet (struct galaxy_seed from_planet, struct galaxy_seed to_planet)
92 {
93 int dx,dy;
94 int light_years;
95
96 dx = abs(to_planet.d - from_planet.d);
97 dy = abs(to_planet.b - from_planet.b);
98
99 dx = dx * dx;
100 dy = dy / 2;
101 dy = dy * dy;
102
103 light_years = sqrt(dx + dy);
104 light_years *= 4;
105
106 return light_years;
107 }
108
109
110 void show_distance (int ypos, struct galaxy_seed from_planet, struct galaxy_seed to_planet)
111 {
112 char str[100];
113 int light_years;
114
115 light_years = calc_distance_to_planet (from_planet, to_planet);
116
117 if (light_years > 0)
118 sprintf (str, "Distance: %2d.%d Light Years ", light_years / 10, light_years % 10);
119 else
120 strcpy (str," ");
121
122 gfx_display_text (16, ypos, str);
123 }
124
125
126
127 void show_distance_to_planet (void)
128 {
129 int px,py;
130 char planet_name[16];
131 char str[32];
132
133 if (current_screen == SCR_GALACTIC_CHART)
134 {
135 px = cross_x / GFX_SCALE;
136 py = (cross_y - ((18 * GFX_SCALE) + 1)) * (2 / GFX_SCALE);
137 }
138 else
139 {
140 px = ((cross_x - GFX_X_CENTRE) / (4 * GFX_SCALE)) + docked_planet.d;
141 py = ((cross_y - GFX_Y_CENTRE) / (2 * GFX_SCALE)) + docked_planet.b;
142 }
143
144 hyperspace_planet = find_planet (px, py);
145
146 name_planet (planet_name, hyperspace_planet);
147
148 gfx_clear_text_area();
149 sprintf (str, "%-18s", planet_name);
150 gfx_display_text (16, 340, str);
151
152 show_distance (356, docked_planet, hyperspace_planet);
153
154 if (current_screen == SCR_GALACTIC_CHART)
155 {
156 cross_x = hyperspace_planet.d * GFX_SCALE;
157 cross_y = hyperspace_planet.b / (2 / GFX_SCALE) + (18 * GFX_SCALE) + 1;
158 }
159 else
160 {
161 cross_x = ((hyperspace_planet.d - docked_planet.d) * (4 * GFX_SCALE)) + GFX_X_CENTRE;
162 cross_y = ((hyperspace_planet.b - docked_planet.b) * (2 * GFX_SCALE)) + GFX_Y_CENTRE;
163 }
164 }
165
166
167 void move_cursor_to_origin (void)
168 {
169 if (current_screen == SCR_GALACTIC_CHART)
170 {
171 cross_x = docked_planet.d * GFX_SCALE;
172 cross_y = docked_planet.b / (2 / GFX_SCALE) + (18 * GFX_SCALE) + 1;
173 }
174 else
175 {
176 cross_x = GFX_X_CENTRE;
177 cross_y = GFX_Y_CENTRE;
178 }
179
180 show_distance_to_planet();
181 }
182
183
184 void find_planet_by_name (char *find_name)
185 {
186 int i;
187 struct galaxy_seed glx;
188 char planet_name[16];
189 int found;
190 char str[32];
191
192 glx = cmdr.galaxy;
193 found = 0;
194
195 for (i = 0; i < 256; i++)
196 {
197 name_planet (planet_name, glx);
198
199 if (strcmp (planet_name, find_name) == 0)
200 {
201 found = 1;
202 break;
203 }
204
205 waggle_galaxy (&glx);
206 waggle_galaxy (&glx);
207 waggle_galaxy (&glx);
208 waggle_galaxy (&glx);
209 }
210
211 if (!found)
212 {
213 gfx_clear_text_area();
214 gfx_display_text (16, 340, "Unknown Planet");
215 return;
216 }
217
218 hyperspace_planet = glx;
219
220 gfx_clear_text_area ();
221 sprintf (str, "%-18s", planet_name);
222 gfx_display_text (16, 340, str);
223
224 show_distance (356, docked_planet, hyperspace_planet);
225
226 if (current_screen == SCR_GALACTIC_CHART)
227 {
228 cross_x = hyperspace_planet.d * GFX_SCALE;
229 cross_y = hyperspace_planet.b / (2 / GFX_SCALE) + (18 * GFX_SCALE) + 1;
230 }
231 else
232 {
233 cross_x = ((hyperspace_planet.d - docked_planet.d) * (4 * GFX_SCALE)) + GFX_X_CENTRE;
234 cross_y = ((hyperspace_planet.b - docked_planet.b) * (2 * GFX_SCALE)) + GFX_Y_CENTRE;
235 }
236 }
237
238
239
240 void display_short_range_chart (void)
241 {
242 int i;
243 struct galaxy_seed glx;
244 int dx,dy;
245 int px,py;
246 char planet_name[16];
247 int row_used[64];
248 int row;
249 int blob_size;
250
251 current_screen = SCR_SHORT_RANGE;
252
253 gfx_clear_display();
254
255 gfx_display_centre_text (10, "SHORT RANGE CHART", 140, GFX_COL_GOLD);
256
257 gfx_draw_line (0, 36, 511, 36);
258
259 draw_fuel_limit_circle (GFX_X_CENTRE, GFX_Y_CENTRE);
260
261 for (i = 0; i < 64; i++)
262 row_used[i] = 0;
263
264 glx = cmdr.galaxy;
265
266 for (i = 0; i < 256; i++)
267 {
268
269 dx = abs (glx.d - docked_planet.d);
270 dy = abs (glx.b - docked_planet.b);
271
272 if ((dx >= 20) || (dy >= 38))
273 {
274 waggle_galaxy (&glx);
275 waggle_galaxy (&glx);
276 waggle_galaxy (&glx);
277 waggle_galaxy (&glx);
278
279 continue;
280 }
281
282 px = (glx.d - docked_planet.d);
283 px = px * 4 * GFX_SCALE + GFX_X_CENTRE; /* Convert to screen co-ords */
284
285 py = (glx.b - docked_planet.b);
286 py = py * 2 * GFX_SCALE + GFX_Y_CENTRE; /* Convert to screen co-ords */
287
288 row = py / (8 * GFX_SCALE);
289
290 if (row_used[row] == 1)
291 row++;
292
293 if (row_used[row] == 1)
294 row -= 2;
295
296 if (row <= 3)
297 {
298 waggle_galaxy (&glx);
299 waggle_galaxy (&glx);
300 waggle_galaxy (&glx);
301 waggle_galaxy (&glx);
302
303 continue;
304 }
305
306 if (row_used[row] == 0)
307 {
308 row_used[row] = 1;
309
310 name_planet (planet_name, glx);
311 capitalise_name (planet_name);
312
313 gfx_display_text (px + (4 * GFX_SCALE), (row * 8 - 5) * GFX_SCALE, planet_name);
314 }
315
316
317 /* The next bit calculates the size of the circle used to represent */
318 /* a planet. The carry_flag is left over from the name generation. */
319 /* Yes this was how it was done... don't ask :-( */
320
321 blob_size = (glx.f & 1) + 2 + carry_flag;
322 blob_size *= GFX_SCALE;
323 gfx_draw_filled_circle (px, py, blob_size, GFX_COL_GOLD);
324
325 waggle_galaxy (&glx);
326 waggle_galaxy (&glx);
327 waggle_galaxy (&glx);
328 waggle_galaxy (&glx);
329 }
330
331 cross_x = ((hyperspace_planet.d - docked_planet.d) * 4 * GFX_SCALE) + GFX_X_CENTRE;
332 cross_y = ((hyperspace_planet.b - docked_planet.b) * 2 * GFX_SCALE) + GFX_Y_CENTRE;
333 }
334
335
336
337
338 void display_galactic_chart (void)
339 {
340 int i;
341 struct galaxy_seed glx;
342 char str[64];
343 int px,py;
344
345
346 current_screen = SCR_GALACTIC_CHART;
347
348 gfx_clear_display();
349
350 sprintf (str, "GALACTIC CHART %d", cmdr.galaxy_number + 1);
351
352 gfx_display_centre_text (10, str, 140, GFX_COL_GOLD);
353
354 gfx_draw_line (0, 36, 511, 36);
355 gfx_draw_line (0, 36+258, 511, 36+258);
356
357 draw_fuel_limit_circle (docked_planet.d * GFX_SCALE,
358 (docked_planet.b / (2 / GFX_SCALE)) + (18 * GFX_SCALE) + 1);
359
360 glx = cmdr.galaxy;
361
362 for (i = 0; i < 256; i++)
363 {
364 px = glx.d * GFX_SCALE;
365 py = (glx.b / (2 / GFX_SCALE)) + (18 * GFX_SCALE) + 1;
366
367 gfx_plot_pixel (px, py, GFX_COL_WHITE);
368
369 if ((glx.e | 0x50) < 0x90)
370 gfx_plot_pixel (px + 1, py, GFX_COL_WHITE);
371
372 waggle_galaxy (&glx);
373 waggle_galaxy (&glx);
374 waggle_galaxy (&glx);
375 waggle_galaxy (&glx);
376
377 }
378
379
380 cross_x = hyperspace_planet.d * GFX_SCALE;
381 cross_y = (hyperspace_planet.b / (2 / GFX_SCALE)) + (18 * GFX_SCALE) + 1;
382 }
383
384
385
386
387
388 /*
389 * Displays data on the currently selected Hyperspace Planet.
390 */
391
392 void display_data_on_planet (void)
393 {
394 char planet_name[16];
395 char str[100];
396 char *description;
397 struct planet_data hyper_planet_data;
398
399 current_screen = SCR_PLANET_DATA;
400
401 gfx_clear_display();
402
403 name_planet (planet_name, hyperspace_planet);
404 sprintf (str, "DATA ON %s", planet_name);
405
406 gfx_display_centre_text (10, str, 140, GFX_COL_GOLD);
407
408 gfx_draw_line (0, 36, 511, 36);
409
410
411 generate_planet_data (&hyper_planet_data, hyperspace_planet);
412
413 show_distance (42, docked_planet, hyperspace_planet);
414
415 sprintf (str, "Economy:%s", economy_type[hyper_planet_data.economy]);
416 gfx_display_text (16, 74, str);
417
418 sprintf (str, "Government:%s", government_type[hyper_planet_data.government]);
419 gfx_display_text (16, 106, str);
420
421 sprintf (str, "Tech.Level:%3d", hyper_planet_data.techlevel + 1);
422 gfx_display_text (16, 138, str);
423
424 sprintf (str, "Population:%d.%d Billion", hyper_planet_data.population / 10, hyper_planet_data.population % 10);
425 gfx_display_text (16, 170, str);
426
427 describe_inhabitants (str, hyperspace_planet);
428 gfx_display_text (16, 202, str);
429
430 sprintf (str, "Gross Productivity:%5d M CR", hyper_planet_data.productivity);
431 gfx_display_text (16, 234, str);
432
433 sprintf (str, "Average Radius:%5d km", hyper_planet_data.radius);
434 gfx_display_text (16, 266, str);
435
436 description = describe_planet (hyperspace_planet);
437 gfx_display_pretty_text (16, 298, 400, 384, description);
438 }
439
440
441
442 struct rank
443 {
444 int score;
445 char *title;
446 };
447
448 #define NO_OF_RANKS 9
449
450 struct rank rating[NO_OF_RANKS] =
451 {
452 {0x0000, "Harmless"},
453 {0x0008, "Mostly Harmless"},
454 {0x0010, "Poor"},
455 {0x0020, "Average"},
456 {0x0040, "Above Average"},
457 {0x0080, "Competent"},
458 {0x0200, "Dangerous"},
459 {0x0A00, "Deadly"},
460 {0x1900, "--- E L I T E ---"}
461 };
462
463 char *laser_name[5] = {"Pulse", "Beam", "Military", "Mining", "Custom"};
464
465
466
467 char *laser_type (int strength)
468 {
469 switch (strength)
470 {
471 case PULSE_LASER:
472 return laser_name[0];
473
474 case BEAM_LASER:
475 return laser_name[1];
476
477 case MILITARY_LASER:
478 return laser_name[2];
479
480 case MINING_LASER:
481 return laser_name[3];
482 }
483
484 return laser_name[4];
485 }
486
487
488 #define EQUIP_START_Y 202
489 #define EQUIP_START_X 50
490 #define EQUIP_MAX_Y 290
491 #define EQUIP_WIDTH 200
492 #define Y_INC 16
493
494
495 static char *condition_txt[] =
496 {
497 "Docked",
498 "Green",
499 "Yellow",
500 "Red",
501 "Red"
502 };
503
504 void display_commander_status (void)
505 {
506 char planet_name[16];
507 char str[100];
508 int i;
509 int x,y;
510
511 current_screen = SCR_CMDR_STATUS;
512
513 gfx_clear_display();
514
515 sprintf (str, "COMMANDER %s", cmdr.name);
516
517 gfx_display_centre_text (10, str, 140, GFX_COL_GOLD);
518
519 gfx_draw_line (0, 36, 511, 36);
520
521
522 gfx_display_colour_text (16, 58, "Present System:", GFX_COL_GREEN_1);
523
524 if (!witchspace)
525 {
526 name_planet (planet_name, docked_planet);
527 capitalise_name (planet_name);
528 sprintf (str, "%s", planet_name);
529 gfx_display_text (190, 58, str);
530 }
531
532 gfx_display_colour_text (16, 74, "Hyperspace System:", GFX_COL_GREEN_1);
533 name_planet (planet_name, hyperspace_planet);
534 capitalise_name (planet_name);
535 sprintf (str, "%s", planet_name);
536 gfx_display_text (190, 74, str);
537
538 gfx_display_colour_text (16, 90, "Condition:", GFX_COL_GREEN_1);
539 gfx_display_text (190, 90, condition_txt[condition]);
540
541 sprintf (str, "%d.%d Light Years", cmdr.fuel / 10, cmdr.fuel % 10);
542 gfx_display_colour_text (16, 106, "Fuel:", GFX_COL_GREEN_1);
543 gfx_display_text (70, 106, str);
544
545 sprintf (str, "%d.%d Cr", cmdr.credits / 10, cmdr.credits % 10);
546 gfx_display_colour_text (16, 122, "Cash:", GFX_COL_GREEN_1);
547 gfx_display_text (70, 122, str);
548
549 if (cmdr.legal_status == 0)
550 strcpy (str, "Clean");
551 else
552 strcpy (str, cmdr.legal_status > 50 ? "Fugitive" : "Offender");
553
554 gfx_display_colour_text (16, 138, "Legal Status:", GFX_COL_GREEN_1);
555 gfx_display_text (128, 138, str);
556
557 for (i = 0; i < NO_OF_RANKS; i++)
558 if (cmdr.score >= rating[i].score)
559 strcpy (str, rating[i].title);
560
561 gfx_display_colour_text (16, 154, "Rating:", GFX_COL_GREEN_1);
562 gfx_display_text (80, 154, str);
563
564 gfx_display_colour_text (16, 186, "EQUIPMENT:", GFX_COL_GREEN_1);
565
566 x = EQUIP_START_X;
567 y = EQUIP_START_Y;
568
569 if (cmdr.cargo_capacity > 20)
570 {
571 gfx_display_text (x, y, "Large Cargo Bay");
572 y += Y_INC;
573 }
574
575 if (cmdr.escape_pod)
576 {
577 gfx_display_text (x, y, "Escape Pod");
578 y += Y_INC;
579 }
580
581 if (cmdr.fuel_scoop)
582 {
583 gfx_display_text (x, y, "Fuel Scoops");
584 y += Y_INC;
585 }
586
587 if (cmdr.ecm)
588 {
589 gfx_display_text (x, y, "E.C.M. System");
590 y += Y_INC;
591 }
592
593 if (cmdr.energy_bomb)
594 {
595 gfx_display_text (x, y, "Energy Bomb");
596 y += Y_INC;
597 }
598
599 if (cmdr.energy_unit)
600 {
601 gfx_display_text (x, y,
602 cmdr.energy_unit == 1 ? "Extra Energy Unit" :"Naval Energy Unit");
603 y += Y_INC;
604 if (y > EQUIP_MAX_Y)
605 {
606 y = EQUIP_START_Y;
607 x += EQUIP_WIDTH;
608 }
609 }
610
611 if (cmdr.docking_computer)
612 {
613 gfx_display_text (x, y, "Docking Computers");
614 y += Y_INC;
615 if (y > EQUIP_MAX_Y)
616 {
617 y = EQUIP_START_Y;
618 x += EQUIP_WIDTH;
619 }
620 }
621
622
623 if (cmdr.galactic_hyperdrive)
624 {
625 gfx_display_text (x, y, "Galactic Hyperspace");
626 y += Y_INC;
627 if (y > EQUIP_MAX_Y)
628 {
629 y = EQUIP_START_Y;
630 x += EQUIP_WIDTH;
631 }
632 }
633
634 if (cmdr.front_laser)
635 {
636 sprintf (str, "Front %s Laser", laser_type(cmdr.front_laser));
637 gfx_display_text (x, y, str);
638 y += Y_INC;
639 if (y > EQUIP_MAX_Y)
640 {
641 y = EQUIP_START_Y;
642 x += EQUIP_WIDTH;
643 }
644 }
645
646 if (cmdr.rear_laser)
647 {
648 sprintf (str, "Rear %s Laser", laser_type(cmdr.rear_laser));
649 gfx_display_text (x, y, str);
650 y += Y_INC;
651 if (y > EQUIP_MAX_Y)
652 {
653 y = EQUIP_START_Y;
654 x += EQUIP_WIDTH;
655 }
656 }
657
658 if (cmdr.left_laser)
659 {
660 sprintf (str, "Left %s Laser", laser_type(cmdr.left_laser));
661 gfx_display_text (x, y, str);
662 y += Y_INC;
663 if (y > EQUIP_MAX_Y)
664 {
665 y = EQUIP_START_Y;
666 x += EQUIP_WIDTH;
667 }
668 }
669
670 if (cmdr.right_laser)
671 {
672 sprintf (str, "Right %s Laser", laser_type(cmdr.right_laser));
673 gfx_display_text (x, y, str);
674 }
675 }
676
677
678
679 /***********************************************************************************/
680
681 #define TONNES 0
682 #define KILOGRAMS 1
683 #define GRAMS 2
684
685 static int hilite_item;
686 static char *unit_name[] = {"t", "kg", "g"};
687
688
689 void display_stock_price (int i)
690 {
691 int y;
692 char str[100];
693
694 y = i * 15 + 55;
695
696 gfx_display_text (16, y, stock_market[i].name);
697
698 gfx_display_text (180, y, unit_name[stock_market[i].units]);
699 sprintf (str, "%d.%d", stock_market[i].current_price / 10,
700 stock_market[i].current_price % 10);
701 gfx_display_text (256, y, str);
702
703 if (stock_market[i].current_quantity > 0)
704 sprintf (str, "%d%s", stock_market[i].current_quantity,
705 unit_name[stock_market[i].units]);
706 else
707 strcpy (str, "-");
708
709 gfx_display_text (338, y, str);
710
711 if (cmdr.current_cargo[i] > 0)
712 sprintf (str, "%d%s", cmdr.current_cargo[i],
713 unit_name[stock_market[i].units]);
714 else
715 strcpy (str, "-");
716
717 gfx_display_text (444, y, str);
718 }
719
720
721 void highlight_stock (int i)
722 {
723 int y;
724 char str[30];
725
726 if ((hilite_item != -1) && (hilite_item != i))
727 {
728 y = hilite_item * 15 + 55;
729 gfx_clear_area (2, y, 510, y + 15);
730 display_stock_price (hilite_item);
731 }
732
733 y = i * 15 + 55;
734
735 gfx_draw_rectangle (2, y, 510, y + 15, GFX_COL_DARK_RED);
736 display_stock_price (i);
737
738 hilite_item = i;
739
740 gfx_clear_text_area();
741 sprintf (str, "Cash: %d.%d", cmdr.credits / 10, cmdr.credits % 10);
742 gfx_display_text (16, 340, str);
743 }
744
745 void select_previous_stock (void)
746 {
747 if ((!docked) || (hilite_item == 0))
748 return;
749
750 highlight_stock (hilite_item - 1);
751 }
752
753 void select_next_stock (void)
754 {
755 if ((!docked) || (hilite_item == 16))
756 return;
757
758 highlight_stock (hilite_item + 1);
759 }
760
761
762 void buy_stock (void)
763 {
764 struct stock_item *item;
765 int cargo_held;
766
767 if (!docked)
768 return;
769
770 item = &stock_market[hilite_item];
771
772 do {
773 if ((item->current_quantity == 0) ||
774 (cmdr.credits < item->current_price))
775 return;
776
777 cargo_held = total_cargo();
778
779 if ((item->units == TONNES) &&
780 (cargo_held == cmdr.cargo_capacity))
781 return;
782
783 cmdr.current_cargo[hilite_item]++;
784 item->current_quantity--;
785 cmdr.credits -= item->current_price;
786
787 highlight_stock (hilite_item);
788 } while (kbd_ctrl_pressed);
789 }
790
791
792 void sell_stock (void)
793 {
794 struct stock_item *item;
795
796 do {
797 if ((!docked) || (cmdr.current_cargo[hilite_item] == 0))
798 return;
799
800 item = &stock_market[hilite_item];
801
802 cmdr.current_cargo[hilite_item]--;
803 item->current_quantity++;
804 cmdr.credits += item->current_price;
805
806 highlight_stock (hilite_item);
807 } while (kbd_ctrl_pressed);
808 }
809
810
811
812 void display_market_prices (void)
813 {
814 char str[100];
815 char planet_name[16];
816 int i;
817
818 current_screen = SCR_MARKET_PRICES;
819
820 gfx_clear_display();
821
822 name_planet (planet_name, docked_planet);
823 sprintf (str, "%s MARKET PRICES", planet_name);
824 gfx_display_centre_text (10, str, 140, GFX_COL_GOLD);
825
826 gfx_draw_line (0, 36, 511, 36);
827
828 gfx_display_colour_text (16, 40, "PRODUCT", GFX_COL_GREEN_1);
829 gfx_display_colour_text (166, 40, "UNIT", GFX_COL_GREEN_1);
830 gfx_display_colour_text (246, 40, "PRICE", GFX_COL_GREEN_1);
831 gfx_display_colour_text (314, 40, "FOR SALE", GFX_COL_GREEN_1);
832 gfx_display_colour_text (420, 40, "IN HOLD", GFX_COL_GREEN_1);
833
834 for (i = 0; i < 17; i++)
835 {
836 display_stock_price (i);
837 }
838
839 if (docked)
840 {
841 hilite_item = -1;
842 highlight_stock (0);
843 }
844 }
845
846
847 void display_inventory (void)
848 {
849 int i;
850 int y;
851 char str[80];
852
853 current_screen = SCR_INVENTORY;
854
855 gfx_clear_display();
856 gfx_display_centre_text (10, "INVENTORY", 140, GFX_COL_GOLD);
857 gfx_draw_line (0, 36, 511, 36);
858
859 sprintf (str, "%d.%d Light Years", cmdr.fuel / 10, cmdr.fuel % 10);
860 gfx_display_colour_text (16, 50, "Fuel:", GFX_COL_GREEN_1);
861 gfx_display_text (70, 50, str);
862
863 sprintf (str, "%d.%d Cr", cmdr.credits / 10, cmdr.credits % 10);
864 gfx_display_colour_text (16, 66, "Cash:", GFX_COL_GREEN_1);
865 gfx_display_text (70, 66, str);
866
867 y = 98;
868 for (i = 0; i < 17; i++)
869 {
870 if (cmdr.current_cargo[i] > 0)
871 {
872 gfx_display_text (16, y, stock_market[i].name);
873
874 sprintf (str, "%d%s", cmdr.current_cargo[i],
875 unit_name[stock_market[i].units]);
876
877 gfx_display_text (180, y, str);
878 y += 16;
879 }
880 }
881 }
882
883 /***********************************************************************************/
884
885 enum equip_types
886 {
887 EQ_FUEL, EQ_MISSILE, EQ_CARGO_BAY, EQ_ECM, EQ_FUEL_SCOOPS,
888 EQ_ESCAPE_POD, EQ_ENERGY_BOMB, EQ_ENERGY_UNIT, EQ_DOCK_COMP,
889 EQ_GAL_DRIVE, EQ_PULSE_LASER, EQ_FRONT_PULSE, EQ_REAR_PULSE,
890 EQ_LEFT_PULSE, EQ_RIGHT_PULSE, EQ_BEAM_LASER, EQ_FRONT_BEAM,
891 EQ_REAR_BEAM, EQ_LEFT_BEAM, EQ_RIGHT_BEAM, EQ_MINING_LASER,
892 EQ_FRONT_MINING, EQ_REAR_MINING, EQ_LEFT_MINING, EQ_RIGHT_MINING,
893 EQ_MILITARY_LASER, EQ_FRONT_MILITARY, EQ_REAR_MILITARY,
894 EQ_LEFT_MILITARY, EQ_RIGHT_MILITARY
895 };
896
897
898
899 #define NO_OF_EQUIP_ITEMS 34
900
901 struct equip_item
902 {
903 int canbuy;
904 int y;
905 int show;
906 int level;
907 int price;
908 char *name;
909 int type;
910 };
911
912 struct equip_item equip_stock[NO_OF_EQUIP_ITEMS] =
913 {
914 {0, 0, 1, 1, 2, " Fuel", EQ_FUEL},
915 {0, 0, 1, 1, 300, " Missile", EQ_MISSILE},
916 {0, 0, 1, 1, 4000, " Large Cargo Bay", EQ_CARGO_BAY},
917 {0, 0, 1, 2, 6000, " E.C.M. System", EQ_ECM},
918 {0, 0, 1, 5, 5250, " Fuel Scoops", EQ_FUEL_SCOOPS},
919 {0, 0, 1, 6, 10000, " Escape Pod", EQ_ESCAPE_POD},
920 {0, 0, 1, 7, 9000, " Energy Bomb", EQ_ENERGY_BOMB},
921 {0, 0, 1, 8, 15000, " Extra Energy Unit", EQ_ENERGY_UNIT},
922 {0, 0, 1, 9, 15000, " Docking Computers", EQ_DOCK_COMP},
923 {0, 0, 1,10, 50000, " Galactic Hyperdrive", EQ_GAL_DRIVE},
924 {0, 0, 0, 3, 4000, "+Pulse Laser", EQ_PULSE_LASER},
925 {0, 0, 1, 3, 0, "-Pulse Laser", EQ_PULSE_LASER},
926 {0, 0, 1, 3, 4000, ">Front", EQ_FRONT_PULSE},
927 {0, 0, 1, 3, 4000, ">Rear", EQ_REAR_PULSE},
928 {0, 0, 1, 3, 4000, ">Left", EQ_LEFT_PULSE},
929 {0, 0, 1, 3, 4000, ">Right", EQ_RIGHT_PULSE},
930 {0, 0, 1, 4, 10000, "+Beam Laser", EQ_BEAM_LASER},
931 {0, 0, 0, 4, 0, "-Beam Laser", EQ_BEAM_LASER},
932 {0, 0, 0, 4, 10000, ">Front", EQ_FRONT_BEAM},
933 {0, 0, 0, 4, 10000, ">Rear", EQ_REAR_BEAM},
934 {0, 0, 0, 4, 10000, ">Left", EQ_LEFT_BEAM},
935 {0, 0, 0, 4, 10000, ">Right", EQ_RIGHT_BEAM},
936 {0, 0, 1,10, 8000, "+Mining Laser", EQ_MINING_LASER},
937 {0, 0, 0,10, 0, "-Mining Laser", EQ_MINING_LASER},
938 {0, 0, 0,10, 8000, ">Front", EQ_FRONT_MINING},
939 {0, 0, 0,10, 8000, ">Rear", EQ_REAR_MINING},
940 {0, 0, 0,10, 8000, ">Left", EQ_LEFT_MINING},
941 {0, 0, 0,10, 8000, ">Right", EQ_RIGHT_MINING},
942 {0, 0, 1,10, 60000, "+Military Laser", EQ_MILITARY_LASER},
943 {0, 0, 0,10, 0, "-Military Laser", EQ_MILITARY_LASER},
944 {0, 0, 0,10, 60000, ">Front", EQ_FRONT_MILITARY},
945 {0, 0, 0,10, 60000, ">Rear", EQ_REAR_MILITARY},
946 {0, 0, 0,10, 60000, ">Left", EQ_LEFT_MILITARY},
947 {0, 0, 0,10, 60000, ">Right", EQ_RIGHT_MILITARY}
948 };
949
950
951 int equip_present (int type)
952 {
953 switch (type)
954 {
955 case EQ_FUEL:
956 return (cmdr.fuel >= 70);
957
958 case EQ_MISSILE:
959 return (cmdr.missiles >= 4);
960
961 case EQ_CARGO_BAY:
962 return (cmdr.cargo_capacity > 20);
963
964 case EQ_ECM:
965 return cmdr.ecm;
966
967 case EQ_FUEL_SCOOPS:
968 return cmdr.fuel_scoop;
969
970 case EQ_ESCAPE_POD:
971 return cmdr.escape_pod;
972
973 case EQ_ENERGY_BOMB:
974 return cmdr.energy_bomb;
975
976 case EQ_ENERGY_UNIT:
977 return cmdr.energy_unit;
978
979 case EQ_DOCK_COMP:
980 return cmdr.docking_computer;
981
982 case EQ_GAL_DRIVE:
983 return cmdr.galactic_hyperdrive;
984
985 case EQ_FRONT_PULSE:
986 return (cmdr.front_laser == PULSE_LASER);
987
988 case EQ_REAR_PULSE:
989 return (cmdr.rear_laser == PULSE_LASER);
990
991 case EQ_LEFT_PULSE:
992 return (cmdr.left_laser == PULSE_LASER);
993
994 case EQ_RIGHT_PULSE:
995 return (cmdr.right_laser == PULSE_LASER);
996
997 case EQ_FRONT_BEAM:
998 return (cmdr.front_laser == BEAM_LASER);
999
1000 case EQ_REAR_BEAM:
1001 return (cmdr.rear_laser == BEAM_LASER);
1002
1003 case EQ_LEFT_BEAM:
1004 return (cmdr.left_laser == BEAM_LASER);
1005
1006 case EQ_RIGHT_BEAM:
1007 return (cmdr.right_laser == BEAM_LASER);
1008
1009 case EQ_FRONT_MINING:
1010 return (cmdr.front_laser == MINING_LASER);
1011
1012 case EQ_REAR_MINING:
1013 return (cmdr.rear_laser == MINING_LASER);
1014
1015 case EQ_LEFT_MINING:
1016 return (cmdr.left_laser == MINING_LASER);
1017
1018 case EQ_RIGHT_MINING:
1019 return (cmdr.right_laser == MINING_LASER);
1020
1021 case EQ_FRONT_MILITARY:
1022 return (cmdr.front_laser == MILITARY_LASER);
1023
1024 case EQ_REAR_MILITARY:
1025 return (cmdr.rear_laser == MILITARY_LASER);
1026
1027 case EQ_LEFT_MILITARY:
1028 return (cmdr.left_laser == MILITARY_LASER);
1029
1030 case EQ_RIGHT_MILITARY:
1031 return (cmdr.right_laser == MILITARY_LASER);
1032 }
1033
1034 return 0;
1035 }
1036
1037
1038 void display_equip_price (int i)
1039 {
1040 int x, y;
1041 int col;
1042 char str[100];
1043
1044 y = equip_stock[i].y;
1045 if (y == 0)
1046 return;
1047
1048 col = equip_stock[i].canbuy ? GFX_COL_WHITE : GFX_COL_GREY_1;
1049
1050 x = *(equip_stock[i].name) == '>' ? 50 : 16;
1051
1052 gfx_display_colour_text (x, y, &equip_stock[i].name[1], col);
1053
1054 if (equip_stock[i].price != 0)
1055 {
1056 sprintf (str, "%d.%d", equip_stock[i].price / 10, equip_stock[i].price % 10);
1057 gfx_display_colour_text (338, y, str, col);
1058 }
1059 }
1060
1061
1062 void highlight_equip (int i)
1063 {
1064 int y;
1065 char str[30];
1066
1067 if ((hilite_item != -1) && (hilite_item != i))
1068 {
1069 y = equip_stock[hilite_item].y;
1070 gfx_clear_area (2, y+1, 510, y + 15);
1071 display_equip_price (hilite_item);
1072 }
1073
1074 y = equip_stock[i].y;
1075
1076 gfx_draw_rectangle (2, y+1, 510, y + 15, GFX_COL_DARK_RED);
1077 display_equip_price (i);
1078
1079 hilite_item = i;
1080
1081 gfx_clear_text_area();
1082 sprintf (str, "Cash: %d.%d", cmdr.credits / 10, cmdr.credits % 10);
1083 gfx_display_text (16, 340, str);
1084 }
1085
1086
1087 void select_next_equip (void)
1088 {
1089 int next;
1090 int i;
1091
1092 if (hilite_item == (NO_OF_EQUIP_ITEMS - 1))
1093 return;
1094
1095 next = hilite_item;
1096 for (i = hilite_item + 1; i < NO_OF_EQUIP_ITEMS; i++)
1097 {
1098 if (equip_stock[i].y != 0)
1099 {
1100 next = i;
1101 break;
1102 }
1103 }
1104
1105 if (next != hilite_item)
1106 highlight_equip (next);
1107 }
1108
1109 void select_previous_equip (void)
1110 {
1111 int i;
1112 int prev;
1113
1114 if (hilite_item == 0)
1115 return;
1116
1117 prev = hilite_item;
1118 for (i = hilite_item - 1; i >= 0; i--)
1119 {
1120 if (equip_stock[i].y != 0)
1121 {
1122 prev = i;
1123 break;
1124 }
1125 }
1126
1127 if (prev != hilite_item)
1128 highlight_equip (prev);
1129 }
1130
1131
1132 void list_equip_prices (void)
1133 {
1134 int i;
1135 int y;
1136 int tech_level;
1137
1138 gfx_clear_area (2, 55, 510, 380);
1139
1140 tech_level = current_planet_data.techlevel + 1;
1141
1142 equip_stock[0].price = (70 - cmdr.fuel) * 2;
1143
1144 y = 55;
1145 for (i = 0; i < NO_OF_EQUIP_ITEMS; i++)
1146 {
1147 equip_stock[i].canbuy = ((equip_present (equip_stock[i].type) == 0) &&
1148 (equip_stock[i].price <= cmdr.credits));
1149
1150 if (equip_stock[i].show && (tech_level >= equip_stock[i].level))
1151 {
1152 equip_stock[i].y = y;
1153 y += 15;
1154 }
1155 else
1156 equip_stock[i].y = 0;
1157
1158 display_equip_price (i);
1159 }
1160
1161 i = hilite_item;
1162 hilite_item = -1;
1163 highlight_equip (i);
1164 }
1165
1166
1167 void collapse_equip_list (void)
1168 {
1169 int i;
1170 int ch;
1171
1172 for (i = 0; i < NO_OF_EQUIP_ITEMS; i++)
1173 {
1174 ch = *(equip_stock[i].name);
1175 equip_stock[i].show = ((ch == ' ') || (ch == '+'));
1176 }
1177 }
1178
1179
1180 int laser_refund (int laser_type)
1181 {
1182 switch (laser_type)
1183 {
1184 case PULSE_LASER:
1185 return 4000;
1186
1187 case BEAM_LASER:
1188 return 10000;
1189
1190 case MILITARY_LASER:
1191 return 60000;
1192
1193 case MINING_LASER:
1194 return 8000;
1195 }
1196
1197 return 0;
1198 }
1199
1200
1201 void buy_equip (void)
1202 {
1203 int i;
1204
1205 if (equip_stock[hilite_item].name[0] == '+')
1206 {
1207 collapse_equip_list();
1208 equip_stock[hilite_item].show = 0;
1209 hilite_item++;
1210 for (i = 0; i < 5; i++)
1211 equip_stock[hilite_item + i].show = 1;
1212
1213 list_equip_prices();
1214 return;
1215 }
1216
1217 if (equip_stock[hilite_item].canbuy == 0)
1218 return;
1219
1220 switch (equip_stock[hilite_item].type)
1221 {
1222 case EQ_FUEL:
1223 cmdr.fuel = myship.max_fuel;
1224 update_console();
1225 break;
1226
1227 case EQ_MISSILE:
1228 cmdr.missiles++;
1229 update_console();
1230 break;
1231
1232 case EQ_CARGO_BAY:
1233 cmdr.cargo_capacity = 35;
1234 break;
1235
1236 case EQ_ECM:
1237 cmdr.ecm = 1;
1238 break;
1239
1240 case EQ_FUEL_SCOOPS:
1241 cmdr.fuel_scoop = 1;
1242 break;
1243
1244 case EQ_ESCAPE_POD:
1245 cmdr.escape_pod = 1;
1246 break;
1247
1248 case EQ_ENERGY_BOMB:
1249 cmdr.energy_bomb = 1;
1250 break;
1251
1252 case EQ_ENERGY_UNIT:
1253 cmdr.energy_unit = 1;
1254 break;
1255
1256 case EQ_DOCK_COMP:
1257 cmdr.docking_computer = 1;
1258 break;
1259
1260 case EQ_GAL_DRIVE:
1261 cmdr.galactic_hyperdrive = 1;
1262 break;
1263
1264 case EQ_FRONT_PULSE:
1265 cmdr.credits += laser_refund (cmdr.front_laser);
1266 cmdr.front_laser = PULSE_LASER;
1267 break;
1268
1269 case EQ_REAR_PULSE:
1270 cmdr.credits += laser_refund (cmdr.rear_laser);
1271 cmdr.rear_laser = PULSE_LASER;
1272 break;
1273
1274 case EQ_LEFT_PULSE:
1275 cmdr.credits += laser_refund (cmdr.left_laser);
1276 cmdr.left_laser = PULSE_LASER;
1277 break;
1278
1279 case EQ_RIGHT_PULSE:
1280 cmdr.credits += laser_refund (cmdr.right_laser);
1281 cmdr.right_laser = PULSE_LASER;
1282 break;
1283
1284 case EQ_FRONT_BEAM:
1285 cmdr.credits += laser_refund (cmdr.front_laser);
1286 cmdr.front_laser = BEAM_LASER;
1287 break;
1288
1289 case EQ_REAR_BEAM:
1290 cmdr.credits += laser_refund (cmdr.rear_laser);
1291 cmdr.rear_laser = BEAM_LASER;
1292 break;
1293
1294 case EQ_LEFT_BEAM:
1295 cmdr.credits += laser_refund (cmdr.left_laser);
1296 cmdr.left_laser = BEAM_LASER;
1297 break;
1298
1299 case EQ_RIGHT_BEAM:
1300 cmdr.credits += laser_refund (cmdr.right_laser);
1301 cmdr.right_laser = BEAM_LASER;
1302 break;
1303
1304 case EQ_FRONT_MINING:
1305 cmdr.credits += laser_refund (cmdr.front_laser);
1306 cmdr.front_laser = MINING_LASER;
1307 break;
1308
1309 case EQ_REAR_MINING:
1310 cmdr.credits += laser_refund (cmdr.rear_laser);
1311 cmdr.rear_laser = MINING_LASER;
1312 break;
1313
1314 case EQ_LEFT_MINING:
1315 cmdr.credits += laser_refund (cmdr.left_laser);
1316 cmdr.left_laser = MINING_LASER;
1317 break;
1318
1319 case EQ_RIGHT_MINING:
1320 cmdr.credits += laser_refund (cmdr.right_laser);
1321 cmdr.right_laser = MINING_LASER;
1322 break;
1323
1324 case EQ_FRONT_MILITARY:
1325 cmdr.credits += laser_refund (cmdr.front_laser);
1326 cmdr.front_laser = MILITARY_LASER;
1327 break;
1328
1329 case EQ_REAR_MILITARY:
1330 cmdr.credits += laser_refund (cmdr.rear_laser);
1331 cmdr.rear_laser = MILITARY_LASER;
1332 break;
1333
1334 case EQ_LEFT_MILITARY:
1335 cmdr.credits += laser_refund (cmdr.left_laser);
1336 cmdr.left_laser = MILITARY_LASER;
1337 break;
1338
1339 case EQ_RIGHT_MILITARY:
1340 cmdr.credits += laser_refund (cmdr.right_laser);
1341 cmdr.right_laser = MILITARY_LASER;
1342 break;
1343 }
1344
1345 cmdr.credits -= equip_stock[hilite_item].price;
1346 list_equip_prices();
1347 }
1348
1349
1350 void equip_ship (void)
1351 {
1352 current_screen = SCR_EQUIP_SHIP;
1353
1354 gfx_clear_display();
1355 gfx_display_centre_text (10, "EQUIP SHIP", 140, GFX_COL_GOLD);
1356 gfx_draw_line (0, 36, 511, 36);
1357
1358 collapse_equip_list();
1359
1360 hilite_item = 0;
1361
1362 list_equip_prices();
1363 }
Elite: The New Kind (by Christian Pinder; many local tweaks)