From 8898ad9b25fca6afe2374d293a981db02a83d7e9 Mon Sep 17 00:00:00 2001 From: "FWoltermann@gmail.com" Date: Thu, 31 May 2012 14:46:27 +0000 Subject: Committing the documentation to svn to have it accessible online --- Doc/doxygen/html/_mfd_8cpp_source.html | 1521 ++++++++++++++++++++++++++++++++ 1 file changed, 1521 insertions(+) create mode 100644 Doc/doxygen/html/_mfd_8cpp_source.html (limited to 'Doc/doxygen/html/_mfd_8cpp_source.html') diff --git a/Doc/doxygen/html/_mfd_8cpp_source.html b/Doc/doxygen/html/_mfd_8cpp_source.html new file mode 100644 index 0000000..004f260 --- /dev/null +++ b/Doc/doxygen/html/_mfd_8cpp_source.html @@ -0,0 +1,1521 @@ + + + + + +Starshatter_Open: D:/SRC/StarshatterSVN/Stars45/Mfd.cpp Source File + + + + + + + + + + + + + +
+
+ + + + + + +
+
Starshatter_Open +
+
Open source Starshatter engine
+
+
+ + + + + +
+
+ +
+
+
+ +
+ + + + +
+ +
+ +
+
+
Mfd.cpp
+
+
+Go to the documentation of this file.
1 /* Project Starshatter 5.0
+
2  Destroyer Studios LLC
+
3  Copyright (C) 1997-2007. All Rights Reserved.
+
4 
+
5  SUBSYSTEM: Stars.exe
+
6  FILE: MFD.cpp
+
7  AUTHOR: John DiCamillo
+
8 
+
9 
+
10  OVERVIEW
+
11  ========
+
12  Class for all Multi Function Displays
+
13 */
+
14 
+
15 #include "MemDebug.h"
+
16 #include "MFD.h"
+
17 #include "HUDView.h"
+
18 #include "Ship.h"
+
19 #include "NavSystem.h"
+
20 #include "Power.h"
+
21 #include "Shield.h"
+
22 #include "Sensor.h"
+
23 #include "Contact.h"
+
24 #include "ShipDesign.h"
+
25 #include "Shot.h"
+
26 #include "Weapon.h"
+
27 #include "WeaponGroup.h"
+
28 #include "Sim.h"
+
29 #include "StarSystem.h"
+
30 #include "Starshatter.h"
+
31 #include "Drive.h"
+
32 #include "QuantumDrive.h"
+
33 #include "Power.h"
+
34 #include "Instruction.h"
+
35 
+
36 #include "NetGame.h"
+
37 
+
38 #include "CameraView.h"
+
39 #include "Color.h"
+
40 #include "Font.h"
+
41 #include "FontMgr.h"
+
42 #include "Window.h"
+
43 #include "Video.h"
+
44 #include "Screen.h"
+
45 #include "DataLoader.h"
+
46 #include "Scene.h"
+
47 #include "Graphic.h"
+
48 #include "Sprite.h"
+
49 #include "Keyboard.h"
+
50 #include "Mouse.h"
+
51 #include "Game.h"
+
52 
+
53 static Bitmap sensor_fov;
+
54 static Bitmap sensor_fwd;
+
55 static Bitmap sensor_hsd;
+
56 static Bitmap sensor_3d;
+
57 
+
58 static BYTE* sensor_fov_shade;
+
59 static BYTE* sensor_fwd_shade;
+
60 static BYTE* sensor_hsd_shade;
+
61 static BYTE* sensor_3d_shade;
+
62 
+
63 static Color hud_color = Color::Black;
+
64 static Color txt_color = Color::Black;
+
65 
+
66 // +--------------------------------------------------------------------+
+
67 
+
68 MFD::MFD(Window* c, int n)
+
69 : window(c), rect(0,0,0,0), index(n), mode(MFD_MODE_OFF), sprite(0),
+
70 ship(0), hidden(true), camview(0), lines(0), mouse_latch(0), mouse_in(false),
+
71 cockpit_hud_texture(0)
+
72 {
+
73  sprite = new(__FILE__,__LINE__) Sprite(&sensor_fov);
+
74 
+
75  sprite->SetBlendMode(2);
+
76  sprite->SetFilter(0);
+
77  sprite->Hide();
+
78 
+
79  Font* font = FontMgr::Find("HUD");
+
80 
+
81  for (int i = 0; i < TXT_LAST; i++) {
+
82  mfd_text[i].font = font;
+
83  mfd_text[i].color = Color::White;
+
84  mfd_text[i].hidden = true;
+
85  }
+
86 }
+
87 
+
88 MFD::~MFD()
+
89 {
+
90  GRAPHIC_DESTROY(sprite);
+
91 }
+
92 
+
93 // +--------------------------------------------------------------------+
+
94 
+
95 void
+
96 MFD::Initialize()
+
97 {
+
98  static int initialized = 0;
+
99  if (initialized) return;
+
100 
+
101  HUDView::PrepareBitmap("sensor_fov.pcx", sensor_fov, sensor_fov_shade);
+
102  HUDView::PrepareBitmap("sensor_fwd.pcx", sensor_fwd, sensor_fwd_shade);
+
103  HUDView::PrepareBitmap("sensor_hsd.pcx", sensor_hsd, sensor_hsd_shade);
+
104  HUDView::PrepareBitmap("sensor_3d.pcx", sensor_3d, sensor_3d_shade);
+
105 
+
106  sensor_fov.SetType(Bitmap::BMP_TRANSLUCENT);
+
107  sensor_fwd.SetType(Bitmap::BMP_TRANSLUCENT);
+
108  sensor_hsd.SetType(Bitmap::BMP_TRANSLUCENT);
+
109  sensor_3d.SetType(Bitmap::BMP_TRANSLUCENT);
+
110 
+
111  initialized = 1;
+
112 }
+
113 
+
114 void
+
115 MFD::Close()
+
116 {
+
117  sensor_fov.ClearImage();
+
118  sensor_fwd.ClearImage();
+
119  sensor_hsd.ClearImage();
+
120  sensor_3d.ClearImage();
+
121 
+
122  delete [] sensor_fov_shade;
+
123  delete [] sensor_fwd_shade;
+
124  delete [] sensor_hsd_shade;
+
125  delete [] sensor_3d_shade;
+
126 }
+
127 
+
128 // +--------------------------------------------------------------------+
+
129 
+
130 void
+
131 MFD::UseCameraView(CameraView* v)
+
132 {
+
133  if (v && !camview) {
+
134  camview = v;
+
135  }
+
136 }
+
137 
+
138 void
+
139 MFD::SetColor(Color c)
+
140 {
+
141  HUDView* hud = HUDView::GetInstance();
+
142 
+
143  if (hud) {
+
144  hud_color = hud->GetHUDColor();
+
145  txt_color = hud->GetTextColor();
+
146  }
+
147  else {
+
148  hud_color = c;
+
149  txt_color = c;
+
150  }
+
151 
+
152  HUDView::ColorizeBitmap(sensor_fov, sensor_fov_shade, c);
+
153  HUDView::ColorizeBitmap(sensor_fwd, sensor_fwd_shade, c);
+
154  HUDView::ColorizeBitmap(sensor_hsd, sensor_hsd_shade, c);
+
155  HUDView::ColorizeBitmap(sensor_3d, sensor_3d_shade, c);
+
156 }
+
157 
+
158 void
+
159 MFD::SetText3DColor(Color c)
+
160 {
+
161  for (int i = 0; i < TXT_LAST; i++)
+
162  mfd_text[i].color = c;
+
163 }
+
164 
+
165 // +--------------------------------------------------------------------+
+
166 
+
167 void
+
168 MFD::Show()
+
169 {
+
170  switch (mode) {
+
171  case MFD_MODE_FOV:
+
172  case MFD_MODE_HSD:
+
173  case MFD_MODE_3D:
+
174  if (sprite)
+
175  sprite->Show();
+
176  break;
+
177  }
+
178 
+
179  hidden = false;
+
180 }
+
181 
+
182 void
+
183 MFD::Hide()
+
184 {
+
185  if (sprite)
+
186  sprite->Hide();
+
187 
+
188  for (int i = 0; i < TXT_LAST; i++)
+
189  HideMFDText(i);
+
190 
+
191  hidden = true;
+
192 }
+
193 
+
194 // +--------------------------------------------------------------------+
+
195 
+
196 void
+
197 MFD::SetRect(const Rect& r)
+
198 {
+
199  rect = r;
+
200 
+
201  if (sprite)
+
202  sprite->MoveTo(Point(rect.x + sprite->Width()/2,
+
203  rect.y + sprite->Height()/2,
+
204  1));
+
205 }
+
206 
+
207 // +--------------------------------------------------------------------+
+
208 
+
209 void
+
210 MFD::SetMode(int m)
+
211 {
+
212  if (m < MFD_MODE_OFF || m > MFD_MODE_3D)
+
213  mode = MFD_MODE_OFF;
+
214  else
+
215  mode = m;
+
216 
+
217  sprite->Hide();
+
218 
+
219  for (int i = 0; i < TXT_LAST; i++)
+
220  HideMFDText(i);
+
221 
+
222  switch (mode) {
+
223  case MFD_MODE_GAME:
+
224  case MFD_MODE_SHIP:
+
225  lines = 0;
+
226  break;
+
227 
+
228  case MFD_MODE_FOV:
+
229  sprite->SetAnimation(&sensor_fov);
+
230  sprite->Show();
+
231  sprite->Reshape(sensor_fov.Width()-8, 16);
+
232  break;
+
233  case MFD_MODE_HSD:
+
234  sprite->SetAnimation(&sensor_hsd);
+
235  sprite->Show();
+
236  sprite->Reshape(sensor_hsd.Width()-8, 16);
+
237  break;
+
238  case MFD_MODE_3D:
+
239  sprite->SetAnimation(&sensor_3d);
+
240  sprite->Show();
+
241  sprite->Reshape(sensor_3d.Width()-8, 16);
+
242  break;
+
243  }
+
244 }
+
245 
+
246 // +--------------------------------------------------------------------+
+
247 
+
248 void
+
249 MFD::Draw()
+
250 {
+
251  mouse_in = false;
+
252 
+
253  if (Mouse::LButton() == 0)
+
254  mouse_latch = 0;
+
255 
+
256  if (rect.Contains(Mouse::X(), Mouse::Y()))
+
257  mouse_in = true;
+
258 
+
259  // click to turn on MFD when off:
+
260  if (mode < MFD_MODE_FOV && Mouse::LButton() && !mouse_latch) {
+
261  mouse_latch = 1;
+
262  if (mouse_in) {
+
263  HUDView* hud = HUDView::GetInstance();
+
264  if (hud)
+
265  hud->CycleMFDMode(index);
+
266  }
+
267  }
+
268 
+
269  for (int i = 0; i < TXT_LAST; i++)
+
270  HideMFDText(i);
+
271 
+
272  if (hidden || mode < MFD_MODE_FOV) {
+
273  if (cockpit_hud_texture) {
+
274  int x1 = index*128;
+
275  int y1 = 256;
+
276  int x2 = x1 + 128;
+
277  int y2 = y1 + 128;
+
278 
+
279  cockpit_hud_texture->FillRect(x1, y1, x2, y2, Color::Black);
+
280  }
+
281 
+
282  if (hidden)
+
283  return;
+
284  }
+
285 
+
286  if (sprite && !sprite->Hidden()) {
+
287  if (cockpit_hud_texture) {
+
288  int x1 = index*128;
+
289  int y1 = 256;
+
290  int w = sprite->Width();
+
291  int h = sprite->Height();
+
292 
+
293  cockpit_hud_texture->BitBlt(x1, y1, *sprite->Frame(), 0,0,w,h);
+
294  }
+
295  else {
+
296  int cx = rect.x + rect.w/2;
+
297  int cy = rect.y + rect.h/2;
+
298  int w2 = sprite->Width()/2;
+
299  int h2 = sprite->Height()/2;
+
300 
+
301  window->DrawBitmap(cx-w2, cy-h2, cx+w2, cy+h2, sprite->Frame(), Video::BLEND_ALPHA);
+
302  }
+
303  }
+
304 
+
305  switch (mode) {
+
306  default:
+
307  case MFD_MODE_OFF: break;
+
308  case MFD_MODE_GAME: DrawGameMFD(); break;
+
309  case MFD_MODE_SHIP: DrawStatusMFD(); break;
+
310 
+
311  // sensor sub-modes:
+
312  case MFD_MODE_FOV: DrawSensorMFD(); break;
+
313  case MFD_MODE_HSD: DrawHSD(); break;
+
314  case MFD_MODE_3D: Draw3D(); break;
+
315  }
+
316 }
+
317 
+
318 // +--------------------------------------------------------------------+
+
319 
+
320 void
+
321 MFD::DrawSensorLabels(const char* mfd_mode)
+
322 {
+
323  Sensor* sensor = ship->GetSensor();
+
324  char mode_buf[8] = " ";
+
325  int scan_r = rect.w;
+
326  int scan_x = rect.x;
+
327  int scan_y = rect.y;
+
328 
+
329  switch (sensor->GetMode()) {
+
330  case Sensor::PAS: strcpy_s(mode_buf, Game::GetText("MFD.mode.passive").data()); break;
+
331  case Sensor::STD: strcpy_s(mode_buf, Game::GetText("MFD.mode.standard").data()); break;
+
332  case Sensor::ACM: strcpy_s(mode_buf, Game::GetText("MFD.mode.auto-combat").data()); break;
+
333  case Sensor::GM: strcpy_s(mode_buf, Game::GetText("MFD.mode.ground").data()); break;
+
334  case Sensor::PST: strcpy_s(mode_buf, Game::GetText("MFD.mode.passive").data()); break;
+
335  case Sensor::CST: strcpy_s(mode_buf, Game::GetText("MFD.mode.combined").data()); break;
+
336  default: break;
+
337  }
+
338 
+
339  Rect mode_rect(scan_x+2, scan_y+2, 40, 12);
+
340  DrawMFDText(0, mode_buf, mode_rect, DT_LEFT);
+
341 
+
342  char range_txt[12];
+
343  double beam_range = sensor->GetBeamRange() + 1;
+
344  if (beam_range >= 1e6)
+
345  sprintf_s(range_txt, "-%dM+", (int) (beam_range / 1e6));
+
346  else
+
347  sprintf_s(range_txt, "-%3d+", (int) (beam_range / 1e3));
+
348 
+
349  Rect range_rect(scan_x+2, scan_y+scan_r-12, 40, 12);
+
350  DrawMFDText(1, range_txt, range_rect, DT_LEFT);
+
351 
+
352  Rect disp_rect(scan_x+scan_r-41, scan_y+2, 40, 12);
+
353  DrawMFDText(2, mfd_mode, disp_rect, DT_RIGHT);
+
354 
+
355  Rect probe_rect(scan_x+scan_r-41, scan_y+scan_r-12, 40, 12);
+
356 
+
357  if (ship->GetProbeLauncher()) {
+
358  char probes[32];
+
359  sprintf_s(probes, "%s %02d", Game::GetText("MFD.probe").data(), ship->GetProbeLauncher()->Ammo());
+
360  DrawMFDText(3, probes, probe_rect, DT_RIGHT);
+
361  }
+
362  else {
+
363  HideMFDText(3);
+
364  }
+
365 
+
366  if (Mouse::LButton() && !mouse_latch) {
+
367  mouse_latch = 1;
+
368 
+
369  if (mode_rect.Contains(Mouse::X(), Mouse::Y())) {
+
370  if (sensor->GetMode() < Sensor::PST) {
+
371  int sensor_mode = sensor->GetMode() + 1;
+
372  if (sensor_mode > Sensor::GM)
+
373  sensor_mode = Sensor::PAS;
+
374 
+
375  sensor->SetMode((Sensor::Mode) sensor_mode);
+
376  }
+
377  }
+
378 
+
379  else if (range_rect.Contains(Mouse::X(), Mouse::Y())) {
+
380  if (Mouse::X() > range_rect.x+range_rect.w/2)
+
381  sensor->IncreaseRange();
+
382  else
+
383  sensor->DecreaseRange();
+
384  }
+
385 
+
386  else if (disp_rect.Contains(Mouse::X(), Mouse::Y())) {
+
387  HUDView* hud = HUDView::GetInstance();
+
388  if (hud)
+
389  hud->CycleMFDMode(index);
+
390  }
+
391 
+
392  else if (probe_rect.Contains(Mouse::X(), Mouse::Y())) {
+
393  ship->LaunchProbe();
+
394  }
+
395  }
+
396 }
+
397 
+
398 // +--------------------------------------------------------------------+
+
399 
+
400 // AZIMUTH-ELEVATION ANGULAR SCANNER
+
401 
+
402 void
+
403 MFD::DrawSensorMFD()
+
404 {
+
405  int scan_r = rect.w;
+
406  int scan_x = cockpit_hud_texture ? (index*128) : rect.x;
+
407  int scan_y = cockpit_hud_texture ? 256 : rect.y;
+
408  int r = scan_r / 2;
+
409 
+
410  double xctr = (scan_r / 2.0) - 0.5;
+
411  double yctr = (scan_r / 2.0) + 0.5;
+
412 
+
413  Sensor* sensor = ship->GetSensor();
+
414  if (!sensor) {
+
415  DrawMFDText(0, Game::GetText("MFD.inactive").data(), rect, DT_CENTER);
+
416  return;
+
417  }
+
418 
+
419  int w = sprite->Width();
+
420  int h = sprite->Height();
+
421 
+
422  if (w < sprite->Frame()->Width())
+
423  w += 2;
+
424 
+
425  if (h < sprite->Frame()->Height())
+
426  h += 16;
+
427 
+
428  sprite->Reshape(w, h);
+
429  sprite->Show();
+
430 
+
431  if (h < sprite->Frame()->Height())
+
432  return;
+
433 
+
434  double sweep_scale = r / (PI/2);
+
435 
+
436  if (sensor->GetBeamLimit() > 90*DEGREES)
+
437  sweep_scale = (double) r / (90*DEGREES);
+
438 
+
439  int az = (int) (sensor->GetBeamLimit() * sweep_scale);
+
440  int el = az;
+
441  int xc = (int) (scan_x + xctr);
+
442  int yc = (int) (scan_y + yctr);
+
443 
+
444  if (mode == MFD_MODE_FOV) {
+
445  if (sensor->GetMode() < Sensor::GM) {
+
446  if (cockpit_hud_texture)
+
447  cockpit_hud_texture->DrawEllipse(xc-az, yc-el, xc+az, yc+el, hud_color);
+
448  else
+
449  window->DrawEllipse(xc-az, yc-el, xc+az, yc+el, hud_color);
+
450  }
+
451  }
+
452  else {
+
453  char az_txt[8];
+
454  sprintf_s(az_txt, "%d", (int) (sensor->GetBeamLimit() / DEGREES));
+
455 
+
456  Rect az_rect(scan_x+2, scan_y+scan_r-12, 32, 12);
+
457  DrawMFDText(1, az_txt, az_rect, DT_LEFT);
+
458 
+
459  az_rect.x = scan_x + (scan_r/2) - (az_rect.w/2);
+
460  DrawMFDText(2, "0", az_rect, DT_CENTER);
+
461 
+
462  az_rect.x = scan_x + scan_r - az_rect.w - 2;
+
463  DrawMFDText(3, az_txt, az_rect, DT_RIGHT);
+
464  }
+
465 
+
466  // draw next nav point:
+
467  Instruction* navpt = ship->GetNextNavPoint();
+
468  if (navpt && navpt->Region() == ship->GetRegion()) {
+
469  const Camera* cam = &ship->Cam();
+
470 
+
471  // translate:
+
472  Point pt = navpt->Location().OtherHand() - ship->Location();
+
473 
+
474  // rotate:
+
475  double tx = pt * cam->vrt();
+
476  double ty = pt * cam->vup();
+
477  double tz = pt * cam->vpn();
+
478 
+
479  if (tz > 1.0) {
+
480  // convert to spherical coords:
+
481  double rng = pt.length();
+
482  double az = asin(fabs(tx) / rng);
+
483  double el = asin(fabs(ty) / rng);
+
484 
+
485  if (tx < 0) az = -az;
+
486  if (ty < 0) el = -el;
+
487 
+
488  if (fabs(az) < 90*DEGREES) {
+
489  az *= sweep_scale;
+
490  el *= sweep_scale;
+
491 
+
492  int x = (int) (r + az);
+
493  int y = (int) (r - el);
+
494 
+
495  // clip again:
+
496  if (x > 0 && x < scan_r &&
+
497  y > 0 && y < scan_r) {
+
498 
+
499  // draw:
+
500  int xc = scan_x + x;
+
501  int yc = scan_y + y;
+
502 
+
503  if (cockpit_hud_texture) {
+
504  cockpit_hud_texture->DrawLine(xc-2, yc-2, xc+2, yc+2, Color::White);
+
505  cockpit_hud_texture->DrawLine(xc-2, yc+2, xc+2, yc-2, Color::White);
+
506  }
+
507  else {
+
508  window->DrawLine(xc-2, yc-2, xc+2, yc+2, Color::White);
+
509  window->DrawLine(xc-2, yc+2, xc+2, yc-2, Color::White);
+
510  }
+
511  }
+
512  }
+
513  }
+
514  }
+
515 
+
516  int num_contacts = ship->NumContacts();
+
517  ListIter<Contact> iter = ship->ContactList();
+
518 
+
519  while (++iter) {
+
520  Contact* contact = iter.value();
+
521  Ship* c_ship = contact->GetShip();
+
522  double az, el, rng;
+
523  bool aft = false;
+
524 
+
525  if (c_ship == ship) continue;
+
526 
+
527  contact->GetBearing(ship, az, el, rng);
+
528 
+
529  // clip (is in-front):
+
530  if (fabs(az) < 90*DEGREES) {
+
531  az *= sweep_scale;
+
532  el *= sweep_scale;
+
533  }
+
534 
+
535  // rear anulus:
+
536  else {
+
537  double len = sqrt(az*az + el*el);
+
538 
+
539  if (len > 1e-6) {
+
540  az = r * az/len;
+
541  el = r * el/len;
+
542  }
+
543  else {
+
544  az = -r;
+
545  el = 0;
+
546  }
+
547 
+
548  aft = true;
+
549  }
+
550 
+
551  int x = (int) (r + az);
+
552  int y = (int) (r - el);
+
553 
+
554  // clip again:
+
555  if (x < 0 || x > scan_r) continue;
+
556  if (y < 0 || y > scan_r) continue;
+
557 
+
558  // draw:
+
559  Color mark = HUDView::MarkerColor(contact);
+
560 
+
561  if (aft)
+
562  mark = mark * 0.75;
+
563 
+
564  int xc = scan_x + x;
+
565  int yc = scan_y + y;
+
566  int size = 1;
+
567 
+
568  if (c_ship && c_ship == ship->GetTarget())
+
569  size = 2;
+
570 
+
571  if (cockpit_hud_texture)
+
572  cockpit_hud_texture->FillRect(xc-size, yc-size, xc+size, yc+size, mark);
+
573  else
+
574  window->FillRect(xc-size, yc-size, xc+size, yc+size, mark);
+
575 
+
576  if (contact->Threat(ship)) {
+
577  if (c_ship) {
+
578  if (cockpit_hud_texture)
+
579  cockpit_hud_texture->DrawEllipse(xc-4, yc-4, xc+3, yc+3, mark);
+
580  else
+
581  window->DrawEllipse(xc-4, yc-4, xc+3, yc+3, mark);
+
582  }
+
583  else {
+
584  if (cockpit_hud_texture) {
+
585  cockpit_hud_texture->DrawLine(xc, yc-5, xc+5, yc, mark);
+
586  cockpit_hud_texture->DrawLine(xc+5, yc, xc, yc+5, mark);
+
587  cockpit_hud_texture->DrawLine(xc, yc+5, xc-5, yc, mark);
+
588  cockpit_hud_texture->DrawLine(xc-5, yc, xc, yc-5, mark);
+
589  }
+
590  else {
+
591  window->DrawLine(xc, yc-5, xc+5, yc, mark);
+
592  window->DrawLine(xc+5, yc, xc, yc+5, mark);
+
593  window->DrawLine(xc, yc+5, xc-5, yc, mark);
+
594  window->DrawLine(xc-5, yc, xc, yc-5, mark);
+
595  }
+
596  }
+
597  }
+
598  }
+
599 
+
600  DrawSensorLabels(Game::GetText("MFD.mode.field-of-view").data());
+
601 }
+
602 
+
603 // +--------------------------------------------------------------------+
+
604 
+
605 // HORIZONTAL SITUATION DISPLAY
+
606 
+
607 void
+
608 MFD::DrawHSD()
+
609 {
+
610  int scan_r = rect.w;
+
611  int scan_x = cockpit_hud_texture ? (index*128) : rect.x;
+
612  int scan_y = cockpit_hud_texture ? 256 : rect.y;
+
613  int r = scan_r / 2 - 4;
+
614 
+
615  double xctr = (scan_r / 2.0) - 0.5;
+
616  double yctr = (scan_r / 2.0) + 0.5;
+
617 
+
618  int xc = (int) xctr + scan_x;
+
619  int yc = (int) yctr + scan_y;
+
620 
+
621  Sensor* sensor = ship->GetSensor();
+
622  if (!sensor) {
+
623  DrawMFDText(0, Game::GetText("MFD.inactive").data(), rect, DT_CENTER);
+
624  return;
+
625  }
+
626 
+
627  int w = sprite->Width();
+
628  int h = sprite->Height();
+
629 
+
630  if (w < sprite->Frame()->Width())
+
631  w += 2;
+
632 
+
633  if (h < sprite->Frame()->Height())
+
634  h += 16;
+
635 
+
636  sprite->Reshape(w, h);
+
637  sprite->Show();
+
638 
+
639  if (h < sprite->Frame()->Height())
+
640  return;
+
641 
+
642  if (sensor->GetMode() < Sensor::PST) {
+
643  double s = sin(sensor->GetBeamLimit());
+
644  double c = cos(sensor->GetBeamLimit());
+
645 
+
646  int x0 = (int) (0.1*r*s);
+
647  int y0 = (int) (0.1*r*c);
+
648  int x1 = (int) (1.0*r*s);
+
649  int y1 = (int) (1.0*r*c);
+
650 
+
651  if (cockpit_hud_texture) {
+
652  cockpit_hud_texture->DrawLine(xc-x0, yc-y0, xc-x1, yc-y1, hud_color);
+
653  cockpit_hud_texture->DrawLine(xc+x0, yc-y0, xc+x1, yc-y1, hud_color);
+
654  }
+
655  else {
+
656  window->DrawLine(xc-x0, yc-y0, xc-x1, yc-y1, hud_color);
+
657  window->DrawLine(xc+x0, yc-y0, xc+x1, yc-y1, hud_color);
+
658  }
+
659  }
+
660 
+
661  double rscale = (double) r/(sensor->GetBeamRange());
+
662 
+
663  Camera hsd_cam = ship->Cam();
+
664  Point look = ship->Location() + ship->Heading() * 1000;
+
665  look.y = ship->Location().y;
+
666 
+
667  hsd_cam.LookAt(look);
+
668 
+
669  // draw tick marks on range rings:
+
670  for (int dir = 0; dir < 4; dir++) {
+
671  Point tick;
+
672 
+
673  switch (dir) {
+
674  case 0: tick = Point( 0, 0, 1000); break;
+
675  case 1: tick = Point( 1000, 0, 0); break;
+
676  case 2: tick = Point( 0, 0, -1000); break;
+
677  case 3: tick = Point(-1000, 0, 0); break;
+
678  }
+
679 
+
680  double tx = tick * hsd_cam.vrt();
+
681  double tz = tick * hsd_cam.vpn();
+
682  double az = asin(fabs(tx) / 1000);
+
683 
+
684  if (tx < 0) az = -az;
+
685 
+
686  if (tz < 0)
+
687  if (az < 0) az = -PI - az;
+
688  else az = PI - az;
+
689 
+
690  for (double range = 0.3; range < 1; range += 0.3) {
+
691  int x0 = (int) (sin(az) * r * range);
+
692  int y0 = (int) (cos(az) * r * range);
+
693  int x1 = (int) (sin(az) * r * (range + 0.1));
+
694  int y1 = (int) (cos(az) * r * (range + 0.1));
+
695 
+
696  if (cockpit_hud_texture) {
+
697  cockpit_hud_texture->DrawLine(xc+x0, yc-y0, xc+x1, yc-y1, hud_color);
+
698  }
+
699  else {
+
700  window->DrawLine(xc+x0, yc-y0, xc+x1, yc-y1, hud_color);
+
701  }
+
702  }
+
703  }
+
704 
+
705  // draw next nav point:
+
706  Instruction* navpt = ship->GetNextNavPoint();
+
707  if (navpt && navpt->Region() == ship->GetRegion()) {
+
708  const Camera* cam = &hsd_cam;
+
709 
+
710  // translate:
+
711  Point pt = navpt->Location().OtherHand() - ship->Location();
+
712 
+
713  // rotate:
+
714  double tx = pt * cam->vrt();
+
715  double ty = pt * cam->vup();
+
716  double tz = pt * cam->vpn();
+
717 
+
718  // convert to spherical coords:
+
719  double rng = pt.length();
+
720  double az = asin(fabs(tx) / rng);
+
721 
+
722  if (rng > sensor->GetBeamRange())
+
723  rng = sensor->GetBeamRange();
+
724 
+
725  if (tx < 0)
+
726  az = -az;
+
727 
+
728  if (tz < 0)
+
729  if (az < 0)
+
730  az = -PI - az;
+
731  else
+
732  az = PI - az;
+
733 
+
734  // draw:
+
735  int x = (int) (xc + sin(az) * rng * rscale);
+
736  int y = (int) (yc - cos(az) * rng * rscale);
+
737 
+
738  if (cockpit_hud_texture) {
+
739  cockpit_hud_texture->DrawLine(x-2, y-2, x+2, y+2, Color::White);
+
740  cockpit_hud_texture->DrawLine(x-2, y+2, x+2, y-2, Color::White);
+
741  }
+
742  else {
+
743  window->DrawLine(x-2, y-2, x+2, y+2, Color::White);
+
744  window->DrawLine(x-2, y+2, x+2, y-2, Color::White);
+
745  }
+
746  }
+
747 
+
748  // draw contact markers:
+
749  double limit = sensor->GetBeamRange();
+
750  ListIter<Contact> contact = ship->ContactList();
+
751 
+
752  while (++contact) {
+
753  Ship* c_ship = contact->GetShip();
+
754  if (c_ship == ship) continue;
+
755 
+
756  // translate:
+
757  Point targ_pt = contact->Location() - hsd_cam.Pos();
+
758 
+
759  // rotate:
+
760  double tx = targ_pt * hsd_cam.vrt();
+
761  double rg = contact->Range(ship, limit);
+
762  double true_range = targ_pt.length();
+
763  double az = asin(fabs(tx) / true_range);
+
764 
+
765  // clip:
+
766  if (rg > limit || rg <= 0)
+
767  continue;
+
768 
+
769  if (tx < 0)
+
770  az = -az;
+
771 
+
772  if (!contact->InFront(ship))
+
773  if (az < 0)
+
774  az = -PI - az;
+
775  else
+
776  az = PI - az;
+
777 
+
778  // draw:
+
779  int x = (int) (xc + sin(az) * rg * rscale);
+
780  int y = (int) (yc - cos(az) * rg * rscale);
+
781  int size = 2;
+
782 
+
783  // clip again:
+
784  if (x < scan_x || y < scan_y)
+
785  continue;
+
786 
+
787  if (c_ship && c_ship == ship->GetTarget())
+
788  size = 3;
+
789 
+
790  Color mark = HUDView::MarkerColor(contact.value());
+
791  if (cockpit_hud_texture) {
+
792  cockpit_hud_texture->FillRect(x-size, y-size, x+size, y+size, mark);
+
793  }
+
794  else {
+
795  window->FillRect(x-size, y-size, x+size, y+size, mark);
+
796  }
+
797 
+
798  if (contact->Threat(ship)) {
+
799  if (c_ship) {
+
800  if (cockpit_hud_texture) {
+
801  cockpit_hud_texture->DrawEllipse(x-4, y-4, x+3, y+3, mark);
+
802  }
+
803  else {
+
804  window->DrawEllipse(x-4, y-4, x+3, y+3, mark);
+
805  }
+
806  }
+
807  else {
+
808  if (cockpit_hud_texture) {
+
809  cockpit_hud_texture->DrawLine(x, y-5, x+5, y, mark);
+
810  cockpit_hud_texture->DrawLine(x+5, y, x, y+5, mark);
+
811  cockpit_hud_texture->DrawLine(x, y+5, x-5, y, mark);
+
812  cockpit_hud_texture->DrawLine(x-5, y, x, y-5, mark);
+
813  }
+
814  else {
+
815  window->DrawLine(x, y-5, x+5, y, mark);
+
816  window->DrawLine(x+5, y, x, y+5, mark);
+
817  window->DrawLine(x, y+5, x-5, y, mark);
+
818  window->DrawLine(x-5, y, x, y-5, mark);
+
819  }
+
820  }
+
821  }
+
822  }
+
823 
+
824  DrawSensorLabels(Game::GetText("MFD.mode.horizontal").data());
+
825 }
+
826 
+
827 // +--------------------------------------------------------------------+
+
828 
+
829 // ELITE-STYLE 3D RADAR
+
830 
+
831 void
+
832 MFD::Draw3D()
+
833 {
+
834  int scan_r = rect.w;
+
835  int scan_x = cockpit_hud_texture ? (index*128) : rect.x;
+
836  int scan_y = cockpit_hud_texture ? 256 : rect.y;
+
837  int r = scan_r / 2 - 4;
+
838 
+
839  double xctr = (scan_r / 2.0) - 0.5;
+
840  double yctr = (scan_r / 2.0) + 0.5;
+
841 
+
842  int xc = (int) xctr + scan_x;
+
843  int yc = (int) yctr + scan_y;
+
844 
+
845  Sensor* sensor = ship->GetSensor();
+
846  if (!sensor) {
+
847  DrawMFDText(0, Game::GetText("MFD.inactive").data(), rect, DT_CENTER);
+
848  return;
+
849  }
+
850 
+
851  int w = sprite->Width();
+
852  int h = sprite->Height();
+
853 
+
854  if (w < sprite->Frame()->Width())
+
855  w += 2;
+
856 
+
857  if (h < sprite->Frame()->Height())
+
858  h += 16;
+
859 
+
860  sprite->Reshape(w, h);
+
861  sprite->Show();
+
862 
+
863  if (h < sprite->Frame()->Height())
+
864  return;
+
865 
+
866  double rscale = (double) r/(sensor->GetBeamRange());
+
867 
+
868  Camera hsd_cam = ship->Cam();
+
869 
+
870  if (ship->IsStarship()) {
+
871  Point look = ship->Location() + ship->Heading() * 1000;
+
872  look.y = ship->Location().y;
+
873 
+
874  hsd_cam.LookAt(look);
+
875  }
+
876 
+
877 
+
878  // draw next nav point:
+
879  Instruction* navpt = ship->GetNextNavPoint();
+
880  if (navpt && navpt->Region() == ship->GetRegion()) {
+
881  const Camera* cam = &hsd_cam;
+
882 
+
883  // translate:
+
884  Point pt = navpt->Location().OtherHand() - ship->Location();
+
885 
+
886  // rotate:
+
887  double tx = pt * cam->vrt();
+
888  double ty = pt * cam->vup();
+
889  double tz = pt * cam->vpn();
+
890 
+
891  // convert to cylindrical coords:
+
892  double rng = pt.length();
+
893  double az = asin(fabs(tx) / rng);
+
894 
+
895  if (rng > sensor->GetBeamRange())
+
896  rng = sensor->GetBeamRange();
+
897 
+
898  if (tx < 0)
+
899  az = -az;
+
900 
+
901  if (tz < 0) {
+
902  if (az < 0)
+
903  az = -PI - az;
+
904  else
+
905  az = PI - az;
+
906  }
+
907 
+
908  // accentuate vertical:
+
909  if (ty > 10)
+
910  ty = log10(ty-9) * r/8;
+
911 
+
912  else if (ty < -10)
+
913  ty = -log10(9-ty) * r/8;
+
914 
+
915  else
+
916  ty = 0;
+
917 
+
918  // draw:
+
919  int x = (int) (sin(az) * rng * rscale);
+
920  int y = (int) (cos(az) * rng * rscale/2);
+
921  int z = (int) (ty);
+
922 
+
923  int x0 = xc+x;
+
924  int y0 = yc-y-z;
+
925 
+
926  if (cockpit_hud_texture) {
+
927  cockpit_hud_texture->DrawLine(x0-2, y0-2, x0+2, y0+2, Color::White);
+
928  cockpit_hud_texture->DrawLine(x0-2, y0+2, x0+2, y0-2, Color::White);
+
929  }
+
930  else {
+
931  window->DrawLine(x0-2, y0-2, x0+2, y0+2, Color::White);
+
932  window->DrawLine(x0-2, y0+2, x0+2, y0-2, Color::White);
+
933  }
+
934 
+
935  if (cockpit_hud_texture) {
+
936  if (z > 0)
+
937  cockpit_hud_texture->DrawLine(x0, y0+1, x0, y0+z, Color::White);
+
938  else if (z < 0)
+
939  cockpit_hud_texture->DrawLine(x0, y0+z, x0, y0-1, Color::White);
+
940  }
+
941  else {
+
942  if (z > 0)
+
943  window->DrawLine(x0, y0+1, x0, y0+z, Color::White);
+
944  else if (z < 0)
+
945  window->DrawLine(x0, y0+z, x0, y0-1, Color::White);
+
946  }
+
947  }
+
948 
+
949 
+
950  // draw contact markers:
+
951  double limit = sensor->GetBeamRange();
+
952  ListIter<Contact> contact = ship->ContactList();
+
953 
+
954  while (++contact) {
+
955  Ship* c_ship = contact->GetShip();
+
956  if (c_ship == ship) continue;
+
957 
+
958  // translate:
+
959  Point targ_pt = contact->Location() - hsd_cam.Pos();
+
960 
+
961  // rotate:
+
962  double tx = targ_pt * hsd_cam.vrt();
+
963  double ty = targ_pt * hsd_cam.vup();
+
964  double rg = contact->Range(ship, limit);
+
965  double true_range = targ_pt.length();
+
966  double az = asin(fabs(tx) / true_range);
+
967 
+
968  // clip:
+
969  if (rg > limit || rg <= 0)
+
970  continue;
+
971 
+
972  if (tx < 0)
+
973  az = -az;
+
974 
+
975  if (!contact->InFront(ship))
+
976  if (az < 0)
+
977  az = -PI - az;
+
978  else
+
979  az = PI - az;
+
980 
+
981  // accentuate vertical:
+
982  ty *= 4;
+
983 
+
984  // draw:
+
985  int x = (int) (sin(az) * rg * rscale);
+
986  int y = (int) (cos(az) * rg * rscale/2);
+
987  int z = (int) (ty * rscale/2);
+
988  int size = 1;
+
989 
+
990  int x0 = xc+x;
+
991  int y0 = yc-y-z;
+
992 
+
993  if (c_ship && c_ship == ship->GetTarget())
+
994  size = 2;
+
995 
+
996  Color mark = HUDView::MarkerColor(contact.value());
+
997 
+
998  if (cockpit_hud_texture) {
+
999  cockpit_hud_texture->FillRect(x0-size, y0-size, x0+size, y0+size, mark);
+
1000 
+
1001  if (contact->Threat(ship)) {
+
1002  if (c_ship) {
+
1003  cockpit_hud_texture->DrawEllipse(x0-4, y0-4, x0+3, y0+3, mark);
+
1004  }
+
1005  else {
+
1006  cockpit_hud_texture->DrawLine(x0, y0-5, x0+5, y0, mark);
+
1007  cockpit_hud_texture->DrawLine(x0+5, y0, x0, y0+5, mark);
+
1008  cockpit_hud_texture->DrawLine(x0, y0+5, x0-5, y0, mark);
+
1009  cockpit_hud_texture->DrawLine(x0-5, y0, x0, y0-5, mark);
+
1010  }
+
1011  }
+
1012 
+
1013  if (z > 0)
+
1014  cockpit_hud_texture->FillRect(x0-1, y0+size, x0, y0+z, mark);
+
1015  else if (z < 0)
+
1016  cockpit_hud_texture->FillRect(x0-1, y0+z, x0, y0-size, mark);
+
1017  }
+
1018  else {
+
1019  window->FillRect(x0-size, y0-size, x0+size, y0+size, mark);
+
1020 
+
1021  if (contact->Threat(ship)) {
+
1022  if (c_ship) {
+
1023  window->DrawEllipse(x0-4, y0-4, x0+3, y0+3, mark);
+
1024  }
+
1025  else {
+
1026  window->DrawLine(x0, y0-5, x0+5, y0, mark);
+
1027  window->DrawLine(x0+5, y0, x0, y0+5, mark);
+
1028  window->DrawLine(x0, y0+5, x0-5, y0, mark);
+
1029  window->DrawLine(x0-5, y0, x0, y0-5, mark);
+
1030  }
+
1031  }
+
1032 
+
1033  if (z > 0)
+
1034  window->FillRect(x0-1, y0+size, x0, y0+z, mark);
+
1035  else if (z < 0)
+
1036  window->FillRect(x0-1, y0+z, x0, y0-size, mark);
+
1037  }
+
1038  }
+
1039 
+
1040  DrawSensorLabels(Game::GetText("MFD.mode.3D").data());
+
1041 }
+
1042 
+
1043 // +--------------------------------------------------------------------+
+
1044 
+
1045 // GROUND MAP
+
1046 
+
1047 void
+
1048 MFD::DrawMap()
+
1049 {
+
1050  DrawMFDText(0, Game::GetText("MFD.mode.ground").data(), Rect(rect.x, rect.y, rect.w, 12), DT_CENTER);
+
1051 }
+
1052 
+
1053 // +--------------------------------------------------------------------+
+
1054 
+
1055 void
+
1056 MFD::DrawGauge(int x, int y, int percent)
+
1057 {
+
1058  if (cockpit_hud_texture) {
+
1059  x += this->index * 128 - this->rect.x;
+
1060  y += 256 - this->rect.y;
+
1061  cockpit_hud_texture->DrawRect(x, y, x+53, y+8, Color::DarkGray);
+
1062  }
+
1063  else {
+
1064  window->DrawRect(x, y, x+53, y+8, Color::DarkGray);
+
1065  }
+
1066 
+
1067  if (percent < 3) return;
+
1068  if (percent > 100) percent = 100;
+
1069 
+
1070  percent /= 2;
+
1071 
+
1072  if (cockpit_hud_texture)
+
1073  cockpit_hud_texture->FillRect(x+2, y+2, x+2+percent, y+7, Color::Gray);
+
1074  else
+
1075  window->FillRect(x+2, y+2, x+2+percent, y+7, Color::Gray);
+
1076 }
+
1077 
+
1078 void
+
1079 MFD::DrawGameMFD()
+
1080 {
+
1081  if (lines < 10) lines++;
+
1082 
+
1083  char txt[64];
+
1084  Rect txt_rect(rect.x, rect.y, rect.w, 12);
+
1085 
+
1086  int t = 0;
+
1087 
+
1088  if (!HUDView::IsArcade() && HUDView::ShowFPS()) {
+
1089  sprintf_s(txt, "FPS: %6.2f", Game::FrameRate());
+
1090  DrawMFDText(t++, txt, txt_rect, DT_LEFT);
+
1091  txt_rect.y += 10;
+
1092 
+
1093  if (lines <= 1) return;
+
1094 
+
1095  Starshatter* game = Starshatter::GetInstance();
+
1096  sprintf_s(txt, "Polys: %d", game->GetPolyStats().npolys);
+
1097  DrawMFDText(t++, txt, txt_rect, DT_LEFT);
+
1098  txt_rect.y += 10;
+
1099  }
+
1100 
+
1101  if (ship) {
+
1102  DrawMFDText(t++, ship->Name(), txt_rect, DT_LEFT);
+
1103  txt_rect.y += 10;
+
1104  }
+
1105 
+
1106  if (lines <= 2) return;
+
1107 
+
1108  int hours = (Game::GameTime() / 3600000) ;
+
1109  int minutes = (Game::GameTime() / 60000) % 60;
+
1110  int seconds = (Game::GameTime() / 1000) % 60;
+
1111 
+
1112  if (ship) {
+
1113  DWORD clock = ship->MissionClock();
+
1114 
+
1115  hours = (clock / 3600000) ;
+
1116  minutes = (clock / 60000) % 60;
+
1117  seconds = (clock / 1000) % 60;
+
1118  }
+
1119 
+
1120  if (Game::TimeCompression() > 1)
+
1121  sprintf_s(txt, "%02d:%02d:%02d x%d", hours, minutes, seconds, Game::TimeCompression());
+
1122  else
+
1123  sprintf_s(txt, "%02d:%02d:%02d", hours, minutes, seconds);
+
1124 
+
1125  DrawMFDText(t++, txt, txt_rect, DT_LEFT);
+
1126  txt_rect.y += 10;
+
1127 
+
1128  if (HUDView::IsArcade() || lines <= 3) return;
+
1129 
+
1130  DrawMFDText(t++, ship->GetRegion()->Name(), txt_rect, DT_LEFT);
+
1131  txt_rect.y += 10;
+
1132 
+
1133  if (lines <= 4) return;
+
1134 
+
1135  if (ship) {
+
1136  switch (ship->GetFlightPhase()) {
+
1137  case Ship::DOCKED: DrawMFDText(t++, Game::GetText("MFD.phase.DOCKED").data(), txt_rect, DT_LEFT); break;
+
1138  case Ship::ALERT: DrawMFDText(t++, Game::GetText("MFD.phase.ALERT").data(), txt_rect, DT_LEFT); break;
+
1139  case Ship::LOCKED: DrawMFDText(t++, Game::GetText("MFD.phase.LOCKED").data(), txt_rect, DT_LEFT); break;
+
1140  case Ship::LAUNCH: DrawMFDText(t++, Game::GetText("MFD.phase.LAUNCH").data(), txt_rect, DT_LEFT); break;
+
1141  case Ship::TAKEOFF: DrawMFDText(t++, Game::GetText("MFD.phase.TAKEOFF").data(), txt_rect, DT_LEFT); break;
+
1142  case Ship::ACTIVE: DrawMFDText(t++, Game::GetText("MFD.phase.ACTIVE").data(), txt_rect, DT_LEFT); break;
+
1143  case Ship::APPROACH: DrawMFDText(t++, Game::GetText("MFD.phase.APPROACH").data(), txt_rect, DT_LEFT); break;
+
1144  case Ship::RECOVERY: DrawMFDText(t++, Game::GetText("MFD.phase.RECOVERY").data(), txt_rect, DT_LEFT); break;
+
1145  case Ship::DOCKING: DrawMFDText(t++, Game::GetText("MFD.phase.DOCKING").data(), txt_rect, DT_LEFT); break;
+
1146  }
+
1147  }
+
1148 }
+
1149 
+
1150 void
+
1151 MFD::DrawStatusMFD()
+
1152 {
+
1153  if (lines < 10) lines++;
+
1154 
+
1155  Rect status_rect(rect.x, rect.y, rect.w, 12);
+
1156  int row = 0;
+
1157  char txt[32];
+
1158 
+
1159  if (ship) {
+
1160  if (status_rect.y > 320 && !ship->IsStarship())
+
1161  status_rect.y += 32;
+
1162 
+
1163  Drive* drive = ship->GetDrive();
+
1164  if (drive) {
+
1165  DrawMFDText(row++, Game::GetText("MFD.status.THRUST").data(), status_rect, DT_LEFT);
+
1166  DrawGauge(status_rect.x+70, status_rect.y, (int) ship->Throttle());
+
1167  status_rect.y += 10;
+
1168  }
+
1169 
+
1170  if (lines <= 1) return;
+
1171 
+
1172  if (ship->Reactors().size() > 0) {
+
1173  PowerSource* reactor = ship->Reactors()[0];
+
1174  if (reactor) {
+
1175  DrawMFDText(row++, Game::GetText("MFD.status.FUEL").data(), status_rect, DT_LEFT);
+
1176  DrawGauge(status_rect.x+70, status_rect.y, reactor->Charge());
+
1177  status_rect.y += 10;
+
1178  }
+
1179  }
+
1180 
+
1181  if (lines <= 2) return;
+
1182 
+
1183  QuantumDrive* quantum_drive = ship->GetQuantumDrive();
+
1184  if (quantum_drive) {
+
1185  DrawMFDText(row++, Game::GetText("MFD.status.QUANTUM").data(), status_rect, DT_LEFT);
+
1186  DrawGauge(status_rect.x+70, status_rect.y, (int) quantum_drive->Charge());
+
1187  status_rect.y += 10;
+
1188  }
+
1189 
+
1190  if (lines <= 3) return;
+
1191 
+
1192  double hull = ship->Integrity() / ship->Design()->integrity * 100;
+
1193  int hull_status = System::CRITICAL;
+
1194 
+
1195  if (hull > 66)
+
1196  hull_status = System::NOMINAL;
+
1197  else if (hull > 33)
+
1198  hull_status = System::DEGRADED;
+
1199 
+
1200  DrawMFDText(row++, Game::GetText("MFD.status.HULL").data(), status_rect, DT_LEFT);
+
1201  DrawGauge(status_rect.x+70, status_rect.y, (int) hull);
+
1202  status_rect.y += 10;
+
1203 
+
1204  if (lines <= 4) return;
+
1205 
+
1206  Shield* shield = ship->GetShield();
+
1207  if (shield) {
+
1208  DrawMFDText(row++, Game::GetText("MFD.status.SHIELD").data(), status_rect, DT_LEFT);
+
1209  DrawGauge(status_rect.x+70, status_rect.y, ship->ShieldStrength());
+
1210  status_rect.y += 10;
+
1211  }
+
1212 
+
1213  if (lines <= 5) return;
+
1214 
+
1215  Weapon* primary = ship->GetPrimary();
+
1216  if (primary) {
+
1217  DrawMFDText(row++, Game::GetText("MFD.status.GUNS").data(), status_rect, DT_LEFT);
+
1218  DrawGauge(status_rect.x+70, status_rect.y, primary->Charge());
+
1219  status_rect.y += 10;
+
1220  }
+
1221 
+
1222  if (lines <= 6) return;
+
1223 
+
1224  if (HUDView::IsArcade()) {
+
1225  for (int i = 0; i < ship->Weapons().size() && i < 4; i++) {
+
1226  WeaponGroup* w = ship->Weapons().at(i);
+
1227 
+
1228  if (w->IsMissile()) {
+
1229  char ammo[8];
+
1230 
+
1231  if (ship->GetSecondaryGroup() == w)
+
1232  sprintf_s(ammo, "%d *", w->Ammo());
+
1233  else
+
1234  sprintf_s(ammo, "%d", w->Ammo());
+
1235 
+
1236  DrawMFDText(row++, (const char*) w->GetDesign()->name, status_rect, DT_LEFT);
+
1237  status_rect.x += 70;
+
1238  DrawMFDText(row++, ammo, status_rect, DT_LEFT);
+
1239  status_rect.x -= 70;
+
1240  status_rect.y += 10;
+
1241  }
+
1242  }
+
1243 
+
1244  if (ship->GetDecoy()) {
+
1245  char ammo[8];
+
1246  sprintf_s(ammo, "%d", ship->GetDecoy()->Ammo());
+
1247  DrawMFDText(row++, Game::GetText("MFD.status.DECOY").data(), status_rect, DT_LEFT);
+
1248  status_rect.x += 70;
+
1249  DrawMFDText(row++, ammo, status_rect, DT_LEFT);
+
1250  status_rect.x -= 70;
+
1251  status_rect.y += 10;
+
1252  }
+
1253 
+
1254  if (NetGame::GetInstance()) {
+
1255  char lives[8];
+
1256  sprintf_s(lives, "%d", ship->RespawnCount() + 1);
+
1257  DrawMFDText(row++, Game::GetText("MFD.status.LIVES").data(), status_rect, DT_LEFT);
+
1258  status_rect.x += 70;
+
1259  DrawMFDText(row++, lives, status_rect, DT_LEFT);
+
1260  status_rect.x -= 70;
+
1261  status_rect.y += 10;
+
1262  }
+
1263 
+
1264  return;
+
1265  }
+
1266 
+
1267  Sensor* sensor = ship->GetSensor();
+
1268  if (sensor) {
+
1269  if (ship->GetFlightPhase() != Ship::ACTIVE) {
+
1270  DrawMFDText(row++, Game::GetText("MFD.status.SENSOR").data(), status_rect, DT_LEFT);
+
1271  status_rect.x += 70;
+
1272  DrawMFDText(row++, Game::GetText("MFD.status.OFFLINE").data(), status_rect, DT_LEFT);
+
1273  status_rect.x -= 70;
+
1274  status_rect.y += 10;
+
1275  }
+
1276 
+
1277  else {
+
1278  DrawMFDText(row++, Game::GetText("MFD.status.EMCON").data(), status_rect, DT_LEFT);
+
1279  status_rect.x += 70;
+
1280 
+
1281  sprintf_s(txt, "%s %d", Game::GetText("MFD.status.MODE").data(), ship->GetEMCON());
+
1282 
+
1283  if (!sensor->IsPowerOn() || sensor->GetEnergy() == 0) {
+
1284  if (!Game::Paused() && (Game::RealTime()/1000) & 2)
+
1285  strcpy_s(txt, Game::GetText("MFD.status.SENSOR-OFF").data());
+
1286  }
+
1287 
+
1288  DrawMFDText(row++, txt, status_rect, DT_LEFT);
+
1289  status_rect.x -= 70;
+
1290  status_rect.y += 10;
+
1291  }
+
1292  }
+
1293 
+
1294  if (lines <= 7) return;
+
1295 
+
1296  DrawMFDText(row++, Game::GetText("MFD.status.SYSTEMS").data(), status_rect, DT_LEFT);
+
1297  status_rect.x += 70;
+
1298  DrawMFDText(row++, ship->GetDirectorInfo(), status_rect, DT_LEFT);
+
1299 
+
1300  if (NetGame::GetInstance()) {
+
1301  char lives[8];
+
1302  sprintf_s(lives, "%d", ship->RespawnCount() + 1);
+
1303  status_rect.x -= 70;
+
1304  status_rect.y += 10;
+
1305  DrawMFDText(row++, Game::GetText("MFD.status.LIVES").data(), status_rect, DT_LEFT);
+
1306  status_rect.x += 70;
+
1307  DrawMFDText(row++, lives, status_rect, DT_LEFT);
+
1308  }
+
1309  }
+
1310 }
+
1311 
+
1312 // +--------------------------------------------------------------------+
+
1313 
+
1314 void
+
1315 MFD::SetStatusColor(int status)
+
1316 {
+
1317  Color status_color;
+
1318 
+
1319  switch (status) {
+
1320  default:
+
1321  case System::NOMINAL: status_color = txt_color; break;
+
1322  case System::DEGRADED: status_color = Color(255,255, 0); break;
+
1323  case System::CRITICAL: status_color = Color(255, 0, 0); break;
+
1324  case System::DESTROYED: status_color = Color( 0, 0, 0); break;
+
1325  }
+
1326 }
+
1327 
+
1328 // +--------------------------------------------------------------------+
+
1329 
+
1330 bool MFD::IsMouseLatched() const
+
1331 {
+
1332  return mouse_in;
+
1333 }
+
1334 
+
1335 // +--------------------------------------------------------------------+
+
1336 
+
1337 void MFD::DrawMFDText(int index, const char* txt, Rect& txt_rect, int align, int status)
+
1338 {
+
1339  if (index >= MFD::TXT_LAST) {
+
1340  Print("MFD DrawMFDText() invalid mfd_text index %d '%s'\n", index, txt);
+
1341  }
+
1342  else {
+
1343  HUDText& mt = mfd_text[index];
+
1344  Color mc = mt.color;
+
1345 
+
1346  switch (status) {
+
1347  default:
+
1348  case System::NOMINAL: mc = txt_color; break;
+
1349  case System::DEGRADED: mc = Color(255,255, 0); break;
+
1350  case System::CRITICAL: mc = Color(255, 0, 0); break;
+
1351  case System::DESTROYED: mc = Color( 0, 0, 0); break;
+
1352  }
+
1353 
+
1354  char txt_buf[256];
+
1355  int n = strlen(txt);
+
1356 
+
1357  if (n > 250) n = 250;
+
1358  int i;
+
1359 
+
1360  for (i = 0; i < n; i++) {
+
1361  if (islower(txt[i]))
+
1362  txt_buf[i] = toupper(txt[i]);
+
1363  else
+
1364  txt_buf[i] = txt[i];
+
1365  }
+
1366 
+
1367  txt_buf[i] = 0;
+
1368 
+
1369 
+
1370  if (cockpit_hud_texture) {
+
1371  Rect hud_rect(txt_rect);
+
1372 
+
1373  hud_rect.x = txt_rect.x + this->index * 128 - this->rect.x;
+
1374  hud_rect.y = txt_rect.y + 256 - this->rect.y;
+
1375 
+
1376  mt.font->SetColor(mc);
+
1377  mt.font->DrawText(txt_buf, 0, hud_rect, align | DT_SINGLELINE, cockpit_hud_texture);
+
1378  mt.rect = rect;
+
1379  mt.hidden = false;
+
1380  }
+
1381  else {
+
1382  if (txt_rect.Contains(Mouse::X(), Mouse::Y()))
+
1383  mc = Color::White;
+
1384 
+
1385  mt.font->SetColor(mc);
+
1386  mt.font->DrawText(txt_buf, 0, txt_rect, align | DT_SINGLELINE);
+
1387  mt.rect = rect;
+
1388  mt.hidden = false;
+
1389  }
+
1390 
+
1391  }
+
1392 }
+
1393 
+
1394 void MFD::HideMFDText(int index)
+
1395 {
+
1396  if (index >= MFD::TXT_LAST)
+
1397  Print("MFD HideMFDText() invalid mfd_text index %d\n", index);
+
1398  else
+
1399  mfd_text[index].hidden = true;
+
1400 }
+
1401 
+
1402 
+
1403 
+
1404 
+
+
+ + + + -- cgit v1.1