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/_sensor_8cpp_source.html | 967 ++++++++++++++++++++++++++++++ 1 file changed, 967 insertions(+) create mode 100644 Doc/doxygen/html/_sensor_8cpp_source.html (limited to 'Doc/doxygen/html/_sensor_8cpp_source.html') diff --git a/Doc/doxygen/html/_sensor_8cpp_source.html b/Doc/doxygen/html/_sensor_8cpp_source.html new file mode 100644 index 0000000..52eb84f --- /dev/null +++ b/Doc/doxygen/html/_sensor_8cpp_source.html @@ -0,0 +1,967 @@ + + + + + +Starshatter_Open: D:/SRC/StarshatterSVN/Stars45/Sensor.cpp Source File + + + + + + + + + + + + + +
+
+ + + + + + +
+
Starshatter_Open +
+
Open source Starshatter engine
+
+
+ + + + + +
+
+ +
+
+
+ +
+ + + + +
+ +
+ +
+
+
Sensor.cpp
+
+
+Go to the documentation of this file.
1 /* Project Starshatter 5.0
+
2  Destroyer Studios LLC
+
3  Copyright © 1997-2007. All Rights Reserved.
+
4 
+
5  SUBSYSTEM: Stars.exe
+
6  FILE: Sensor.cpp
+
7  AUTHOR: John DiCamillo
+
8 
+
9 
+
10  OVERVIEW
+
11  ========
+
12  Integrated (Passive and Active) Sensor Package class implementation
+
13 */
+
14 
+
15 #include "MemDebug.h"
+
16 #include "Sensor.h"
+
17 #include "Contact.h"
+
18 #include "Element.h"
+
19 #include "Ship.h"
+
20 #include "ShipDesign.h"
+
21 #include "Shot.h"
+
22 #include "Drone.h"
+
23 #include "WeaponDesign.h"
+
24 #include "Sim.h"
+
25 #include "CombatGroup.h"
+
26 #include "CombatUnit.h"
+
27 
+
28 #include "Game.h"
+
29 
+
30 // +----------------------------------------------------------------------+
+
31 
+
32 const double SENSOR_THRESHOLD = 0.25;
+
33 
+
34 // +----------------------------------------------------------------------+
+
35 
+
36 Sensor::Sensor()
+
37 : System(SENSOR, 1, "Dual Sensor Pkg", 1, 10, 10, 10),
+
38 mode(STD), target(0),
+
39 nsettings(0), range_index(0)
+
40 {
+
41  name = Game::GetText("sys.sensor");
+
42  abrv = Game::GetText("sys.sensor.abrv");
+
43 
+
44  SetMode(mode);
+
45  power_flags = POWER_WATTS;
+
46 
+
47  ZeroMemory(range_settings, sizeof(range_settings));
+
48 }
+
49 
+
50 // +----------------------------------------------------------------------+
+
51 
+
52 Sensor::Sensor(const Sensor& s)
+
53 : System(s), mode(STD), target(0),
+
54 nsettings(s.nsettings), range_index(0)
+
55 {
+
56  Mount(s);
+
57 
+
58  SetMode(mode);
+
59  power_flags = POWER_WATTS;
+
60 
+
61  CopyMemory(range_settings, s.range_settings, sizeof(range_settings));
+
62 
+
63  if (nsettings)
+
64  range_index = nsettings-1;
+
65 }
+
66 
+
67 // +--------------------------------------------------------------------+
+
68 
+
69 Sensor::~Sensor()
+
70 {
+
71  ClearAllContacts();
+
72 }
+
73 
+
74 // +--------------------------------------------------------------------+
+
75 
+
76 void
+
77 Sensor::ClearAllContacts()
+
78 {
+
79  contacts.destroy();
+
80 }
+
81 
+
82 // +--------------------------------------------------------------------+
+
83 
+
84 double
+
85 Sensor::GetBeamLimit() const
+
86 {
+
87  if (mode == ACM)
+
88  return 15*DEGREES;
+
89 
+
90  if (mode <= GM)
+
91  return 45*DEGREES;
+
92 
+
93  return 175*DEGREES;
+
94 }
+
95 
+
96 double
+
97 Sensor::GetBeamRange() const
+
98 {
+
99  return (double) range_settings[range_index];
+
100 }
+
101 
+
102 void
+
103 Sensor::IncreaseRange()
+
104 {
+
105  if (range_index < nsettings-1)
+
106  range_index++;
+
107  else
+
108  range_index = nsettings-1;
+
109 }
+
110 
+
111 void
+
112 Sensor::DecreaseRange()
+
113 {
+
114  if (range_index > 0)
+
115  range_index--;
+
116  else
+
117  range_index = 0;
+
118 }
+
119 
+
120 void
+
121 Sensor::AddRange(double r)
+
122 {
+
123  if (nsettings < 8)
+
124  range_settings[nsettings++] = (float) r;
+
125 
+
126  range_index = nsettings-1;
+
127 }
+
128 
+
129 void
+
130 Sensor::SetMode(Mode m)
+
131 {
+
132  if (mode != m) {
+
133  // dump the contact list when changing in/out of GM:
+
134  if (mode == GM || m == GM)
+
135  ClearAllContacts();
+
136 
+
137  // dump the current target on mode changes:
+
138  if (m <= GM) {
+
139  if (ship)
+
140  ship->DropTarget();
+
141 
+
142  Ignore(target);
+
143  target = 0;
+
144  }
+
145  }
+
146 
+
147  mode = m;
+
148 }
+
149 
+
150 // +----------------------------------------------------------------------+
+
151 
+
152 bool
+
153 Sensor::Update(SimObject* obj)
+
154 {
+
155  if (obj == target) {
+
156  target = 0;
+
157  }
+
158 
+
159  return SimObserver::Update(obj);
+
160 }
+
161 
+
162 const char*
+
163 Sensor::GetObserverName() const
+
164 {
+
165  return "Sensor";
+
166 }
+
167 
+
168 // +--------------------------------------------------------------------+
+
169 
+
170 void
+
171 Sensor::ExecFrame(double seconds)
+
172 {
+
173  if (Game::Paused())
+
174  return;
+
175 
+
176  System::ExecFrame(seconds);
+
177 
+
178  if (!IsPowerOn() || energy <= 0) {
+
179  ClearAllContacts();
+
180  return;
+
181  }
+
182 
+
183  if (ship && ship->GetAIMode() < 2) {
+
184  // just pretend to work this frame:
+
185  energy = 0.0f;
+
186  return;
+
187  }
+
188 
+
189  if (ship && ship->GetRegion()) {
+
190  const Camera* cam = &ship->Cam();
+
191  double az1 = -45*DEGREES;
+
192  double az2 = 45*DEGREES;
+
193 
+
194  if (mode > GM) {
+
195  az1 = -175*DEGREES;
+
196  az2 = 175*DEGREES;
+
197  }
+
198 
+
199  ListIter<Ship> ship_iter(ship->GetRegion()->Ships());
+
200  while (++ship_iter) {
+
201  Ship* c_ship = ship_iter.value();
+
202 
+
203  if (c_ship != ship) {
+
204  ProcessContact(c_ship, az1, az2);
+
205  }
+
206  else {
+
207  Contact* c = FindContact(c_ship);
+
208 
+
209  if (!c) {
+
210  c = new(__FILE__,__LINE__) Contact(c_ship, 0.0f, 0.0f);
+
211  contacts.append(c);
+
212  }
+
213 
+
214  // update track:
+
215  if (c) {
+
216  c->loc = c_ship->Location();
+
217  c->d_pas = 2.0f;
+
218  c->d_act = 2.0f;
+
219 
+
220  c->UpdateTrack();
+
221  }
+
222  }
+
223  }
+
224 
+
225  ListIter<Shot> threat_iter(ship->GetThreatList());
+
226  while (++threat_iter) {
+
227  ProcessContact(threat_iter.value(), az1, az2);
+
228  }
+
229 
+
230  ListIter<Drone> drone_iter(ship->GetRegion()->Drones());
+
231  while (++drone_iter) {
+
232  ProcessContact(drone_iter.value(), az1, az2);
+
233  }
+
234 
+
235  List<Contact>& track_list = ship->GetRegion()->TrackList(ship->GetIFF());
+
236  ListIter<Contact> c_iter(contacts);
+
237 
+
238  while (++c_iter) {
+
239  Contact* contact = c_iter.value();
+
240  Ship* c_ship = contact->GetShip();
+
241  Shot* c_shot = contact->GetShot();
+
242  double c_life = -1;
+
243 
+
244  if (c_ship) {
+
245  c_life = c_ship->Life();
+
246 
+
247  // look for quantum jumps and orbit transitions:
+
248  if (c_ship->GetRegion() != ship->GetRegion())
+
249  c_life = 0;
+
250  }
+
251 
+
252  else if (c_shot) {
+
253  c_life = c_shot->Life();
+
254  }
+
255 
+
256  else {
+
257  c_life = 0;
+
258  }
+
259 
+
260  if (contact->Age() < 0 || c_life == 0) {
+
261  delete c_iter.removeItem();
+
262  }
+
263 
+
264  else if (ship && ship->GetIFF() >= 0 && ship->GetIFF() < 5) {
+
265  // update shared track database:
+
266  Contact* t = track_list.find(contact);
+
267 
+
268  if (c_ship) {
+
269  if (!t) {
+
270  Contact* track = new(__FILE__,__LINE__) Contact(c_ship, contact->d_pas, contact->d_act);
+
271  track->loc = c_ship->Location();
+
272  track_list.append(track);
+
273  }
+
274 
+
275  else {
+
276  t->loc = c_ship->Location();
+
277  t->Merge(contact);
+
278  t->UpdateTrack();
+
279  }
+
280  }
+
281 
+
282  else if (c_shot) {
+
283  if (!t) {
+
284  Contact* track = new(__FILE__,__LINE__) Contact(c_shot, contact->d_pas, contact->d_act);
+
285  track->loc = c_shot->Location();
+
286  track_list.append(track);
+
287  }
+
288 
+
289  else {
+
290  t->loc = c_shot->Location();
+
291  t->Merge(contact);
+
292  t->UpdateTrack();
+
293  }
+
294  }
+
295  }
+
296  }
+
297 
+
298 
+
299  if (mode == ACM) {
+
300  if (!ship->GetTarget())
+
301  ship->LockTarget(SimObject::SIM_SHIP, true, true);
+
302  }
+
303  }
+
304 
+
305  energy = 0.0f;
+
306 }
+
307 
+
308 // +--------------------------------------------------------------------+
+
309 
+
310 void
+
311 Sensor::ProcessContact(Ship* c_ship, double az1, double az2)
+
312 {
+
313  if (c_ship->IsNetObserver())
+
314  return;
+
315 
+
316  double sensor_range = GetBeamRange();
+
317 
+
318  // translate:
+
319  const Camera* cam = &ship->Cam();
+
320  Point targ_pt = c_ship->Location() - ship->Location();
+
321 
+
322  // rotate:
+
323  double tx = targ_pt * cam->vrt();
+
324  double ty = targ_pt * cam->vup();
+
325  double tz = targ_pt * cam->vpn();
+
326 
+
327  // convert to spherical coords:
+
328  double rng = targ_pt.length();
+
329  double az = asin(fabs(tx) / rng);
+
330  double el = asin(fabs(ty) / rng);
+
331  if (tx < 0) az = -az;
+
332  if (ty < 0) el = -el;
+
333 
+
334  double min_range = rng;
+
335  Drone* probe = ship->GetProbe();
+
336  bool probescan = false;
+
337 
+
338  if (ship->GetIFF() == c_ship->GetIFF()) {
+
339  min_range = 1;
+
340  }
+
341 
+
342  else if (probe) {
+
343  Point probe_pt = c_ship->Location() - probe->Location();
+
344  double prng = probe_pt.length();
+
345 
+
346  if (prng < probe->Design()->lethal_radius && prng < rng) {
+
347  min_range = prng;
+
348  probescan = true;
+
349  }
+
350  }
+
351 
+
352  bool vis = tz > 1 && (c_ship->Radius()/rng > 0.001);
+
353  bool threat = (c_ship->Life() != 0 &&
+
354  c_ship->GetIFF() &&
+
355  c_ship->GetIFF() != ship->GetIFF() &&
+
356  c_ship->GetEMCON() > 2 &&
+
357  c_ship->IsTracking(ship));
+
358 
+
359  if (!threat) {
+
360  if (mode == GM && !c_ship->IsGroundUnit())
+
361  return;
+
362 
+
363  if (mode != GM && c_ship->IsGroundUnit())
+
364  return;
+
365 
+
366  if (min_range > sensor_range || min_range > c_ship->Design()->detet) {
+
367  if (c_ship == target) {
+
368  ship->DropTarget();
+
369  Ignore(target);
+
370  target = 0;
+
371  }
+
372 
+
373  return;
+
374  }
+
375  }
+
376 
+
377  // clip:
+
378  if (threat || vis || mode >= PST || tz > 1) {
+
379 
+
380  // correct az/el for back hemisphere:
+
381  if (tz < 0) {
+
382  if (az < 0) az = -PI - az;
+
383  else az = PI - az;
+
384  }
+
385 
+
386  double d_pas = 0;
+
387  double d_act = 0;
+
388  double effectivity = energy/capacity * availability;
+
389 
+
390  // did this contact get scanned this frame?
+
391  if (effectivity > SENSOR_THRESHOLD) {
+
392  if (az >= az1 && az <= az2 && (mode >= PST || fabs(el) < 45*DEGREES)) {
+
393  double passive_range_limit = 500e3;
+
394  if (c_ship->Design()->detet > passive_range_limit)
+
395  passive_range_limit = c_ship->Design()->detet;
+
396 
+
397  d_pas = c_ship->PCS() * effectivity * (1 - min_range/passive_range_limit);
+
398 
+
399  if (d_pas < 0)
+
400  d_pas = 0;
+
401 
+
402  if (probescan) {
+
403  double max_range = probe->Design()->lethal_radius;
+
404  d_act = c_ship->ACS() * (1 - min_range/max_range);
+
405  }
+
406 
+
407  else if (mode != PAS && mode != PST) {
+
408  double max_range = sensor_range;
+
409  d_act = c_ship->ACS() * effectivity * (1 - min_range/max_range);
+
410  }
+
411 
+
412  if (d_act < 0)
+
413  d_act = 0;
+
414  }
+
415  }
+
416 
+
417  // yes, update or add new contact:
+
418  if (threat || vis || d_pas > SENSOR_THRESHOLD || d_act > SENSOR_THRESHOLD) {
+
419  Element* elem = c_ship->GetElement();
+
420  CombatUnit* unit = c_ship->GetCombatUnit();
+
421 
+
422  if (elem && ship && elem->GetIFF() != ship->GetIFF() && elem->IntelLevel() < Intel::LOCATED) {
+
423  elem->SetIntelLevel(Intel::LOCATED);
+
424  }
+
425 
+
426  if (unit && ship && unit->GetIFF() != ship->GetIFF()) {
+
427  CombatGroup* group = unit->GetCombatGroup();
+
428 
+
429  if (group && group->IntelLevel() < Intel::LOCATED &&
+
430  group->IntelLevel() > Intel::RESERVE) {
+
431  group->SetIntelLevel(Intel::LOCATED);
+
432  }
+
433  }
+
434 
+
435  Contact* c = FindContact(c_ship);
+
436 
+
437  if (!c) {
+
438  c = new(__FILE__,__LINE__) Contact(c_ship, 0.0f, 0.0f);
+
439  contacts.append(c);
+
440  }
+
441 
+
442  // update track:
+
443  if (c) {
+
444  c->loc = c_ship->Location();
+
445  c->d_pas = (float) d_pas;
+
446  c->d_act = (float) d_act;
+
447  c->probe = probescan;
+
448 
+
449  c->UpdateTrack();
+
450  }
+
451  }
+
452  }
+
453 }
+
454 
+
455 // +--------------------------------------------------------------------+
+
456 
+
457 void
+
458 Sensor::ProcessContact(Shot* c_shot, double az1, double az2)
+
459 {
+
460  double sensor_range = GetBeamRange();
+
461 
+
462  if (c_shot->IsPrimary() || c_shot->IsDecoy())
+
463  return;
+
464 
+
465  // translate:
+
466  const Camera* cam = &ship->Cam();
+
467  Point targ_pt = c_shot->Location() - ship->Location();
+
468 
+
469  // rotate:
+
470  double tx = targ_pt * cam->vrt();
+
471  double ty = targ_pt * cam->vup();
+
472  double tz = targ_pt * cam->vpn();
+
473 
+
474  // convert to spherical coords:
+
475  double rng = targ_pt.length();
+
476  double az = asin(fabs(tx) / rng);
+
477  double el = asin(fabs(ty) / rng);
+
478  if (tx < 0) az = -az;
+
479  if (ty < 0) el = -el;
+
480 
+
481  bool vis = tz > 1 && (c_shot->Radius()/rng > 0.001);
+
482  bool threat = (c_shot->IsTracking(ship));
+
483 
+
484  // clip:
+
485  if (threat || vis || ((mode >= PST || tz > 1) && rng <= sensor_range)) {
+
486 
+
487  // correct az/el for back hemisphere:
+
488  if (tz < 0) {
+
489  if (az < 0) az = -PI - az;
+
490  else az = PI - az;
+
491  }
+
492 
+
493  double d_pas = 0;
+
494  double d_act = 0;
+
495  double effectivity = energy/capacity * availability;
+
496 
+
497  // did this contact get scanned this frame?
+
498  if (effectivity > SENSOR_THRESHOLD) {
+
499  if (az >= az1 && az <= az2 && (mode >= PST || fabs(el) < 45*DEGREES)) {
+
500  if (rng < sensor_range/2)
+
501  d_pas = 1.5;
+
502  else
+
503  d_pas = 0.5;
+
504 
+
505  if (mode != PAS && mode != PST)
+
506  d_act = effectivity * (1 - rng/sensor_range);
+
507 
+
508  if (d_act < 0)
+
509  d_act = 0;
+
510  }
+
511  }
+
512 
+
513  // yes, update or add new contact:
+
514  if (threat || vis || d_pas > SENSOR_THRESHOLD || d_act > SENSOR_THRESHOLD) {
+
515  Contact* c = FindContact(c_shot);
+
516 
+
517  if (!c) {
+
518  c = new(__FILE__,__LINE__) Contact(c_shot, 0.0f, 0.0f);
+
519  contacts.append(c);
+
520  }
+
521 
+
522  // update track:
+
523  if (c) {
+
524  c->loc = c_shot->Location();
+
525  c->d_pas = (float) d_pas;
+
526  c->d_act = (float) d_act;
+
527 
+
528  c->UpdateTrack();
+
529  }
+
530  }
+
531  }
+
532 }
+
533 
+
534 Contact*
+
535 Sensor::FindContact(Ship* s)
+
536 {
+
537  ListIter<Contact> iter(contacts);
+
538  while (++iter) {
+
539  Contact* c = iter.value();
+
540  if (c->GetShip() == s)
+
541  return c;
+
542  }
+
543 
+
544  return 0;
+
545 }
+
546 
+
547 Contact*
+
548 Sensor::FindContact(Shot* s)
+
549 {
+
550  ListIter<Contact> iter(contacts);
+
551  while (++iter) {
+
552  Contact* c = iter.value();
+
553  if (c->GetShot() == s)
+
554  return c;
+
555  }
+
556 
+
557  return 0;
+
558 }
+
559 
+
560 // +--------------------------------------------------------------------+
+
561 
+
562 bool
+
563 Sensor::IsTracking(SimObject* tgt)
+
564 {
+
565  if (tgt && mode != GM && mode != PAS && mode != PST && IsPowerOn()) {
+
566  if (tgt == target)
+
567  return true;
+
568 
+
569  Contact* c = 0;
+
570 
+
571  if (tgt->Type() == SimObject::SIM_SHIP) {
+
572  c = FindContact((Ship*) tgt);
+
573  }
+
574  else {
+
575  c = FindContact((Shot*) tgt);
+
576  }
+
577 
+
578  return (c != 0 && c->ActReturn() > SENSOR_THRESHOLD && !c->IsProbed());
+
579  }
+
580 
+
581  return false;
+
582 }
+
583 
+
584 // +--------------------------------------------------------------------+
+
585 
+
586 const double sensor_lock_threshold = 0.5;
+
587 
+
588 struct TargetOffset {
+
589  static const char* TYPENAME() { return "TargetOffset"; }
+
590 
+
591  SimObject* target;
+
592  double offset;
+
593 
+
594  TargetOffset() : target(0), offset(10) { }
+
595  TargetOffset(SimObject* t, double o) : target(t), offset(o) { }
+
596  int operator< (const TargetOffset& o) const { return offset < o.offset; }
+
597  int operator<=(const TargetOffset& o) const { return offset <= o.offset; }
+
598  int operator==(const TargetOffset& o) const { return offset == o.offset; }
+
599 };
+
600 
+
601 SimObject*
+
602 Sensor::LockTarget(int type, bool closest, bool hostile)
+
603 {
+
604  if (!ship || ship->GetEMCON() < 3) {
+
605  Ignore(target);
+
606  target = 0;
+
607  return target;
+
608  }
+
609 
+
610  SimObject* test = 0;
+
611  ListIter<Contact> contact(ship->ContactList());
+
612 
+
613  List<TargetOffset> targets;
+
614 
+
615  while (++contact) {
+
616  if (type == SimObject::SIM_SHIP)
+
617  test = contact->GetShip();
+
618  else
+
619  test = contact->GetShot();
+
620 
+
621  if (!test)
+
622  continue;
+
623 
+
624  // do not target own missiles:
+
625  if (contact->GetShot() && contact->GetShot()->Owner() == ship)
+
626  continue;
+
627 
+
628  double tgt_range = contact->Range(ship);
+
629 
+
630  // do not target ships outside of detet range:
+
631  if (contact->GetShip() && contact->GetShip()->Design()->detet < tgt_range)
+
632  continue;
+
633 
+
634  double d_pas = contact->PasReturn();
+
635  double d_act = contact->ActReturn();
+
636  bool vis = contact->Visible(ship) || contact->Threat(ship);
+
637 
+
638  if (!vis && d_pas < sensor_lock_threshold && d_act < sensor_lock_threshold)
+
639  continue;
+
640 
+
641  if (closest) {
+
642  if (hostile && (contact->GetIFF(ship) == 0 || contact->GetIFF(ship) == ship->GetIFF()))
+
643  continue;
+
644 
+
645  targets.append(new(__FILE__,__LINE__) TargetOffset(test, tgt_range));
+
646  }
+
647 
+
648  // clip:
+
649  else if (contact->InFront(ship)) {
+
650  double az, el, rng;
+
651 
+
652  contact->GetBearing(ship, az, el, rng);
+
653  az = fabs(az / PI);
+
654  el = fabs(el / PI);
+
655 
+
656  if (az <= 0.2 && el <= 0.2)
+
657  targets.append(new(__FILE__,__LINE__) TargetOffset(test, az+el));
+
658  }
+
659  }
+
660 
+
661  targets.sort();
+
662 
+
663  if (target) {
+
664  int index = 100000;
+
665  int i = 0;
+
666 
+
667  if (targets.size() > 0) {
+
668  ListIter<TargetOffset> iter(targets);
+
669  while (++iter) {
+
670  if (iter->target == target) {
+
671  index = i;
+
672  break;
+
673  }
+
674 
+
675  i++;
+
676  }
+
677 
+
678  if (index < targets.size()-1)
+
679  index++;
+
680  else
+
681  index = 0;
+
682 
+
683  target = targets[index]->target;
+
684  Observe(target);
+
685  }
+
686  }
+
687  else if (targets.size() > 0) {
+
688  target = targets[0]->target;
+
689  Observe(target);
+
690  }
+
691  else {
+
692  target = 0;
+
693  }
+
694 
+
695  targets.destroy();
+
696 
+
697  if (target && mode < STD)
+
698  mode = STD;
+
699 
+
700  return target;
+
701 }
+
702 
+
703 // +--------------------------------------------------------------------+
+
704 
+
705 SimObject*
+
706 Sensor::LockTarget(SimObject* candidate)
+
707 {
+
708  Ignore(target);
+
709  target = 0;
+
710 
+
711  if (ship->GetEMCON() < 3)
+
712  return target;
+
713 
+
714  if (!candidate)
+
715  return target;
+
716 
+
717  int type = candidate->Type();
+
718  SimObject* test = 0;
+
719  ListIter<Contact> contact(ship->ContactList());
+
720 
+
721  while (++contact) {
+
722  if (type == SimObject::SIM_SHIP)
+
723  test = contact->GetShip();
+
724  else
+
725  test = contact->GetShot();
+
726 
+
727  if (test == candidate) {
+
728  double d_pas = contact->PasReturn();
+
729  double d_act = contact->ActReturn();
+
730  bool vis = contact->Visible(ship) || contact->Threat(ship);
+
731 
+
732  if (vis || d_pas > sensor_lock_threshold || d_act > sensor_lock_threshold) {
+
733  target = test;
+
734  Observe(target);
+
735  }
+
736 
+
737  break;
+
738  }
+
739  }
+
740 
+
741  if (target && mode < STD)
+
742  mode = STD;
+
743 
+
744  return target;
+
745 }
+
746 
+
747 // +--------------------------------------------------------------------+
+
748 
+
749 SimObject*
+
750 Sensor::AcquirePassiveTargetForMissile()
+
751 {
+
752  SimObject* pick = 0;
+
753  double min_off = 2;
+
754 
+
755  ListIter<Contact> contact(ship->ContactList());
+
756 
+
757  while (++contact) {
+
758  SimObject* test = contact->GetShip();
+
759  double d = contact->PasReturn();
+
760 
+
761  if (d < 1) continue;
+
762 
+
763  // clip:
+
764  if (contact->InFront(ship)) {
+
765  double az, el, rng;
+
766 
+
767  contact->GetBearing(ship, az, el, rng);
+
768  az = fabs(az / PI);
+
769  el = fabs(el / PI);
+
770 
+
771  if (az + el < min_off) {
+
772  min_off = az + el;
+
773  pick = test;
+
774  }
+
775  }
+
776  }
+
777 
+
778  return pick;
+
779 }
+
780 
+
781 // +--------------------------------------------------------------------+
+
782 
+
783 SimObject*
+
784 Sensor::AcquireActiveTargetForMissile()
+
785 {
+
786  SimObject* pick = 0;
+
787  double min_off = 2;
+
788 
+
789  ListIter<Contact> contact(ship->ContactList());
+
790 
+
791  while (++contact) {
+
792  SimObject* test = contact->GetShip();
+
793  double d = contact->ActReturn();
+
794 
+
795  if (d < 1) continue;
+
796 
+
797  if (contact->InFront(ship)) {
+
798  double az, el, rng;
+
799 
+
800  contact->GetBearing(ship, az, el, rng);
+
801  az = fabs(az / PI);
+
802  el = fabs(el / PI);
+
803 
+
804  if (az + el < min_off) {
+
805  min_off = az + el;
+
806  pick = test;
+
807  }
+
808  }
+
809  }
+
810 
+
811  return pick;
+
812 }
+
813 
+
814 // +--------------------------------------------------------------------+
+
815 
+
816 void
+
817 Sensor::DoEMCON(int index)
+
818 {
+
819  int e = GetEMCONPower(index);
+
820 
+
821  if (power_level * 100 > e || emcon != index) {
+
822  if (e == 0) {
+
823  PowerOff();
+
824  }
+
825  else if (emcon != index) {
+
826  PowerOn();
+
827 
+
828  if (power_level * 100 > e) {
+
829  SetPowerLevel(e);
+
830  }
+
831 
+
832  if (emcon == 3) {
+
833  if (GetMode() < PST)
+
834  SetMode(STD);
+
835  else
+
836  SetMode(CST);
+
837  }
+
838  else {
+
839  int m = GetMode();
+
840  if (m < PST && m > PAS)
+
841  SetMode(Sensor::PAS);
+
842  else if (m == CST)
+
843  SetMode(PST);
+
844  }
+
845  }
+
846  }
+
847 
+
848  emcon = index;
+
849 }
+
850 
+
+
+ + + + -- cgit v1.1