Starshatter_Open
Open source Starshatter engine
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
CampaignMissionFighter.cpp
Go to the documentation of this file.
1 /* Project Starshatter 4.5
2  Destroyer Studios LLC
3  Copyright (C) 1997-2004. All Rights Reserved.
4 
5  SUBSYSTEM: Stars.exe
6  FILE: CampaignMissionFighter.cpp
7  AUTHOR: John DiCamillo
8 
9 
10  OVERVIEW
11  ========
12  CampaignMissionFighter generates missions and mission
13  info for the player's FIGHTER SQUADRON as part of a
14  dynamic campaign.
15 */
16 
17 #include "MemDebug.h"
18 #include "CampaignMissionFighter.h"
19 #include "CampaignMissionRequest.h"
20 #include "Campaign.h"
21 #include "Combatant.h"
22 #include "CombatAssignment.h"
23 #include "CombatGroup.h"
24 #include "CombatUnit.h"
25 #include "CombatZone.h"
26 #include "Callsign.h"
27 #include "Galaxy.h"
28 #include "Mission.h"
29 #include "MissionTemplate.h"
30 #include "Instruction.h"
31 #include "Ship.h"
32 #include "ShipDesign.h"
33 #include "Starshatter.h"
34 #include "StarSystem.h"
35 #include "Player.h"
36 
37 #include "Random.h"
38 
39 static int pkg_id = 1000;
40 extern int dump_missions;
41 
42 // +--------------------------------------------------------------------+
43 
44 CampaignMissionFighter::CampaignMissionFighter(Campaign* c)
45 : campaign(c), squadron(0), mission(0), player_elem(0),
46 strike_group(0), strike_target(0), prime_target(0),
47 carrier_elem(0), ward(0), escort(0), airborne(false), airbase(false),
48 ownside(0), enemy(-1), mission_type(0), mission_info(0)
49 {
50  if (!campaign || !campaign->GetPlayerGroup()) {
51  ::Print("ERROR - CMF campaign=0x%08x player_group=0x%08x\n",
52  campaign, (DWORD) campaign?campaign->GetPlayerGroup():0);
53  return;
54  }
55 
56  CombatGroup* player_group = campaign->GetPlayerGroup();
57 
58  switch (player_group->Type()) {
59  case CombatGroup::WING: {
60  CombatGroup* wing = player_group;
61  ListIter<CombatGroup> iter = wing->GetComponents();
62 
63  while (++iter) {
64  if (iter->Type() == CombatGroup::FIGHTER_SQUADRON) {
65  squadron = iter.value();
66  }
67  }
68  }
69  break;
70 
71  case CombatGroup::FIGHTER_SQUADRON:
72  case CombatGroup::INTERCEPT_SQUADRON:
73  case CombatGroup::ATTACK_SQUADRON:
74  squadron = player_group;
75  break;
76 
77  default:
78  ::Print("ERROR - CMF invalid player group: %s IFF %d\n",
79  player_group->GetDescription(),
80  player_group->GetIFF());
81  break;
82  }
83 
84  if (squadron) {
85  CombatGroup* carrier = squadron->FindCarrier();
86 
87  if (carrier && carrier->Type() == CombatGroup::STARBASE) {
88  airbase = true;
89  }
90  }
91 }
92 
93 CampaignMissionFighter::~CampaignMissionFighter() {}
94 
95 // +--------------------------------------------------------------------+
96 
97 void
98 CampaignMissionFighter::CreateMission(CampaignMissionRequest* req)
99 {
100  if (!campaign || !squadron || !req)
101  return;
102 
103  ::Print("\n-----------------------------------------------\n");
104  if (req->Script().length())
105  ::Print("CMF CreateMission() request: %s '%s'\n",
106  Mission::RoleName(req->Type()),
107  (const char*) req->Script());
108 
109  else
110  ::Print("CMF CreateMission() request: %s %s\n",
111  Mission::RoleName(req->Type()),
112  req->GetObjective() ? req->GetObjective()->Name().data() : "(no target)");
113 
114  request = req;
115  mission_info = 0;
116 
117  if (request->GetPrimaryGroup()) {
118  switch (request->GetPrimaryGroup()->Type()) {
119  case CombatGroup::FIGHTER_SQUADRON:
120  case CombatGroup::INTERCEPT_SQUADRON:
121  case CombatGroup::ATTACK_SQUADRON:
122  squadron = request->GetPrimaryGroup();
123  break;
124  }
125  }
126 
127  ownside = squadron->GetIFF();
128 
129  for (int i = 0; i < campaign->GetCombatants().size(); i++) {
130  int iff = campaign->GetCombatants().at(i)->GetIFF();
131  if (iff > 0 && iff != ownside) {
132  enemy = iff;
133  break;
134  }
135  }
136 
137  static int id_key = 1;
138  GenerateMission(id_key++);
139  DefineMissionObjectives();
140 
141  MissionInfo* info = DescribeMission();
142 
143  if (info) {
144  campaign->GetMissionList().append(info);
145 
146  ::Print("CMF Created %03d '%s' %s\n\n",
147  info->id,
148  (const char*) info->name,
149  Mission::RoleName(mission->Type()));
150 
151  if (dump_missions) {
152  Text script = mission->Serialize();
153  char fname[32];
154 
155  sprintf_s(fname, "msn%03d.def", info->id);
156  FILE* f;
157  fopen_s(&f, fname, "w");
158  if (f) {
159  fprintf(f, "%s\n", script.data());
160  fclose(f);
161  }
162  }
163  }
164  else {
165  ::Print("CMF failed to create mission.\n");
166  }
167 }
168 
169 // +--------------------------------------------------------------------+
170 
171 Mission*
172 CampaignMissionFighter::GenerateMission(int id)
173 {
174  bool found = false;
175 
176  SelectType();
177 
178  if (request && request->Script().length()) {
179  MissionTemplate* mt = new(__FILE__,__LINE__) MissionTemplate(id, request->Script(), campaign->Path());
180  if (mt)
181  mt->SetPlayerSquadron(squadron);
182  mission = mt;
183  found = true;
184  }
185 
186  else {
187  mission_info = campaign->FindMissionTemplate(mission_type, squadron);
188  found = mission_info != 0;
189 
190  if (found) {
191  MissionTemplate* mt = new(__FILE__,__LINE__) MissionTemplate(id, mission_info->script, campaign->Path());
192  if (mt)
193  mt->SetPlayerSquadron(squadron);
194  mission = mt;
195  }
196  else {
197  mission = new(__FILE__,__LINE__) Mission(id);
198  if (mission)
199  mission->SetType(mission_type);
200  }
201  }
202 
203  if (!mission) {
204  Exit();
205  return 0;
206  }
207 
208  char name[64];
209  sprintf_s(name, "Fighter Mission %d", id);
210 
211  mission->SetName(name);
212  mission->SetTeam(squadron->GetIFF());
213  mission->SetStart(request->StartTime());
214 
215  SelectRegion();
216  GenerateStandardElements();
217  CreatePatrols();
218 
219  if (!found) {
220  GenerateMissionElements();
221  mission->SetOK(true);
222  mission->Validate();
223  }
224 
225  else {
226  mission->Load();
227 
228  if (mission->IsOK()) {
229  player_elem = mission->GetPlayer();
230  prime_target = mission->GetTarget();
231  ward = mission->GetWard();
232 
233  Player* p = Player::GetCurrentPlayer();
234 
235  if (player_elem && p)
236  player_elem->SetAlert(!p->FlyingStart());
237  }
238 
239  // if there was a problem, scrap the mission
240  // and start over:
241  else {
242  delete mission;
243 
244  mission = new(__FILE__,__LINE__) Mission(id);
245  mission->SetType(mission_type);
246  mission->SetName(name);
247  mission->SetTeam(squadron->GetIFF());
248  mission->SetStart(request->StartTime());
249 
250  SelectRegion();
251  GenerateStandardElements();
252  GenerateMissionElements();
253 
254  mission->SetOK(true);
255  mission->Validate();
256  }
257  }
258 
259  return mission;
260 }
261 
262 // +--------------------------------------------------------------------+
263 
264 bool
265 CampaignMissionFighter::IsGroundObjective(CombatGroup* obj)
266 {
267  bool ground = false;
268 
269  if (obj) {
270  CombatGroup* pgroup = campaign->GetPlayerGroup();
271 
272  if (pgroup) {
273  CombatZone* zone = pgroup->GetAssignedZone();
274 
275  if (zone) {
276  StarSystem* system = campaign->GetSystem(zone->System());
277 
278  if (system) {
279  OrbitalRegion* region = system->FindRegion(obj->GetRegion());
280 
281  if (region && region->Type() == Orbital::TERRAIN) {
282  ground = true;
283  }
284  }
285  }
286  }
287  }
288 
289  return ground;
290 }
291 
292 // +--------------------------------------------------------------------+
293 
294 void
295 CampaignMissionFighter::SelectType()
296 {
297  int type = Mission::PATROL;
298 
299  if (request) {
300  type = request->Type();
301  if (type == Mission::STRIKE) {
302  strike_group = request->GetPrimaryGroup();
303 
304  // verify that objective is a ground target:
305  if (!IsGroundObjective(request->GetObjective())) {
306  type = Mission::ASSAULT;
307  }
308  }
309 
310  else if (type == Mission::ESCORT_STRIKE) {
311  strike_group = request->GetSecondaryGroup();
312  if (!strike_group || strike_group->CalcValue() < 1) {
313  type = Mission::SWEEP;
314  strike_group = 0;
315  }
316  }
317  }
318 
319  mission_type = type;
320 }
321 
322 void
323 CampaignMissionFighter::SelectRegion()
324 {
325  CombatZone* zone = squadron->GetAssignedZone();
326 
327  if (!zone)
328  zone = squadron->GetCurrentZone();
329 
330  if (zone) {
331  mission->SetStarSystem(campaign->GetSystem(zone->System()));
332  mission->SetRegion(*zone->GetRegions().at(0));
333 
334  orb_region = mission->GetRegion();
335 
336  if (zone->GetRegions().size() > 1) {
337  air_region = *zone->GetRegions().at(1);
338 
339  StarSystem* system = mission->GetStarSystem();
340  OrbitalRegion* rgn = 0;
341 
342  if (system)
343  rgn = system->FindRegion(air_region);
344 
345  if (!rgn || rgn->Type() != Orbital::TERRAIN)
346  air_region = "";
347  }
348 
349  if (air_region.length() > 0) {
350  if (request && IsGroundObjective(request->GetObjective())) {
351  airborne = true;
352  }
353 
354  else if (mission->Type() >= Mission::AIR_PATROL &&
355  mission->Type() <= Mission::AIR_INTERCEPT) {
356  airborne = true;
357  }
358 
359  else if (mission->Type() == Mission::STRIKE ||
360  mission->Type() == Mission::ESCORT_STRIKE) {
361  if (strike_group) {
362  strike_target = campaign->FindStrikeTarget(ownside, strike_group);
363 
364  if (strike_target && strike_target->GetRegion() == air_region)
365  airborne = true;
366  }
367  }
368 
369  if (airbase) {
370  mission->SetRegion(air_region);
371  }
372  }
373  }
374 
375  else {
376  ::Print("WARNING: CMF - No zone for '%s'\n", squadron->Name().data());
377 
378  StarSystem* s = campaign->GetSystemList()[0];
379 
380  mission->SetStarSystem(s);
381  mission->SetRegion(s->Regions()[0]->Name());
382  }
383 
384  if (!airborne) {
385  switch (mission->Type()) {
386  case Mission::AIR_PATROL: mission->SetType(Mission::PATROL); break;
387  case Mission::AIR_SWEEP: mission->SetType(Mission::SWEEP); break;
388  case Mission::AIR_INTERCEPT: mission->SetType(Mission::INTERCEPT); break;
389  default: break;
390  }
391  }
392 }
393 
394 // +--------------------------------------------------------------------+
395 
396 void
397 CampaignMissionFighter::GenerateStandardElements()
398 {
399  ListIter<CombatZone> z_iter = campaign->GetZones();
400  while (++z_iter) {
401  CombatZone* z = z_iter.value();
402 
403  ListIter<ZoneForce> iter = z->GetForces();
404  while (++iter) {
405  ZoneForce* force = iter.value();
406  ListIter<CombatGroup> group = force->GetGroups();
407 
408  while (++group) {
409  CombatGroup* g = group.value();
410 
411  switch (g->Type()) {
412  case CombatGroup::INTERCEPT_SQUADRON:
413  case CombatGroup::FIGHTER_SQUADRON:
414  case CombatGroup::ATTACK_SQUADRON:
415  case CombatGroup::LCA_SQUADRON:
416  CreateSquadron(g);
417  break;
418 
419  case CombatGroup::DESTROYER_SQUADRON:
420  case CombatGroup::BATTLE_GROUP:
421  case CombatGroup::CARRIER_GROUP:
422  CreateElements(g);
423  break;
424 
425  case CombatGroup::MINEFIELD:
426  case CombatGroup::BATTERY:
427  case CombatGroup::MISSILE:
428  case CombatGroup::STATION:
429  case CombatGroup::STARBASE:
430  case CombatGroup::SUPPORT:
431  case CombatGroup::COURIER:
432  case CombatGroup::MEDICAL:
433  case CombatGroup::SUPPLY:
434  case CombatGroup::REPAIR:
435  CreateElements(g);
436  break;
437 
438  case CombatGroup::CIVILIAN:
439  case CombatGroup::WAR_PRODUCTION:
440  case CombatGroup::FACTORY:
441  case CombatGroup::REFINERY:
442  case CombatGroup::RESOURCE:
443  case CombatGroup::INFRASTRUCTURE:
444  case CombatGroup::TRANSPORT:
445  case CombatGroup::NETWORK:
446  case CombatGroup::HABITAT:
447  case CombatGroup::STORAGE:
448  case CombatGroup::NON_COM:
449  CreateElements(g);
450  break;
451  }
452  }
453  }
454  }
455 }
456 
457 // +--------------------------------------------------------------------+
458 
459 void
460 CampaignMissionFighter::GenerateMissionElements()
461 {
462  CreateWards();
463  CreatePlayer(squadron);
464  CreateTargets();
465  CreateEscorts();
466 
467  if (player_elem) {
468  Instruction* obj = new(__FILE__,__LINE__) Instruction(mission->GetRegion(),
469  Point(0,0,0),
470  Instruction::RTB);
471 
472  if (obj)
473  player_elem->AddObjective(obj);
474  }
475 }
476 
477 // +--------------------------------------------------------------------+
478 
479 void
480 CampaignMissionFighter::CreateElements(CombatGroup* g)
481 {
482  MissionElement* elem = 0;
483  List<CombatUnit>& units = g->GetUnits();
484 
485  CombatUnit* cmdr = 0;
486 
487  for (int i = 0; i < units.size(); i++) {
488  elem = CreateSingleElement(g, units[i]);
489 
490  if (elem) {
491  if (!cmdr) {
492  cmdr = units[i];
493  }
494  else {
495  elem->SetCommander(cmdr->Name());
496 
497  if (g->Type() == CombatGroup::CARRIER_GROUP &&
498  elem->MissionRole() == Mission::ESCORT) {
499  Instruction* obj = new(__FILE__,__LINE__) Instruction(Instruction::ESCORT, cmdr->Name());
500  if (obj)
501  elem->AddObjective(obj);
502  }
503  }
504 
505  mission->AddElement(elem);
506  }
507  }
508 }
509 
510 MissionElement*
511 CampaignMissionFighter::CreateSingleElement(CombatGroup* g, CombatUnit* u)
512 {
513  if (!g || g->IsReserve()) return 0;
514  if (!u || u->LiveCount() < 1) return 0;
515 
516  // make sure this unit is actually in the right star system:
517  Galaxy* galaxy = Galaxy::GetInstance();
518  if (galaxy) {
519  if (galaxy->FindSystemByRegion(u->GetRegion()) !=
520  galaxy->FindSystemByRegion(squadron->GetRegion())) {
521  return 0;
522  }
523  }
524 
525  // make sure this unit isn't already in the mission:
526  ListIter<MissionElement> e_iter = mission->GetElements();
527  while (++e_iter) {
528  MissionElement* elem = e_iter.value();
529 
530  if (elem->GetCombatUnit() == u)
531  return 0;
532  }
533 
534  MissionElement* elem = new(__FILE__,__LINE__) MissionElement;
535  if (!elem) {
536  Exit();
537  return 0;
538  }
539 
540  if (u->Name().length())
541  elem->SetName(u->Name());
542  else
543  elem->SetName(u->DesignName());
544 
545  elem->SetElementID(pkg_id++);
546 
547  elem->SetDesign(u->GetDesign());
548  elem->SetCount(u->LiveCount());
549  elem->SetIFF(u->GetIFF());
550  elem->SetIntelLevel(g->IntelLevel());
551  elem->SetRegion(u->GetRegion());
552  elem->SetHeading(u->GetHeading());
553 
554  int unit_index = g->GetUnits().index(u);
555  Point base_loc = u->Location();
556  bool exact = u->IsStatic(); // exact unit-level placement
557 
558  if (base_loc.length() < 1) {
559  base_loc = g->Location();
560  exact = false;
561  }
562 
563  if (unit_index < 0 || unit_index > 0 && !exact) {
564  Point loc = RandomDirection();
565 
566  if (!u->IsStatic()) {
567  while (fabs(loc.y) > fabs(loc.x))
568  loc = RandomDirection();
569 
570  loc *= 10e3 + 9e3 * unit_index;
571  }
572  else {
573  loc *= 2e3 + 2e3 * unit_index;
574  }
575 
576  elem->SetLocation(base_loc + loc);
577  }
578  else {
579  elem->SetLocation(base_loc);
580  }
581 
582  if (g->Type() == CombatGroup::CARRIER_GROUP) {
583  if (u->Type() == Ship::CARRIER) {
584  elem->SetMissionRole(Mission::FLIGHT_OPS);
585 
586  if (squadron && elem->GetCombatGroup() == squadron->FindCarrier())
587  carrier_elem = elem;
588 
589  else if (!carrier_elem && u->GetIFF() == squadron->GetIFF())
590  carrier_elem = elem;
591  }
592  else {
593  elem->SetMissionRole(Mission::ESCORT);
594  }
595  }
596  else if (u->Type() == Ship::STATION ||
597  u->Type() == Ship::STARBASE) {
598  elem->SetMissionRole(Mission::FLIGHT_OPS);
599 
600  if (squadron && elem->GetCombatGroup() == squadron->FindCarrier()) {
601  carrier_elem = elem;
602 
603  if (u->Type() == Ship::STARBASE)
604  airbase = true;
605  }
606  }
607  else if (u->Type() == Ship::FARCASTER) {
608  elem->SetMissionRole(Mission::OTHER);
609 
610  // link farcaster to other terminus:
611  Text name = u->Name();
612  int dash = -1;
613 
614  for (int i = 0; i < (int) name.length(); i++)
615  if (name[i] == '-')
616  dash = i;
617 
618  Text src = name.substring(0, dash);
619  Text dst = name.substring(dash+1, name.length() - (dash+1));
620 
621  Instruction* obj = new(__FILE__,__LINE__) Instruction(Instruction::VECTOR, dst + "-" + src);
622  elem->AddObjective(obj);
623  }
624  else if ((u->Type() & Ship::STARSHIPS) != 0) {
625  elem->SetMissionRole(Mission::FLEET);
626  }
627 
628  elem->SetCombatGroup(g);
629  elem->SetCombatUnit(u);
630 
631  return elem;
632 }
633 
634 CombatUnit*
635 CampaignMissionFighter::FindCarrier(CombatGroup* g)
636 {
637  CombatGroup* carrier = g->FindCarrier();
638 
639  if (carrier && carrier->GetUnits().size()) {
640  MissionElement* carrier_elem = mission->FindElement(carrier->Name());
641 
642  if (carrier_elem)
643  return carrier->GetUnits().at(0);
644  }
645 
646  return 0;
647 }
648 
649 void
650 CampaignMissionFighter::CreateSquadron(CombatGroup* g)
651 {
652  if (!g || g->IsReserve()) return;
653 
654  CombatUnit* fighter = g->GetUnits().at(0);
655  CombatUnit* carrier = FindCarrier(g);
656 
657  if (!fighter || !carrier) return;
658 
659  int live_count = fighter->LiveCount();
660  int maint_count = (live_count > 4) ? live_count / 2 : 0;
661 
662  MissionElement* elem = new(__FILE__,__LINE__) MissionElement;
663 
664  if (!elem) {
665  Exit();
666  return;
667  }
668 
669  elem->SetName(g->Name());
670  elem->SetElementID(pkg_id++);
671 
672  elem->SetDesign(fighter->GetDesign());
673  elem->SetCount(fighter->Count());
674  elem->SetDeadCount(fighter->DeadCount());
675  elem->SetMaintCount(maint_count);
676  elem->SetIFF(fighter->GetIFF());
677  elem->SetIntelLevel(g->IntelLevel());
678  elem->SetRegion(fighter->GetRegion());
679 
680  elem->SetCarrier(carrier->Name());
681  elem->SetCommander(carrier->Name());
682  elem->SetLocation(carrier->Location() + RandomPoint());
683 
684  elem->SetCombatGroup(g);
685  elem->SetCombatUnit(fighter);
686 
687  mission->AddElement(elem);
688 }
689 
690 void
691 CampaignMissionFighter::CreatePlayer(CombatGroup* g)
692 {
693  int pkg_size = 2;
694 
695  if (mission->Type() == Mission::STRIKE || mission->Type() == Mission::ASSAULT) {
696  if (request && request->GetObjective()) {
697  int tgt_type = request->GetObjective()->Type();
698 
699  if (tgt_type >= CombatGroup::FLEET && tgt_type <= CombatGroup::CARRIER_GROUP)
700  pkg_size = 4;
701 
702  if (tgt_type == CombatGroup::STATION || tgt_type == CombatGroup::STARBASE)
703  pkg_size = 4;
704  }
705  }
706 
707  MissionElement* elem = CreateFighterPackage(g, pkg_size, mission->Type());
708 
709  if (elem) {
710  Player* p = Player::GetCurrentPlayer();
711  elem->SetAlert(p ? !p->FlyingStart() : true);
712  elem->SetPlayer(1);
713 
714  if (ward) {
715  Point approach = elem->Location() - ward->Location();
716  approach.Normalize();
717 
718  Point pickup = ward->Location() + approach * 50e3;
719  double delta = (pickup - elem->Location()).length();
720 
721  if (delta > 30e3) {
722  Instruction* n = new(__FILE__,__LINE__) Instruction(elem->Region(), pickup, Instruction::ESCORT);
723  n->SetTarget(ward->Name());
724  n->SetSpeed(750);
725  elem->AddNavPoint(n);
726  }
727 
728  Instruction* obj = new(__FILE__,__LINE__) Instruction(Instruction::ESCORT, ward->Name());
729 
730  switch (mission->Type()) {
731  case Mission::ESCORT_FREIGHT:
732  obj->SetTargetDesc(Text("the star freighter ") + ward->Name());
733  break;
734 
735  case Mission::ESCORT_SHUTTLE:
736  obj->SetTargetDesc(Text("the shuttle ") + ward->Name());
737  break;
738 
739  case Mission::ESCORT_STRIKE:
740  obj->SetTargetDesc(Text("the ") + ward->Name() + Text(" strike package"));
741  break;
742 
743  case Mission::DEFEND:
744  obj->SetTargetDesc(Text("the ") + ward->Name());
745  break;
746 
747  default:
748  if (ward->GetCombatGroup()) {
749  obj->SetTargetDesc(Text("the ") + ward->GetCombatGroup()->GetDescription());
750  }
751  else {
752  obj->SetTargetDesc(Text("the ") + ward->Name());
753  }
754  break;
755  }
756 
757  elem->AddObjective(obj);
758  }
759 
760  mission->AddElement(elem);
761 
762  player_elem = elem;
763  }
764 }
765 
766 // +--------------------------------------------------------------------+
767 
768 void
769 CampaignMissionFighter::CreatePatrols()
770 {
771  List<MissionElement> patrols;
772 
773  ListIter<MissionElement> iter = mission->GetElements();
774  while (++iter) {
775  MissionElement* squad_elem = iter.value();
776  CombatGroup* squadron = squad_elem->GetCombatGroup();
777  CombatUnit* unit = squad_elem->GetCombatUnit();
778 
779  if (!squad_elem->IsSquadron() || !squadron || !unit || unit->LiveCount() < 4)
780  continue;
781 
782  if (squadron->Type() == CombatGroup::INTERCEPT_SQUADRON ||
783  squadron->Type() == CombatGroup::FIGHTER_SQUADRON) {
784 
785  StarSystem* system = mission->GetStarSystem();
786  CombatGroup* base = squadron->FindCarrier();
787 
788  if (!base)
789  continue;
790 
791  OrbitalRegion* region = system->FindRegion(base->GetRegion());
792 
793  if (!region)
794  continue;
795 
796  int patrol_type = Mission::PATROL;
797  Point base_loc;
798 
799  if (region->Type() == Orbital::TERRAIN) {
800  patrol_type = Mission::AIR_PATROL;
801 
802  if (RandomChance(2,3))
803  continue;
804  }
805 
806  base_loc = base->Location() + RandomPoint() * 1.5;
807 
808  if (region->Type() == Orbital::TERRAIN)
809  base_loc += Point(0, 0, 14.0e3);
810 
811  MissionElement* elem = CreateFighterPackage(squadron, 2, patrol_type);
812  if (elem) {
813  elem->SetIntelLevel(Intel::KNOWN);
814  elem->SetRegion(base->GetRegion());
815  elem->SetLocation(base_loc);
816  patrols.append(elem);
817  }
818  }
819  }
820 
821  iter.attach(patrols);
822  while (++iter)
823  mission->AddElement(iter.value());
824 }
825 
826 // +--------------------------------------------------------------------+
827 
828 void
829 CampaignMissionFighter::CreateWards()
830 {
831  switch (mission->Type()) {
832  case Mission::ESCORT_FREIGHT: CreateWardFreight(); break;
833  case Mission::ESCORT_SHUTTLE: CreateWardShuttle(); break;
834  case Mission::ESCORT_STRIKE: CreateWardStrike(); break;
835  default: break;
836  }
837 }
838 
839 void
840 CampaignMissionFighter::CreateWardFreight()
841 {
842  if (!mission || !mission->GetStarSystem()) return;
843 
844  CombatUnit* carrier = FindCarrier(squadron);
845  CombatGroup* freight = 0;
846 
847  if (request)
848  freight = request->GetObjective();
849 
850  if (!freight)
851  freight = campaign->FindGroup(ownside, CombatGroup::FREIGHT);
852 
853  if (!freight || freight->CalcValue() < 1) return;
854 
855  CombatUnit* unit = freight->GetNextUnit();
856  if (!unit) return;
857 
858  MissionElement* elem = CreateSingleElement(freight, unit);
859  if (!elem) return;
860 
861  elem->SetMissionRole(Mission::CARGO);
862  elem->SetIntelLevel(Intel::KNOWN);
863  elem->SetRegion(squadron->GetRegion());
864 
865  if (carrier)
866  elem->SetLocation(carrier->Location() + RandomPoint() * 2);
867 
868  ward = elem;
869  mission->AddElement(elem);
870 
871 
872  StarSystem* system = mission->GetStarSystem();
873  OrbitalRegion* rgn1 = system->FindRegion(elem->Region());
874  Point delta = rgn1->Location() - rgn1->Primary()->Location();
875  Point npt_loc = elem->Location();
876  Instruction* n = 0;
877 
878  delta.Normalize();
879  delta *= 200.0e3;
880 
881  npt_loc += delta;
882 
883  n = new(__FILE__,__LINE__) Instruction(elem->Region(),
884  npt_loc,
885  Instruction::VECTOR);
886 
887  if (n) {
888  n->SetSpeed(500);
889  elem->AddNavPoint(n);
890  }
891 
892  Text rgn2 = elem->Region();
893  List<CombatZone>& zones = campaign->GetZones();
894  if (zones[zones.size()-1]->HasRegion(rgn2))
895  rgn2 = *zones[0]->GetRegions()[0];
896  else
897  rgn2 = *zones[zones.size()-1]->GetRegions()[0];
898 
899  n = new(__FILE__,__LINE__) Instruction(rgn2,
900  Point(0, 0, 0),
901  Instruction::VECTOR);
902 
903  if (n) {
904  n->SetSpeed(750);
905  elem->AddNavPoint(n);
906  }
907 }
908 
909 void
910 CampaignMissionFighter::CreateWardShuttle()
911 {
912  if (!mission || !mission->GetStarSystem()) return;
913 
914  CombatUnit* carrier = FindCarrier(squadron);
915  CombatGroup* shuttle = campaign->FindGroup(ownside, CombatGroup::LCA_SQUADRON);
916 
917  if (!shuttle || shuttle->CalcValue() < 1) return;
918 
919  List<CombatUnit>& units = shuttle->GetUnits();
920 
921  MissionElement* elem = CreateFighterPackage(shuttle, 1, Mission::CARGO);
922  if (!elem) return;
923 
924  elem->SetIntelLevel(Intel::KNOWN);
925  elem->SetRegion(orb_region);
926  elem->Loadouts().destroy();
927 
928  if (carrier)
929  elem->SetLocation(carrier->Location() + RandomPoint() * 2);
930 
931  ward = elem;
932  mission->AddElement(elem);
933 
934  // if there is terrain nearby, then have the shuttle fly down to it:
935  if (air_region.length() > 0) {
936  StarSystem* system = mission->GetStarSystem();
937  OrbitalRegion* rgn1 = system->FindRegion(elem->Region());
938  Point delta = rgn1->Location() - rgn1->Primary()->Location();
939  Point npt_loc = elem->Location();
940  Instruction* n = 0;
941 
942  delta.Normalize();
943  delta *= -200.0e3;
944 
945  npt_loc += delta;
946 
947  n = new(__FILE__,__LINE__) Instruction(elem->Region(),
948  npt_loc,
949  Instruction::VECTOR);
950 
951  if (n) {
952  n->SetSpeed(500);
953  elem->AddNavPoint(n);
954  }
955 
956  n = new(__FILE__,__LINE__) Instruction(air_region,
957  Point(0, 0, 10.0e3),
958  Instruction::VECTOR);
959 
960  if (n) {
961  n->SetSpeed(500);
962  elem->AddNavPoint(n);
963  }
964  }
965 
966  // otherwise, escort the shuttle in for a landing on the carrier:
967  else if (carrier) {
968  Point src = carrier->Location() + RandomDirection() * 150e3;
969  Point dst = carrier->Location() + RandomDirection() * 25e3;
970  Instruction* n = 0;
971 
972  elem->SetLocation(src);
973 
974  n = new(__FILE__,__LINE__) Instruction(elem->Region(), dst, Instruction::DOCK);
975  if (n) {
976  n->SetTarget(carrier->Name());
977  n->SetSpeed(500);
978  elem->AddNavPoint(n);
979  }
980  }
981 }
982 
983 void
984 CampaignMissionFighter::CreateWardStrike()
985 {
986  if (!mission || !mission->GetStarSystem()) return;
987 
988  CombatUnit* carrier = FindCarrier(squadron);
989  CombatGroup* strike = strike_group;
990 
991  if (!strike || strike->CalcValue() < 1) return;
992 
993  List<CombatUnit>& units = strike->GetUnits();
994 
995  int type = Mission::ASSAULT;
996 
997  if (airborne)
998  type = Mission::STRIKE;
999 
1000  MissionElement* elem = CreateFighterPackage(strike, 2, type);
1001  if (!elem) return;
1002 
1003  if (strike->GetParent() == squadron->GetParent()) {
1004  Player* p = Player::GetCurrentPlayer();
1005  elem->SetAlert(p ? !p->FlyingStart() : true);
1006  }
1007 
1008  elem->SetIntelLevel(Intel::KNOWN);
1009  elem->SetRegion(squadron->GetRegion());
1010 
1011  if (strike_target) {
1012  Instruction* obj = new(__FILE__,__LINE__) Instruction(Instruction::ASSAULT, strike_target->Name());
1013 
1014  if (obj) {
1015  if (airborne)
1016  obj->SetAction(Instruction::STRIKE);
1017 
1018  elem->AddObjective(obj);
1019  }
1020  }
1021 
1022  ward = elem;
1023  mission->AddElement(elem);
1024 
1025 
1026  StarSystem* system = mission->GetStarSystem();
1027  OrbitalRegion* rgn1 = system->FindRegion(elem->Region());
1028  Point delta = rgn1->Location() - rgn1->Primary()->Location();
1029  Point npt_loc = elem->Location();
1030  Instruction* n = 0;
1031 
1032  if (airborne) {
1033  delta.Normalize();
1034  delta *= -30.0e3;
1035  npt_loc += delta;
1036 
1037  n = new(__FILE__,__LINE__) Instruction(elem->Region(),
1038  npt_loc,
1039  Instruction::VECTOR);
1040  if (n) {
1041  n->SetSpeed(500);
1042  elem->AddNavPoint(n);
1043  }
1044 
1045  npt_loc = Point(0, 0, 10.0e3);
1046 
1047  n = new(__FILE__,__LINE__) Instruction(air_region,
1048  npt_loc,
1049  Instruction::VECTOR);
1050  if (n) {
1051  n->SetSpeed(500);
1052  elem->AddNavPoint(n);
1053  }
1054  }
1055 
1056  // IP:
1057  if (strike_target) {
1058  delta = strike_target->Location() - npt_loc;
1059  delta.Normalize();
1060  delta *= 15.0e3;
1061 
1062  npt_loc = strike_target->Location() + delta + Point(0, 0, 8.0e3);
1063 
1064  n = new(__FILE__,__LINE__) Instruction(strike_target->GetRegion(),
1065  npt_loc,
1066  Instruction::STRIKE);
1067  if (n) {
1068  n->SetSpeed(500);
1069  elem->AddNavPoint(n);
1070  }
1071  }
1072 
1073  if (airborne) {
1074  n = new(__FILE__,__LINE__) Instruction(air_region,
1075  Point(0, 0, 30.0e3),
1076  Instruction::VECTOR);
1077  if (n) {
1078  n->SetSpeed(500);
1079  elem->AddNavPoint(n);
1080  }
1081  }
1082 
1083  if (carrier) {
1084  n = new(__FILE__,__LINE__) Instruction(elem->Region(),
1085  carrier->Location() - Point(0, -20.0e3, 0),
1086  Instruction::VECTOR);
1087  if (n) {
1088  n->SetSpeed(500);
1089  elem->AddNavPoint(n);
1090  }
1091  }
1092 
1093  // find the strike target element:
1094  if (strike_target) {
1095  prime_target = mission->FindElement(strike_target->Name());
1096  }
1097 }
1098 
1099 // +--------------------------------------------------------------------+
1100 
1101 void
1102 CampaignMissionFighter::CreateEscorts()
1103 {
1104  bool escort_needed = false;
1105 
1106  if (mission->Type() == Mission::STRIKE || mission->Type() == Mission::ASSAULT) {
1107  if (request && request->GetObjective()) {
1108  int tgt_type = request->GetObjective()->Type();
1109 
1110  if (tgt_type == CombatGroup::CARRIER_GROUP ||
1111  tgt_type == CombatGroup::STATION ||
1112  tgt_type == CombatGroup::STARBASE)
1113 
1114  escort_needed = true;
1115  }
1116  }
1117 
1118  if (player_elem && escort_needed) {
1119  CombatGroup* s = FindSquadron(ownside, CombatGroup::INTERCEPT_SQUADRON);
1120 
1121  if (s && s->IsAssignable()) {
1122  MissionElement* elem = CreateFighterPackage(s, 2, Mission::ESCORT_STRIKE);
1123 
1124  if (elem) {
1125  Point offset = Point(2.0e3, 2.0e3, 1.0e3);
1126 
1127  ListIter<Instruction> npt_iter = player_elem->NavList();
1128  while (++npt_iter) {
1129  Instruction* npt = npt_iter.value();
1130  Instruction* n = new(__FILE__,__LINE__) Instruction(npt->RegionName(),
1131  npt->Location() + offset,
1132  Instruction::ESCORT);
1133  if (n) {
1134  n->SetSpeed(npt->Speed());
1135  elem->AddNavPoint(n);
1136  }
1137  }
1138 
1139  mission->AddElement(elem);
1140  }
1141  }
1142  }
1143 }
1144 
1145 // +--------------------------------------------------------------------+
1146 
1147 void
1148 CampaignMissionFighter::CreateTargets()
1149 {
1150  switch (mission->Type()) {
1151  default:
1152  case Mission::DEFEND:
1153  case Mission::PATROL: CreateTargetsPatrol(); break;
1154  case Mission::SWEEP: CreateTargetsSweep(); break;
1155  case Mission::INTERCEPT: CreateTargetsIntercept(); break;
1156  case Mission::ESCORT_FREIGHT: CreateTargetsFreightEscort(); break;
1157 
1158  case Mission::ESCORT:
1159  case Mission::ESCORT_SHUTTLE: CreateTargetsShuttleEscort(); break;
1160  case Mission::ESCORT_STRIKE: CreateTargetsStrikeEscort(); break;
1161  case Mission::STRIKE: CreateTargetsStrike(); break;
1162  case Mission::ASSAULT: CreateTargetsAssault(); break;
1163  }
1164 }
1165 
1166 void
1167 CampaignMissionFighter::CreateTargetsPatrol()
1168 {
1169  if (!squadron || !player_elem) return;
1170 
1171  Text region = squadron->GetRegion();
1172  Point base_loc = player_elem->Location();
1173  Point patrol_loc;
1174 
1175  if (airborne)
1176  base_loc = RandomPoint() * 2 + Point(0, 0, 12.0e3);
1177 
1178  else if (carrier_elem)
1179  base_loc = carrier_elem->Location();
1180 
1181  if (airborne) {
1182  if (!airbase)
1183  PlanetaryInsertion(player_elem);
1184  region = air_region;
1185  patrol_loc = base_loc +
1186  RandomDirection() * Random( 60e3, 100e3);
1187  }
1188  else {
1189  patrol_loc = base_loc +
1190  RandomDirection() * Random(110e3, 160e3);
1191  }
1192 
1193  Instruction* n = new(__FILE__,__LINE__) Instruction(region,
1194  patrol_loc,
1195  Instruction::PATROL);
1196  if (n)
1197  player_elem->AddNavPoint(n);
1198 
1199  int ntargets = (int) Random(2.0,5.1);
1200 
1201  while (ntargets > 0) {
1202  int t = CreateRandomTarget(region, patrol_loc);
1203  ntargets -= t;
1204  if (t < 1) break;
1205  }
1206 
1207  if (airborne && !airbase) {
1208  OrbitalInsertion(player_elem);
1209  }
1210 
1211  Instruction* obj = new(__FILE__,__LINE__) Instruction(*n);
1212  obj->SetTargetDesc("inbound enemy units");
1213  player_elem->AddObjective(obj);
1214 
1215  if (carrier_elem && !airborne) {
1216  obj = new(__FILE__,__LINE__) Instruction(Instruction::DEFEND, carrier_elem->Name());
1217  if (obj) {
1218  obj->SetTargetDesc(Text("the ") + carrier_elem->Name() + " battle group");
1219  player_elem->AddObjective(obj);
1220  }
1221  }
1222 }
1223 
1224 void
1225 CampaignMissionFighter::CreateTargetsSweep()
1226 {
1227  if (!squadron || !player_elem) return;
1228 
1229  double traverse = PI;
1230  double a = Random(-PI/2, PI/2);
1231  Point base_loc = player_elem->Location();
1232  Point sweep_loc = base_loc;
1233  Text region = player_elem->Region();
1234  Instruction* n = 0;
1235 
1236  if (carrier_elem)
1237  base_loc = carrier_elem->Location();
1238 
1239  if (airborne) {
1240  PlanetaryInsertion(player_elem);
1241  region = air_region;
1242  sweep_loc = RandomPoint() + Point(0, 0, 10.0e3); // keep it airborne!
1243  }
1244 
1245  sweep_loc += Point(sin(a), -cos(a), 0) * 100.0e3;
1246 
1247  n = new(__FILE__,__LINE__) Instruction(region,
1248  sweep_loc,
1249  Instruction::VECTOR);
1250  if (n) {
1251  n->SetSpeed(750);
1252  player_elem->AddNavPoint(n);
1253  }
1254 
1255  int index = 0;
1256  int ntargets = 6;
1257 
1258  while (traverse > 0) {
1259  double a1 = Random(PI/4, PI/2);
1260  traverse -= a1;
1261  a += a1;
1262 
1263  sweep_loc += Point(sin(a), -cos(a), 0) * 80.0e3;
1264 
1265  n = new(__FILE__,__LINE__) Instruction(region,
1266  sweep_loc,
1267  Instruction::SWEEP);
1268  if (n) {
1269  n->SetSpeed(750);
1270  n->SetFormation(Instruction::SPREAD);
1271  player_elem->AddNavPoint(n);
1272  }
1273 
1274  if (ntargets && RandomChance()) {
1275  ntargets -= CreateRandomTarget(region, sweep_loc);
1276  }
1277 
1278  index++;
1279  }
1280 
1281  if (ntargets > 0)
1282  CreateRandomTarget(region, sweep_loc);
1283 
1284  if (airborne && !airbase) {
1285  OrbitalInsertion(player_elem);
1286  region = player_elem->Region();
1287  }
1288 
1289  sweep_loc = base_loc;
1290  sweep_loc.y += 30.0e3;
1291 
1292  n = new(__FILE__,__LINE__) Instruction(region,
1293  sweep_loc,
1294  Instruction::VECTOR);
1295  if (n) {
1296  n->SetSpeed(750);
1297  player_elem->AddNavPoint(n);
1298  }
1299 
1300  Instruction* obj = new(__FILE__,__LINE__) Instruction(region,
1301  sweep_loc,
1302  Instruction::SWEEP);
1303  if (obj) {
1304  obj->SetTargetDesc("enemy patrols");
1305  player_elem->AddObjective(obj);
1306  }
1307 
1308  if (carrier_elem && !airborne) {
1309  obj = new(__FILE__,__LINE__) Instruction(Instruction::DEFEND, carrier_elem->Name());
1310  if (obj) {
1311  obj->SetTargetDesc(Text("the ") + carrier_elem->Name() + " battle group");
1312  player_elem->AddObjective(obj);
1313  }
1314  }
1315 }
1316 
1317 void
1318 CampaignMissionFighter::CreateTargetsIntercept()
1319 {
1320  if (!squadron || !player_elem) return;
1321 
1322  CombatUnit* carrier = FindCarrier(squadron);
1323  CombatGroup* s = FindSquadron(enemy, CombatGroup::ATTACK_SQUADRON);
1324  CombatGroup* s2 = FindSquadron(enemy, CombatGroup::FIGHTER_SQUADRON);
1325 
1326  if (!s || !s2) return;
1327 
1328  int ninbound = 2 + (int) (RandomIndex() < 5);
1329  bool second = ninbound > 2;
1330  Text attacker;
1331 
1332  while (ninbound--) {
1333  MissionElement* elem = CreateFighterPackage(s, 4, Mission::ASSAULT);
1334  if (elem) {
1335  elem->SetIntelLevel(Intel::KNOWN);
1336  elem->Loadouts().destroy();
1337  elem->Loadouts().append(new(__FILE__,__LINE__) MissionLoad(-1, "Hvy Ship Strike"));
1338 
1339  if (carrier) {
1340  Instruction* obj = new(__FILE__,__LINE__) Instruction(Instruction::ASSAULT, carrier->Name());
1341  if (obj) {
1342  elem->AddObjective(obj);
1343  elem->SetLocation(carrier->Location() + RandomPoint() * 6);
1344  }
1345  }
1346  else {
1347  elem->SetLocation(squadron->Location() + RandomPoint() * 5);
1348  }
1349 
1350  mission->AddElement(elem);
1351 
1352  attacker = elem->Name();
1353 
1354  if (!prime_target) {
1355  prime_target = elem;
1356  Instruction* obj = new(__FILE__,__LINE__) Instruction(Instruction::INTERCEPT, attacker);
1357  if (obj) {
1358  obj->SetTargetDesc(Text("inbound strike package '") + elem->Name() + "'");
1359  player_elem->AddObjective(obj);
1360  }
1361  }
1362 
1363  MissionElement* e2 = CreateFighterPackage(s2, 2, Mission::ESCORT);
1364  if (e2) {
1365  e2->SetIntelLevel(Intel::KNOWN);
1366  e2->SetLocation(elem->Location() + RandomPoint() * 0.25);
1367 
1368  Instruction* obj = new(__FILE__,__LINE__) Instruction(Instruction::ESCORT, elem->Name());
1369  if (obj)
1370  e2->AddObjective(obj);
1371  mission->AddElement(e2);
1372  }
1373  }
1374  }
1375 
1376  if (second) {
1377  // second friendly fighter package
1378  CombatGroup* s = FindSquadron(ownside, CombatGroup::FIGHTER_SQUADRON);
1379 
1380  if (s) {
1381  MissionElement* elem = CreateFighterPackage(s, 2, Mission::INTERCEPT);
1382  if (elem) {
1383  Player* p = Player::GetCurrentPlayer();
1384  elem->SetAlert(p ? !p->FlyingStart() : true);
1385 
1386  Instruction* obj = new(__FILE__,__LINE__) Instruction(Instruction::INTERCEPT, attacker);
1387  if (obj)
1388  elem->AddObjective(obj);
1389  mission->AddElement(elem);
1390  }
1391  }
1392  }
1393 
1394  if (carrier && !airborne) {
1395  Instruction* obj = new(__FILE__,__LINE__) Instruction(Instruction::DEFEND, carrier->Name());
1396  if (obj) {
1397  obj->SetTargetDesc(Text("the ") + carrier->Name() + " battle group");
1398  player_elem->AddObjective(obj);
1399  }
1400  }
1401 }
1402 
1403 void
1404 CampaignMissionFighter::CreateTargetsFreightEscort()
1405 {
1406  if (!squadron || !player_elem) return;
1407 
1408  if (!ward) {
1409  CreateTargetsPatrol();
1410  return;
1411  }
1412 
1413  CombatUnit* carrier = FindCarrier(squadron);
1414  CombatGroup* s = FindSquadron(enemy, CombatGroup::ATTACK_SQUADRON);
1415  CombatGroup* s2 = FindSquadron(enemy, CombatGroup::FIGHTER_SQUADRON);
1416 
1417  if (!s) s = s2;
1418 
1419  if (!s || !s2) return;
1420 
1421  MissionElement* elem = CreateFighterPackage(s, 2, Mission::ASSAULT);
1422  if (elem) {
1423  elem->SetIntelLevel(Intel::KNOWN);
1424 
1425  elem->SetLocation(ward->Location() + RandomPoint() * 5);
1426 
1427  Instruction* obj = new(__FILE__,__LINE__) Instruction(Instruction::ASSAULT, ward->Name());
1428  if (obj)
1429  elem->AddObjective(obj);
1430  mission->AddElement(elem);
1431 
1432  MissionElement* e2 = CreateFighterPackage(s2, 2, Mission::ESCORT);
1433  if (e2) {
1434  e2->SetIntelLevel(Intel::KNOWN);
1435  e2->SetLocation(elem->Location() + RandomPoint() * 0.25);
1436 
1437  Instruction* obj2 = new(__FILE__,__LINE__) Instruction(Instruction::ESCORT, elem->Name());
1438  if (obj2)
1439  e2->AddObjective(obj2);
1440  mission->AddElement(e2);
1441  }
1442  }
1443 
1444  Instruction* obj3 = new(__FILE__,__LINE__) Instruction(mission->GetRegion(),
1445  Point(0,0,0),
1446  Instruction::PATROL);
1447 
1448  if (obj3) {
1449  obj3->SetTargetDesc("enemy patrols");
1450  player_elem->AddObjective(obj3);
1451  }
1452 }
1453 
1454 void
1455 CampaignMissionFighter::CreateTargetsShuttleEscort()
1456 {
1457  CreateTargetsFreightEscort();
1458 }
1459 
1460 // +--------------------------------------------------------------------+
1461 
1462 void
1463 CampaignMissionFighter::CreateTargetsStrikeEscort()
1464 {
1465  if (!squadron || !player_elem) return;
1466 
1467  if (ward) {
1468  Point offset = Point(2.0e3, 2.0e3, 1.0e3);
1469 
1470  ListIter<Instruction> npt_iter = ward->NavList();
1471  while (++npt_iter) {
1472  Instruction* npt = npt_iter.value();
1473  Instruction* n = new(__FILE__,__LINE__) Instruction(npt->RegionName(),
1474  npt->Location() + offset,
1475  Instruction::ESCORT);
1476  if (n) {
1477  n->SetSpeed(npt->Speed());
1478  player_elem->AddNavPoint(n);
1479  }
1480  }
1481  }
1482 }
1483 
1484 // +--------------------------------------------------------------------+
1485 
1486 void
1487 CampaignMissionFighter::CreateTargetsStrike()
1488 {
1489  if (!squadron || !player_elem) return;
1490 
1491  if (request && request->GetObjective())
1492  strike_target = request->GetObjective();
1493 
1494  if (strike_target && strike_group) {
1495  CreateElements(strike_target);
1496 
1497  ListIter<MissionElement> e_iter = mission->GetElements();
1498  while (++e_iter) {
1499  MissionElement* elem = e_iter.value();
1500 
1501  if (elem->GetCombatGroup() == strike_target) {
1502  prime_target = elem;
1503  Instruction* obj = new(__FILE__,__LINE__) Instruction(Instruction::STRIKE, elem->Name());
1504  if (obj) {
1505  obj->SetTargetDesc(Text("preplanned target '") + elem->Name() + "'");
1506  player_elem->AddObjective(obj);
1507  }
1508 
1509  // create flight plan:
1510  RLoc rloc;
1511  Point loc = Point(0, 0, 15e3);
1512  Instruction* n = 0;
1513 
1514  PlanetaryInsertion(player_elem);
1515 
1516  // target approach and strike:
1517  Point delta = prime_target->Location() - loc;
1518 
1519  if (delta.length() >= 100e3) {
1520  Point mid = loc + delta * 0.5;
1521  mid.z = 10.0e3;
1522 
1523  rloc.SetReferenceLoc(0);
1524  rloc.SetBaseLocation(mid);
1525  rloc.SetDistance(20e3);
1526  rloc.SetDistanceVar(5e3);
1527  rloc.SetAzimuth(90*DEGREES);
1528  rloc.SetAzimuthVar(25*DEGREES);
1529 
1530  n = new(__FILE__,__LINE__) Instruction(prime_target->Region(),
1531  Point(),
1532  Instruction::VECTOR);
1533  if (n) {
1534  n->SetSpeed(750);
1535  n->GetRLoc() = rloc;
1536  player_elem->AddNavPoint(n);
1537  }
1538 
1539  loc = mid;
1540  }
1541 
1542  delta = loc - prime_target->Location();
1543  delta.Normalize();
1544  delta *= 25.0e3;
1545 
1546  loc = prime_target->Location() + delta;
1547  loc.z = 8.0e3;
1548 
1549  n = new(__FILE__,__LINE__) Instruction(prime_target->Region(),
1550  loc,
1551  Instruction::STRIKE);
1552  if (n) {
1553  n->SetSpeed(500);
1554  player_elem->AddNavPoint(n);
1555  }
1556 
1557  // exeunt:
1558  rloc.SetReferenceLoc(0);
1559  rloc.SetBaseLocation(Point(0, 0, 30.0e3));
1560  rloc.SetDistance(50e3);
1561  rloc.SetDistanceVar(5e3);
1562  rloc.SetAzimuth(-90*DEGREES);
1563  rloc.SetAzimuthVar(25*DEGREES);
1564 
1565  n = new(__FILE__,__LINE__) Instruction(prime_target->Region(),
1566  Point(),
1567  Instruction::VECTOR);
1568  if (n) {
1569  n->SetSpeed(750);
1570  n->GetRLoc() = rloc;
1571  player_elem->AddNavPoint(n);
1572  }
1573 
1574  if (carrier_elem) {
1575  rloc.SetReferenceLoc(0);
1576  rloc.SetBaseLocation(carrier_elem->Location());
1577  rloc.SetDistance(60e3);
1578  rloc.SetDistanceVar(10e3);
1579  rloc.SetAzimuth(180*DEGREES);
1580  rloc.SetAzimuthVar(30*DEGREES);
1581 
1582  n = new(__FILE__,__LINE__) Instruction(carrier_elem->Region(),
1583  Point(),
1584  Instruction::RTB);
1585  if (n) {
1586  n->SetSpeed(750);
1587  n->GetRLoc() = rloc;
1588  player_elem->AddNavPoint(n);
1589  }
1590  }
1591 
1592  break;
1593  }
1594  }
1595  }
1596 }
1597 
1598 // +--------------------------------------------------------------------+
1599 
1600 void
1601 CampaignMissionFighter::CreateTargetsAssault()
1602 {
1603  if (!squadron || !player_elem) return;
1604 
1605  CombatGroup* assigned = 0;
1606 
1607  if (request)
1608  assigned = request->GetObjective();
1609 
1610  if (assigned) {
1611  if (assigned->Type() > CombatGroup::WING && assigned->Type() < CombatGroup::FLEET) {
1612  mission->AddElement(CreateFighterPackage(assigned, 2, Mission::CARGO));
1613  }
1614  else {
1615  CreateElements(assigned);
1616  }
1617 
1618  // select the prime target element - choose the lowest ranking
1619  // unit of a DESRON, CBG, or CVBG:
1620 
1621  ListIter<MissionElement> e_iter = mission->GetElements();
1622  while (++e_iter) {
1623  MissionElement* elem = e_iter.value();
1624 
1625  if (elem->GetCombatGroup() == assigned) {
1626  if (!prime_target || assigned->Type() <= CombatGroup::CARRIER_GROUP) {
1627  prime_target = elem;
1628  }
1629  }
1630  }
1631 
1632  if (prime_target) {
1633  MissionElement* elem = prime_target;
1634 
1635  Instruction* obj = new(__FILE__,__LINE__) Instruction(Instruction::ASSAULT, elem->Name());
1636  if (obj) {
1637  obj->SetTargetDesc(Text("preplanned target '") + elem->Name() + "'");
1638  player_elem->AddObjective(obj);
1639  }
1640 
1641  // create flight plan:
1642  RLoc rloc;
1643  Vec3 dummy(0,0,0);
1644  Instruction* instr = 0;
1645  Point loc = player_elem->Location();
1646  Point tgt = elem->Location();
1647  Point mid;
1648 
1649  CombatGroup* tgt_group = elem->GetCombatGroup();
1650  if (tgt_group && tgt_group->GetFirstUnit() && tgt_group->IsMovable()) {
1651  tgt = tgt_group->GetFirstUnit()->Location();
1652  }
1653 
1654  if (carrier_elem)
1655  loc = carrier_elem->Location();
1656 
1657  mid = loc + (elem->Location() - loc) * 0.5;
1658 
1659  rloc.SetReferenceLoc(0);
1660  rloc.SetBaseLocation(mid);
1661  rloc.SetDistance(40e3);
1662  rloc.SetDistanceVar(5e3);
1663  rloc.SetAzimuth(90*DEGREES);
1664  rloc.SetAzimuthVar(45*DEGREES);
1665 
1666  instr = new(__FILE__,__LINE__) Instruction(elem->Region(), dummy, Instruction::VECTOR);
1667  if (instr) {
1668  instr->SetSpeed(750);
1669  instr->GetRLoc() = rloc;
1670 
1671  player_elem->AddNavPoint(instr);
1672 
1673  if (RandomChance()) {
1674  CreateRandomTarget(elem->Region(), rloc.Location());
1675  }
1676  }
1677 
1678  rloc.SetReferenceLoc(0);
1679  rloc.SetBaseLocation(tgt);
1680  rloc.SetDistance(60e3);
1681  rloc.SetDistanceVar(5e3);
1682  rloc.SetAzimuth(120*DEGREES);
1683  rloc.SetAzimuthVar(15*DEGREES);
1684 
1685  instr = new(__FILE__,__LINE__) Instruction(elem->Region(), dummy, Instruction::ASSAULT);
1686  if (instr) {
1687  instr->SetSpeed(750);
1688  instr->GetRLoc() = rloc;
1689  instr->SetTarget(elem->Name());
1690 
1691  player_elem->AddNavPoint(instr);
1692  }
1693 
1694  if (carrier_elem) {
1695  rloc.SetReferenceLoc(0);
1696  rloc.SetBaseLocation(loc);
1697  rloc.SetDistance(30e3);
1698  rloc.SetDistanceVar(0);
1699  rloc.SetAzimuth(180*DEGREES);
1700  rloc.SetAzimuthVar(60*DEGREES);
1701 
1702  instr = new(__FILE__,__LINE__) Instruction(carrier_elem->Region(), dummy, Instruction::RTB);
1703  if (instr) {
1704  instr->SetSpeed(500);
1705  instr->GetRLoc() = rloc;
1706 
1707  player_elem->AddNavPoint(instr);
1708  }
1709  }
1710  }
1711  }
1712 }
1713 
1714 // +--------------------------------------------------------------------+
1715 
1716 int
1717 CampaignMissionFighter::CreateRandomTarget(const char* rgn, Point base_loc)
1718 {
1719  if (!mission) return 0;
1720 
1721  int ntargets = 0;
1722  int ttype = RandomIndex();
1723  bool oca = (mission->Type() == Mission::SWEEP);
1724 
1725  if (ttype < 8) {
1726  CombatGroup* s = 0;
1727 
1728  if (ttype < 4)
1729  s = FindSquadron(enemy, CombatGroup::INTERCEPT_SQUADRON);
1730  else
1731  s = FindSquadron(enemy, CombatGroup::FIGHTER_SQUADRON);
1732 
1733  if (s) {
1734  MissionElement* elem = CreateFighterPackage(s, 2, Mission::SWEEP);
1735  if (elem) {
1736  elem->SetIntelLevel(Intel::KNOWN);
1737  elem->SetRegion(rgn);
1738  elem->SetLocation(base_loc + RandomPoint() * 1.5);
1739  mission->AddElement(elem);
1740  ntargets++;
1741  }
1742  }
1743  }
1744  else if (ttype < 12) {
1745  if (oca) {
1746  CombatGroup* s = FindSquadron(enemy, CombatGroup::LCA_SQUADRON);
1747 
1748  if (s) {
1749  MissionElement* elem = CreateFighterPackage(s, 1, Mission::CARGO);
1750  if (elem) {
1751  elem->SetIntelLevel(Intel::KNOWN);
1752  elem->SetRegion(rgn);
1753  elem->SetLocation(base_loc + RandomPoint() * 2);
1754  mission->AddElement(elem);
1755  ntargets++;
1756 
1757  CombatGroup* s2 = FindSquadron(enemy, CombatGroup::FIGHTER_SQUADRON);
1758 
1759  if (s2) {
1760  MissionElement* e2 = CreateFighterPackage(s2, 2, Mission::ESCORT);
1761  if (e2) {
1762  e2->SetIntelLevel(Intel::KNOWN);
1763  e2->SetRegion(rgn);
1764  e2->SetLocation(elem->Location() + RandomPoint() * 0.5);
1765 
1766  Instruction* obj = new(__FILE__,__LINE__) Instruction(Instruction::ESCORT, elem->Name());
1767  if (obj)
1768  e2->AddObjective(obj);
1769  mission->AddElement(e2);
1770  ntargets++;
1771  }
1772  }
1773  }
1774  }
1775  }
1776  else {
1777  CombatGroup* s = FindSquadron(enemy, CombatGroup::ATTACK_SQUADRON);
1778 
1779  if (s) {
1780  MissionElement* elem = CreateFighterPackage(s, 2, Mission::ASSAULT);
1781  if (elem) {
1782  elem->SetIntelLevel(Intel::KNOWN);
1783  elem->SetRegion(rgn);
1784  elem->SetLocation(base_loc + RandomPoint() * 1.3);
1785  mission->AddElement(elem);
1786  ntargets++;
1787  }
1788  }
1789  }
1790  }
1791  else if (ttype < 15) {
1792  if (oca) {
1793  CombatGroup* s = 0;
1794 
1795  if (airborne)
1796  s = FindSquadron(enemy, CombatGroup::LCA_SQUADRON);
1797  else
1798  s = FindSquadron(enemy, CombatGroup::FREIGHT);
1799 
1800  if (s) {
1801  MissionElement* elem = CreateFighterPackage(s, 1, Mission::CARGO);
1802  if (elem) {
1803  elem->SetIntelLevel(Intel::KNOWN);
1804  elem->SetRegion(rgn);
1805  elem->SetLocation(base_loc + RandomPoint() * 2);
1806  mission->AddElement(elem);
1807  ntargets++;
1808 
1809  CombatGroup* s2 = FindSquadron(enemy, CombatGroup::INTERCEPT_SQUADRON);
1810 
1811  if (s2) {
1812  MissionElement* e2 = CreateFighterPackage(s2, 2, Mission::ESCORT);
1813  if (e2) {
1814  e2->SetIntelLevel(Intel::KNOWN);
1815  e2->SetRegion(rgn);
1816  e2->SetLocation(elem->Location() + RandomPoint() * 0.5);
1817 
1818  Instruction* obj = new(__FILE__,__LINE__) Instruction(Instruction::ESCORT, elem->Name());
1819  if (obj)
1820  e2->AddObjective(obj);
1821  mission->AddElement(e2);
1822  ntargets++;
1823  }
1824  }
1825  }
1826  }
1827  }
1828  else {
1829  CombatGroup* s = FindSquadron(enemy, CombatGroup::ATTACK_SQUADRON);
1830 
1831  if (s) {
1832  MissionElement* elem = CreateFighterPackage(s, 2, Mission::ASSAULT);
1833  if (elem) {
1834  elem->SetIntelLevel(Intel::KNOWN);
1835  elem->SetRegion(rgn);
1836  elem->SetLocation(base_loc + RandomPoint() * 1.1);
1837  mission->AddElement(elem);
1838  ntargets++;
1839 
1840  CombatGroup* s2 = FindSquadron(enemy, CombatGroup::FIGHTER_SQUADRON);
1841 
1842  if (s2) {
1843  MissionElement* e2 = CreateFighterPackage(s2, 2, Mission::ESCORT);
1844  if (e2) {
1845  e2->SetIntelLevel(Intel::KNOWN);
1846  e2->SetRegion(rgn);
1847  e2->SetLocation(elem->Location() + RandomPoint() * 0.5);
1848 
1849  Instruction* obj = new(__FILE__,__LINE__) Instruction(Instruction::ESCORT, elem->Name());
1850  if (obj)
1851  e2->AddObjective(obj);
1852  mission->AddElement(e2);
1853  ntargets++;
1854  }
1855  }
1856  }
1857  }
1858  }
1859  }
1860  else {
1861  CombatGroup* s = FindSquadron(enemy, CombatGroup::LCA_SQUADRON);
1862 
1863  if (s) {
1864  MissionElement* elem = CreateFighterPackage(s, 2, Mission::CARGO);
1865  if (elem) {
1866  elem->SetIntelLevel(Intel::KNOWN);
1867  elem->SetRegion(rgn);
1868  elem->SetLocation(base_loc + RandomPoint() * 2);
1869  mission->AddElement(elem);
1870  ntargets++;
1871  }
1872  }
1873  }
1874 
1875  return ntargets;
1876 }
1877 
1878 // +--------------------------------------------------------------------+
1879 
1880 void
1881 CampaignMissionFighter::PlanetaryInsertion(MissionElement* elem)
1882 {
1883  if (!mission || !elem) return;
1884  if (!mission->GetStarSystem()) return;
1885 
1886  MissionElement* carrier = mission->FindElement(elem->Commander());
1887  StarSystem* system = mission->GetStarSystem();
1888  OrbitalRegion* rgn1 = system->FindRegion(elem->Region());
1889  OrbitalRegion* rgn2 = system->FindRegion(air_region);
1890  Point npt_loc = elem->Location();
1891  Instruction* n = 0;
1892  Player* p = Player::GetCurrentPlayer();
1893 
1894  int flying_start = p ? p->FlyingStart() : 0;
1895 
1896  if (carrier && !flying_start) {
1897  npt_loc = carrier->Location() + Point(1e3, -5e3, 0);
1898  }
1899 
1900  if (rgn1 && rgn2) {
1901  double delta_t = mission->Start() - campaign->GetTime();
1902  Point r1 = rgn1->PredictLocation(delta_t);
1903  Point r2 = rgn2->PredictLocation(delta_t);
1904 
1905  Point delta = r2 - r1;
1906 
1907  delta.y *= -1;
1908  delta.Normalize();
1909  delta *= 10e3;
1910 
1911  npt_loc += delta;
1912 
1913  n = new(__FILE__,__LINE__) Instruction(elem->Region(),
1914  npt_loc,
1915  Instruction::VECTOR);
1916  if (n) {
1917  n->SetSpeed(750);
1918  elem->AddNavPoint(n);
1919  }
1920  }
1921 
1922  n = new(__FILE__,__LINE__) Instruction(air_region,
1923  Point(0, 0, 15e3),
1924  Instruction::VECTOR);
1925  if (n) {
1926  n->SetSpeed(750);
1927  elem->AddNavPoint(n);
1928  }
1929 }
1930 
1931 void
1932 CampaignMissionFighter::OrbitalInsertion(MissionElement* elem)
1933 {
1934  Instruction* n = new(__FILE__,__LINE__) Instruction(air_region,
1935  Point(0, 0, 30.0e3),
1936  Instruction::VECTOR);
1937  if (n) {
1938  n->SetSpeed(750);
1939  elem->AddNavPoint(n);
1940  }
1941 }
1942 
1943 // +--------------------------------------------------------------------+
1944 
1945 MissionElement*
1946 CampaignMissionFighter::CreateFighterPackage(CombatGroup* squadron, int count, int role)
1947 {
1948  if (!squadron) return 0;
1949 
1950  CombatUnit* fighter = squadron->GetUnits().at(0);
1951  CombatUnit* carrier = FindCarrier(squadron);
1952 
1953  if (!fighter)
1954  return 0;
1955 
1956  int avail = fighter->LiveCount();
1957  int actual = count;
1958 
1959  if (avail < actual)
1960  actual = avail;
1961 
1962  if (avail < 1) {
1963  ::Print("CMF - Insufficient fighters in squadron '%s' - %d required, %d available\n",
1964  squadron->Name().data(), count, avail);
1965  return 0;
1966  }
1967 
1968  MissionElement* elem = new(__FILE__,__LINE__) MissionElement;
1969  if (!elem) {
1970  Exit();
1971  return 0;
1972  }
1973 
1974  elem->SetName(Callsign::GetCallsign(fighter->GetIFF()));
1975  elem->SetElementID(pkg_id++);
1976 
1977  if (carrier) {
1978  elem->SetCommander(carrier->Name());
1979  elem->SetHeading(carrier->GetHeading());
1980  }
1981  else {
1982  elem->SetHeading(fighter->GetHeading());
1983  }
1984 
1985  elem->SetDesign(fighter->GetDesign());
1986  elem->SetCount(actual);
1987  elem->SetIFF(fighter->GetIFF());
1988  elem->SetIntelLevel(squadron->IntelLevel());
1989  elem->SetRegion(fighter->GetRegion());
1990  elem->SetSquadron(squadron->Name());
1991  elem->SetMissionRole(role);
1992 
1993  switch (role) {
1994  case Mission::ASSAULT:
1995  if (request->GetObjective() &&
1996  request->GetObjective()->Type() == CombatGroup::MINEFIELD)
1997  elem->Loadouts().append(new(__FILE__,__LINE__) MissionLoad(-1, "Rockets"));
1998  else
1999  elem->Loadouts().append(new(__FILE__,__LINE__) MissionLoad(-1, "Ship Strike"));
2000  break;
2001 
2002  case Mission::STRIKE:
2003  elem->Loadouts().append(new(__FILE__,__LINE__) MissionLoad(-1, "Ground Strike"));
2004  break;
2005 
2006  default:
2007  elem->Loadouts().append(new(__FILE__,__LINE__) MissionLoad(-1, "ACM Medium Range"));
2008  break;
2009  }
2010 
2011  if (carrier) {
2012  Point offset = RandomPoint() * 0.3;
2013  offset.y = fabs(offset.y);
2014  offset.z += 2e3;
2015  elem->SetLocation(carrier->Location() + offset);
2016  }
2017  else {
2018  elem->SetLocation(fighter->Location() + RandomPoint());
2019  }
2020 
2021  elem->SetCombatGroup(squadron);
2022  elem->SetCombatUnit(fighter);
2023 
2024  return elem;
2025 }
2026 
2027 // +--------------------------------------------------------------------+
2028 
2029 static CombatGroup* FindCombatGroup(CombatGroup* g, int type)
2030 {
2031  if (g->IntelLevel() <= Intel::RESERVE)
2032  return 0;
2033 
2034  if (g->GetUnits().size() > 0) {
2035  for (int i = 0; i < g->GetUnits().size(); i++) {
2036  CombatUnit* u = g->GetUnits().at(i);
2037  if (g->Type() == type && u->LiveCount() > 0)
2038  return g;
2039  }
2040  }
2041 
2042  CombatGroup* result = 0;
2043 
2044  ListIter<CombatGroup> subgroup = g->GetComponents();
2045  while (++subgroup && !result)
2046  result = FindCombatGroup(subgroup.value(), type);
2047 
2048  return result;
2049 }
2050 
2051 // +--------------------------------------------------------------------+
2052 
2053 CombatGroup*
2054 CampaignMissionFighter::FindSquadron(int iff, int type)
2055 {
2056  if (!squadron) return 0;
2057 
2058  CombatGroup* result = 0;
2059  Campaign* campaign = Campaign::GetCampaign();
2060 
2061  if (campaign) {
2062  ListIter<Combatant> combatant = campaign->GetCombatants();
2063  while (++combatant && !result) {
2064  if (combatant->GetIFF() == iff) {
2065  result = ::FindCombatGroup(combatant->GetForce(), type);
2066 
2067  if (result && result->CountUnits() < 1) {
2068  result = 0;
2069  }
2070  }
2071  }
2072  }
2073 
2074  return result;
2075 }
2076 
2077 // +--------------------------------------------------------------------+
2078 
2079 void
2080 CampaignMissionFighter::DefineMissionObjectives()
2081 {
2082  if (!mission || !player_elem) return;
2083 
2084  if (prime_target) mission->SetTarget(prime_target);
2085  if (ward) mission->SetWard(ward);
2086 
2087  Text objectives;
2088 
2089  for (int i = 0; i < player_elem->Objectives().size(); i++) {
2090  Instruction* obj = player_elem->Objectives().at(i);
2091  objectives += "* ";
2092  objectives += obj->GetDescription();
2093  objectives += ".\n";
2094  }
2095 
2096  mission->SetObjective(objectives);
2097 }
2098 
2099 // +--------------------------------------------------------------------+
2100 
2101 MissionInfo*
2102 CampaignMissionFighter::DescribeMission()
2103 {
2104  if (!mission || !player_elem) return 0;
2105 
2106  char name[256];
2107  char player_info[256];
2108 
2109  if (mission_info && mission_info->name.length())
2110  sprintf_s(name, "MSN-%03d %s", mission->Identity(), mission_info->name.data());
2111  else if (ward)
2112  sprintf_s(name, "MSN-%03d %s %s", mission->Identity(), Game::GetText(mission->TypeName()).data(), ward->Name().data());
2113  else if (prime_target)
2114  sprintf_s(name, "MSN-%03d %s %s %s", mission->Identity(), Game::GetText(mission->TypeName()).data(),
2115  Ship::ClassName(prime_target->GetDesign()->type),
2116  prime_target->Name().data());
2117  else
2118  sprintf_s(name, "MSN-%03d %s", mission->Identity(), Game::GetText(mission->TypeName()).data());
2119 
2120  if (player_elem) {
2121  sprintf_s(player_info, "%d x %s %s '%s'",
2122  player_elem->Count(),
2123  (const char*) player_elem->GetDesign()->abrv,
2124  (const char*) player_elem->GetDesign()->name,
2125  (const char*) player_elem->Name());
2126  }
2127 
2128  MissionInfo* info = new(__FILE__,__LINE__) MissionInfo;
2129 
2130  info->id = mission->Identity();
2131  info->mission = mission;
2132  info->name = name;
2133  info->type = mission->Type();
2134  info->player_info = player_info;
2135  info->description = mission->Objective();
2136  info->start = mission->Start();
2137 
2138  if (mission->GetStarSystem())
2139  info->system = mission->GetStarSystem()->Name();
2140  info->region = mission->GetRegion();
2141 
2142  mission->SetName(name);
2143 
2144  return info;
2145 }
2146 
2147 // +--------------------------------------------------------------------+
2148 
2149 void
2150 CampaignMissionFighter::Exit()
2151 {
2152  Starshatter* stars = Starshatter::GetInstance();
2153  if (stars)
2154  stars->SetGameMode(Starshatter::MENU_MODE);
2155 }