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/_campaign_8cpp_source.html | 2463 +++++++++++++++++++++++++++ 1 file changed, 2463 insertions(+) create mode 100644 Doc/doxygen/html/_campaign_8cpp_source.html (limited to 'Doc/doxygen/html/_campaign_8cpp_source.html') diff --git a/Doc/doxygen/html/_campaign_8cpp_source.html b/Doc/doxygen/html/_campaign_8cpp_source.html new file mode 100644 index 0000000..436768d --- /dev/null +++ b/Doc/doxygen/html/_campaign_8cpp_source.html @@ -0,0 +1,2463 @@ + + + + + +Starshatter_Open: D:/SRC/StarshatterSVN/Stars45/Campaign.cpp Source File + + + + + + + + + + + + + +
+
+ + + + + + +
+
Starshatter_Open +
+
Open source Starshatter engine
+
+
+ + + + + +
+
+ +
+
+
+ +
+ + + + +
+ +
+ +
+
+
Campaign.cpp
+
+
+Go to the documentation of this file.
1 /* Project Starshatter 4.5
+
2  Destroyer Studios LLC
+
3  Copyright (C) 1997-2006. All Rights Reserved.
+
4 
+
5  SUBSYSTEM: Stars.exe
+
6  FILE: Campaign.cpp
+
7  AUTHOR: John DiCamillo
+
8 
+
9 
+
10  OVERVIEW
+
11  ========
+
12  Campaign defines a strategic military scenario.
+
13 */
+
14 
+
15 #include "MemDebug.h"
+
16 #include "Campaign.h"
+
17 #include "CampaignPlanStrategic.h"
+
18 #include "CampaignPlanAssignment.h"
+
19 #include "CampaignPlanEvent.h"
+
20 #include "CampaignPlanMission.h"
+
21 #include "CampaignPlanMovement.h"
+
22 #include "CampaignSituationReport.h"
+
23 #include "CampaignSaveGame.h"
+
24 #include "Combatant.h"
+
25 #include "CombatAction.h"
+
26 #include "CombatEvent.h"
+
27 #include "CombatGroup.h"
+
28 #include "CombatRoster.h"
+
29 #include "CombatUnit.h"
+
30 #include "CombatZone.h"
+
31 #include "Galaxy.h"
+
32 #include "Mission.h"
+
33 #include "StarSystem.h"
+
34 #include "Starshatter.h"
+
35 #include "Player.h"
+
36 
+
37 #include "Game.h"
+
38 #include "Bitmap.h"
+
39 #include "DataLoader.h"
+
40 #include "ParseUtil.h"
+
41 #include "Random.h"
+
42 #include "FormatUtil.h"
+
43 
+
44 
+
45 const int TIME_NEVER = (int) 1e9;
+
46 const int ONE_DAY = (int) 24 * 3600;
+
47 
+
48 // +====================================================================+
+
49 
+
50 MissionInfo::MissionInfo()
+
51 : mission(0), start(0), type(0), id(0), min_rank(0), max_rank(0),
+
52 action_id(0), action_status(0), exec_once(0),
+
53 start_before(TIME_NEVER), start_after(0)
+
54 { }
+
55 
+
56 MissionInfo::~MissionInfo()
+
57 {
+
58  delete mission;
+
59 }
+
60 
+
61 bool
+
62 MissionInfo::IsAvailable()
+
63 {
+
64  Campaign* campaign = Campaign::GetCampaign();
+
65  Player* player = Player::GetCurrentPlayer();
+
66  CombatGroup* player_group = campaign->GetPlayerGroup();
+
67 
+
68  if (campaign->GetTime() < start_after)
+
69  return false;
+
70 
+
71  if (campaign->GetTime() > start_before)
+
72  return false;
+
73 
+
74  if (region.length() && player_group->GetRegion() != region)
+
75  return false;
+
76 
+
77  if (min_rank && player->Rank() < min_rank)
+
78  return false;
+
79 
+
80  if (max_rank && player->Rank() > max_rank)
+
81  return false;
+
82 
+
83  if (exec_once < 0)
+
84  return false;
+
85 
+
86  if (exec_once > 0)
+
87  exec_once = -1;
+
88 
+
89  return true;
+
90 }
+
91 
+
92 // +====================================================================+
+
93 
+
94 TemplateList::TemplateList()
+
95 : mission_type(0), group_type(0), index(0)
+
96 { }
+
97 
+
98 TemplateList::~TemplateList()
+
99 {
+
100  missions.destroy();
+
101 }
+
102 
+
103 // +====================================================================+
+
104 
+
105 static List<Campaign> campaigns;
+
106 static Campaign* current_campaign = 0;
+
107 
+
108 // +--------------------------------------------------------------------+
+
109 
+
110 Campaign::Campaign(int id, const char* n)
+
111 : campaign_id(id), name(n), mission_id(-1), mission(0), net_mission(0),
+
112 scripted(false), sequential(false), time(0), startTime(0), loadTime(0),
+
113 player_group(0), player_unit(0), status(CAMPAIGN_INIT), lockout(0),
+
114 loaded_from_savegame(false)
+
115 {
+
116  ZeroMemory(path, sizeof(path));
+
117  Load();
+
118 }
+
119 
+
120 Campaign::Campaign(int id, const char* n, const char* p)
+
121 : campaign_id(id), name(n), mission_id(-1), mission(0), net_mission(0),
+
122 scripted(false), sequential(false), time(0), startTime(0), loadTime(0),
+
123 player_group(0), player_unit(0), status(CAMPAIGN_INIT), lockout(0),
+
124 loaded_from_savegame(false)
+
125 {
+
126  ZeroMemory(path, sizeof(path));
+
127  strncpy(path, p, sizeof(path));
+
128  Load();
+
129 }
+
130 
+
131 // +--------------------------------------------------------------------+
+
132 
+
133 Campaign::~Campaign()
+
134 {
+
135  for (int i = 0; i < NUM_IMAGES; i++)
+
136  image[i].ClearImage();
+
137 
+
138  delete net_mission;
+
139 
+
140  actions.destroy();
+
141  events.destroy();
+
142  missions.destroy();
+
143  templates.destroy();
+
144  planners.destroy();
+
145  zones.destroy();
+
146  combatants.destroy();
+
147 }
+
148 
+
149 // +--------------------------------------------------------------------+
+
150 
+
151 void
+
152 Campaign::Initialize()
+
153 {
+
154  Campaign* c = 0;
+
155  DataLoader* loader = DataLoader::GetLoader();
+
156 
+
157  for (int i = 1; i < 100; i++) {
+
158  char path[256];
+
159  sprintf_s(path, "Campaigns/%02d/", i);
+
160 
+
161  loader->UseFileSystem(true);
+
162  loader->SetDataPath(path);
+
163 
+
164  if (loader->FindFile("campaign.def")) {
+
165  char txt[256];
+
166  sprintf_s(txt, "Dynamic Campaign %02d", i);
+
167  c = new(__FILE__,__LINE__) Campaign(i, txt);
+
168 
+
169  if (c) {
+
170  campaigns.insertSort(c);
+
171  }
+
172  }
+
173  }
+
174 
+
175  c = new(__FILE__,__LINE__) Campaign(SINGLE_MISSIONS, "Single Missions");
+
176  if (c) {
+
177  campaigns.insertSort(c);
+
178  current_campaign = c;
+
179  }
+
180 
+
181  c = new(__FILE__,__LINE__) Campaign(MULTIPLAYER_MISSIONS, "Multiplayer Missions");
+
182  if (c) {
+
183  campaigns.insertSort(c);
+
184  }
+
185 
+
186  c = new(__FILE__,__LINE__) Campaign(CUSTOM_MISSIONS, "Custom Missions");
+
187  if (c) {
+
188  campaigns.insertSort(c);
+
189  }
+
190 }
+
191 
+
192 void
+
193 Campaign::Close()
+
194 {
+
195  Print("Campaign::Close() - destroying all campaigns\n");
+
196  current_campaign = 0;
+
197  campaigns.destroy();
+
198 }
+
199 
+
200 Campaign*
+
201 Campaign::GetCampaign()
+
202 {
+
203  return current_campaign;
+
204 }
+
205 
+
206 Campaign*
+
207 Campaign::SelectCampaign(const char* name)
+
208 {
+
209  Campaign* c = 0;
+
210  ListIter<Campaign> iter = campaigns;
+
211 
+
212  while (++iter && !c) {
+
213  if (!_stricmp(iter->Name(), name))
+
214  c = iter.value();
+
215  }
+
216 
+
217  if (c) {
+
218  Print("Campaign: Selected '%s'\n", c->Name());
+
219  current_campaign = c;
+
220  }
+
221  else {
+
222  Print("Campaign: could not find '%s'\n", name);
+
223  }
+
224 
+
225  return c;
+
226 }
+
227 
+
228 Campaign*
+
229 Campaign::CreateCustomCampaign(const char* name, const char* path)
+
230 {
+
231  int id = 0;
+
232 
+
233  if (name && *name && path && *path) {
+
234  ListIter<Campaign> iter = campaigns;
+
235 
+
236  while (++iter) {
+
237  Campaign* c = iter.value();
+
238  if (c->GetCampaignId() >= id)
+
239  id = c->GetCampaignId() + 1;
+
240 
+
241  if (!strcmp(c->Name(), name)) {
+
242  Print("Campaign: custom campaign '%s' already exists.\n", name);
+
243  return 0;
+
244  }
+
245  }
+
246  }
+
247 
+
248  if (id == 0)
+
249  id = CUSTOM_MISSIONS + 1;
+
250 
+
251  Campaign* c = new(__FILE__,__LINE__) Campaign(id, name, path);
+
252  Print("Campaign: created custom campaign %d '%s'\n", id, name);
+
253  campaigns.append(c);
+
254 
+
255  return c;
+
256 }
+
257 
+
258 List<Campaign>&
+
259 Campaign::GetAllCampaigns()
+
260 {
+
261  return campaigns;
+
262 }
+
263 
+
264 int
+
265 Campaign::GetLastCampaignId()
+
266 {
+
267  int result = 0;
+
268 
+
269  for (int i = 0; i < campaigns.size(); i++) {
+
270  Campaign* c = campaigns.at(i);
+
271 
+
272  if (c->IsDynamic() && c->GetCampaignId() > result) {
+
273  result = c->GetCampaignId();
+
274  }
+
275  }
+
276 
+
277  return result;
+
278 }
+
279 
+
280 // +--------------------------------------------------------------------+
+
281 
+
282 CombatEvent*
+
283 Campaign::GetLastEvent()
+
284 {
+
285  CombatEvent* result = 0;
+
286 
+
287  if (!events.isEmpty())
+
288  result = events.last();
+
289 
+
290  return result;
+
291 }
+
292 
+
293 // +--------------------------------------------------------------------+
+
294 
+
295 int
+
296 Campaign::CountNewEvents() const
+
297 {
+
298  int result = 0;
+
299 
+
300  for (int i = 0; i < events.size(); i++)
+
301  if (/*events[i]->Source() != CombatEvent::TACNET &&*/ !events[i]->Visited())
+
302  result++;
+
303 
+
304  return result;
+
305 }
+
306 
+
307 // +--------------------------------------------------------------------+
+
308 
+
309 void
+
310 Campaign::Clear()
+
311 {
+
312  missions.destroy();
+
313  planners.destroy();
+
314  combatants.destroy();
+
315  events.destroy();
+
316  actions.destroy();
+
317 
+
318  player_group = 0;
+
319  player_unit = 0;
+
320 
+
321  updateTime = time;
+
322 }
+
323 
+
324 // +--------------------------------------------------------------------+
+
325 
+
326 void
+
327 Campaign::Load()
+
328 {
+
329  // first, unload any existing data:
+
330  Unload();
+
331 
+
332  if (!path[0]) {
+
333  // then load the campaign from files:
+
334  switch (campaign_id) {
+
335  case SINGLE_MISSIONS: strcpy_s(path, "Missions/"); break;
+
336  case CUSTOM_MISSIONS: strcpy_s(path, "Mods/Missions/"); break;
+
337  case MULTIPLAYER_MISSIONS: strcpy_s(path, "Multiplayer/"); break;
+
338  default: sprintf_s(path, "Campaigns/%02d/", campaign_id); break;
+
339  }
+
340  }
+
341 
+
342  DataLoader* loader = DataLoader::GetLoader();
+
343  loader->UseFileSystem(true);
+
344  loader->SetDataPath(path);
+
345  systems.clear();
+
346 
+
347  if (loader->FindFile("zones.def"))
+
348  zones.append(CombatZone::Load("zones.def"));
+
349 
+
350  for (int i = 0; i < zones.size(); i++) {
+
351  Text s = zones[i]->System();
+
352  bool found = false;
+
353 
+
354  for (int n = 0; !found && n < systems.size(); n++) {
+
355  if (s == systems[n]->Name())
+
356  found = true;
+
357  }
+
358 
+
359  if (!found)
+
360  systems.append(Galaxy::GetInstance()->GetSystem(s));
+
361  }
+
362 
+
363  loader->UseFileSystem(Starshatter::UseFileSystem());
+
364 
+
365  if (loader->FindFile("campaign.def"))
+
366  LoadCampaign(loader);
+
367 
+
368  if (campaign_id == CUSTOM_MISSIONS) {
+
369  loader->SetDataPath(path);
+
370  LoadCustomMissions(loader);
+
371  }
+
372  else {
+
373  bool found = false;
+
374 
+
375  if (loader->FindFile("missions.def")) {
+
376  loader->SetDataPath(path);
+
377  LoadMissionList(loader);
+
378  found = true;
+
379  }
+
380 
+
381  if (loader->FindFile("templates.def")) {
+
382  loader->SetDataPath(path);
+
383  LoadTemplateList(loader);
+
384  found = true;
+
385  }
+
386 
+
387  if (!found) {
+
388  loader->SetDataPath(path);
+
389  LoadCustomMissions(loader);
+
390  }
+
391  }
+
392 
+
393  loader->UseFileSystem(true);
+
394  loader->SetDataPath(path);
+
395 
+
396  if (loader->FindFile("image.pcx")) {
+
397  loader->LoadBitmap("image.pcx", image[ 0]);
+
398  loader->LoadBitmap("selected.pcx", image[ 1]);
+
399  loader->LoadBitmap("unavail.pcx", image[ 2]);
+
400  loader->LoadBitmap("banner.pcx", image[ 3]);
+
401  }
+
402 
+
403  loader->SetDataPath(0);
+
404  loader->UseFileSystem(Starshatter::UseFileSystem());
+
405 }
+
406 
+
407 void
+
408 Campaign::Unload()
+
409 {
+
410  SetStatus(CAMPAIGN_INIT);
+
411 
+
412  Game::ResetGameTime();
+
413  StarSystem::SetBaseTime(0);
+
414 
+
415  startTime = Stardate();
+
416  loadTime = startTime;
+
417  lockout = 0;
+
418 
+
419  for (int i = 0; i < NUM_IMAGES; i++)
+
420  image[i].ClearImage();
+
421 
+
422  Clear();
+
423 
+
424  zones.destroy();
+
425 }
+
426 
+
427 void
+
428 Campaign::LoadCampaign(DataLoader* loader, bool full)
+
429 {
+
430  BYTE* block = 0;
+
431  const char* filename = "campaign.def";
+
432 
+
433  loader->UseFileSystem(true);
+
434  loader->LoadBuffer(filename, block, true);
+
435  loader->UseFileSystem(Starshatter::UseFileSystem());
+
436  Parser parser(new(__FILE__,__LINE__) BlockReader((const char*) block));
+
437 
+
438  Term* term = parser.ParseTerm();
+
439 
+
440  if (!term) {
+
441  return;
+
442  }
+
443  else {
+
444  TermText* file_type = term->isText();
+
445  if (!file_type || file_type->value() != "CAMPAIGN") {
+
446  return;
+
447  }
+
448  }
+
449 
+
450  do {
+
451  delete term; term = 0;
+
452  term = parser.ParseTerm();
+
453 
+
454  if (term) {
+
455  TermDef* def = term->isDef();
+
456  if (def) {
+
457  if (def->name()->value() == "name") {
+
458  if (!def->term() || !def->term()->isText()) {
+
459  ::Print("WARNING: name missing in '%s/%s'\n", loader->GetDataPath(), filename);
+
460  }
+
461  else {
+
462  name = def->term()->isText()->value();
+
463  name = Game::GetText(name);
+
464  }
+
465  }
+
466  else if (def->name()->value() == "desc") {
+
467  if (!def->term() || !def->term()->isText()) {
+
468  ::Print("WARNING: description missing in '%s/%s'\n", loader->GetDataPath(), filename);
+
469  }
+
470  else {
+
471  description = def->term()->isText()->value();
+
472  description = Game::GetText(description);
+
473  }
+
474  }
+
475  else if (def->name()->value() == "situation") {
+
476  if (!def->term() || !def->term()->isText()) {
+
477  ::Print("WARNING: situation missing in '%s/%s'\n", loader->GetDataPath(), filename);
+
478  }
+
479  else {
+
480  situation = def->term()->isText()->value();
+
481  situation = Game::GetText(situation);
+
482  }
+
483  }
+
484  else if (def->name()->value() == "orders") {
+
485  if (!def->term() || !def->term()->isText()) {
+
486  ::Print("WARNING: orders missing in '%s/%s'\n", loader->GetDataPath(), filename);
+
487  }
+
488  else {
+
489  orders = def->term()->isText()->value();
+
490  orders = Game::GetText(orders);
+
491  }
+
492  }
+
493  else if (def->name()->value() == "scripted") {
+
494  if (def->term() && def->term()->isBool()) {
+
495  scripted = def->term()->isBool()->value();
+
496  }
+
497  }
+
498  else if (def->name()->value() == "sequential") {
+
499  if (def->term() && def->term()->isBool()) {
+
500  sequential = def->term()->isBool()->value();
+
501  }
+
502  }
+
503  else if (full && def->name()->value() == "combatant") {
+
504  if (!def->term() || !def->term()->isStruct()) {
+
505  ::Print("WARNING: combatant struct missing in '%s/%s'\n", loader->GetDataPath(), filename);
+
506  }
+
507  else {
+
508  TermStruct* val = def->term()->isStruct();
+
509 
+
510  char name[64];
+
511  int iff = 0;
+
512  CombatGroup* force = 0;
+
513  CombatGroup* clone = 0;
+
514 
+
515  ZeroMemory(name, sizeof(name));
+
516 
+
517  for (int i = 0; i < val->elements()->size(); i++) {
+
518  TermDef* pdef = val->elements()->at(i)->isDef();
+
519  if (pdef) {
+
520  if (pdef->name()->value() == "name") {
+
521  GetDefText(name, pdef, filename);
+
522 
+
523  force = CombatRoster::GetInstance()->GetForce(name);
+
524 
+
525  if (force)
+
526  clone = force->Clone(false); // shallow copy
+
527  }
+
528 
+
529  else if (pdef->name()->value() == "group") {
+
530  ParseGroup(pdef->term()->isStruct(), force, clone, filename);
+
531  }
+
532  }
+
533  }
+
534 
+
535  loader->SetDataPath(path);
+
536  Combatant* c = new(__FILE__,__LINE__) Combatant(name, clone);
+
537  if (c) {
+
538  combatants.append(c);
+
539  }
+
540  else {
+
541  Unload();
+
542  return;
+
543  }
+
544  }
+
545  }
+
546  else if (full && def->name()->value() == "action") {
+
547  if (!def->term() || !def->term()->isStruct()) {
+
548  ::Print("WARNING: action struct missing in '%s/%s'\n", loader->GetDataPath(), filename);
+
549  }
+
550  else {
+
551  TermStruct* val = def->term()->isStruct();
+
552  ParseAction(val, filename);
+
553  }
+
554  }
+
555  }
+
556  }
+
557  }
+
558  while (term);
+
559 
+
560  loader->ReleaseBuffer(block);
+
561 }
+
562 
+
563 // +--------------------------------------------------------------------+
+
564 
+
565 void
+
566 Campaign::ParseGroup(TermStruct* val,
+
567 CombatGroup* force,
+
568 CombatGroup* clone,
+
569 const char* filename)
+
570 {
+
571  if (!val) {
+
572  ::Print("invalid combat group in campaign %s\n", name.data());
+
573  return;
+
574  }
+
575 
+
576  int type = 0;
+
577  int id = 0;
+
578 
+
579  for (int i = 0; i < val->elements()->size(); i++) {
+
580  TermDef* pdef = val->elements()->at(i)->isDef();
+
581  if (pdef) {
+
582  if (pdef->name()->value() == "type") {
+
583  char type_name[64];
+
584  GetDefText(type_name, pdef, filename);
+
585  type = CombatGroup::TypeFromName(type_name);
+
586  }
+
587 
+
588  else if (pdef->name()->value() == "id") {
+
589  GetDefNumber(id, pdef, filename);
+
590  }
+
591  }
+
592  }
+
593 
+
594  if (type && id) {
+
595  CombatGroup* g = force->FindGroup(type, id);
+
596 
+
597  // found original group, now clone it over
+
598  if (g && g->GetParent()) {
+
599  CombatGroup* parent = CloneOver(force, clone, g->GetParent());
+
600  parent->AddComponent(g->Clone());
+
601  }
+
602  }
+
603 }
+
604 
+
605 // +--------------------------------------------------------------------+
+
606 
+
607 void
+
608 Campaign::ParseAction(TermStruct* val, const char* filename)
+
609 {
+
610  if (!val) {
+
611  ::Print("invalid action in campaign %s\n", name.data());
+
612  return;
+
613  }
+
614 
+
615  int id = 0;
+
616  int type = 0;
+
617  int subtype = 0;
+
618  int opp_type = -1;
+
619  int team = 0;
+
620  int source = 0;
+
621  Vec3 loc(0.0f, 0.0f, 0.0f);
+
622  Text system;
+
623  Text region;
+
624  Text file;
+
625  Text image;
+
626  Text scene;
+
627  Text text;
+
628  int count = 1;
+
629  int start_before = TIME_NEVER;
+
630  int start_after = 0;
+
631  int min_rank = 0;
+
632  int max_rank = 100;
+
633  int delay = 0;
+
634  int probability = 100;
+
635 
+
636  int asset_type = 0;
+
637  int asset_id = 0;
+
638  int target_type = 0;
+
639  int target_id = 0;
+
640  int target_iff = 0;
+
641 
+
642  CombatAction* action = 0;
+
643 
+
644  for (int i = 0; i < val->elements()->size(); i++) {
+
645  TermDef* pdef = val->elements()->at(i)->isDef();
+
646  if (pdef) {
+
647  if (pdef->name()->value() == "id") {
+
648  GetDefNumber(id, pdef, filename);
+
649  }
+
650  else if (pdef->name()->value() == "type") {
+
651  char txt[64];
+
652  GetDefText(txt, pdef, filename);
+
653  type = CombatAction::TypeFromName(txt);
+
654  }
+
655  else if (pdef->name()->value() == "subtype") {
+
656  if (pdef->term()->isNumber()) {
+
657  GetDefNumber(subtype, pdef, filename);
+
658  }
+
659 
+
660  else if (pdef->term()->isText()) {
+
661  char txt[64];
+
662  GetDefText(txt, pdef, filename);
+
663 
+
664  if (type == CombatAction::MISSION_TEMPLATE) {
+
665  subtype = Mission::TypeFromName(txt);
+
666  }
+
667  else if (type == CombatAction::COMBAT_EVENT) {
+
668  subtype = CombatEvent::TypeFromName(txt);
+
669  }
+
670  else if (type == CombatAction::INTEL_EVENT) {
+
671  subtype = Intel::IntelFromName(txt);
+
672  }
+
673  }
+
674  }
+
675  else if (pdef->name()->value() == "opp_type") {
+
676  if (pdef->term()->isNumber()) {
+
677  GetDefNumber(opp_type, pdef, filename);
+
678  }
+
679 
+
680  else if (pdef->term()->isText()) {
+
681  char txt[64];
+
682  GetDefText(txt, pdef, filename);
+
683 
+
684  if (type == CombatAction::MISSION_TEMPLATE) {
+
685  opp_type = Mission::TypeFromName(txt);
+
686  }
+
687  }
+
688  }
+
689  else if (pdef->name()->value() == "source") {
+
690  char txt[64];
+
691  GetDefText(txt, pdef, filename);
+
692  source = CombatEvent::SourceFromName(txt);
+
693  }
+
694  else if (pdef->name()->value() == "team") {
+
695  GetDefNumber(team, pdef, filename);
+
696  }
+
697  else if (pdef->name()->value() == "iff") {
+
698  GetDefNumber(team, pdef, filename);
+
699  }
+
700  else if (pdef->name()->value() == "count") {
+
701  GetDefNumber(count, pdef, filename);
+
702  }
+
703  else if (pdef->name()->value().contains("before")) {
+
704  if (pdef->term()->isNumber()) {
+
705  GetDefNumber(start_before, pdef, filename);
+
706  }
+
707  else {
+
708  GetDefTime(start_before, pdef, filename);
+
709  start_before -= ONE_DAY;
+
710  }
+
711  }
+
712  else if (pdef->name()->value().contains("after")) {
+
713  if (pdef->term()->isNumber()) {
+
714  GetDefNumber(start_after, pdef, filename);
+
715  }
+
716  else {
+
717  GetDefTime(start_after, pdef, filename);
+
718  start_after -= ONE_DAY;
+
719  }
+
720  }
+
721  else if (pdef->name()->value() == "min_rank") {
+
722  if (pdef->term()->isNumber()) {
+
723  GetDefNumber(min_rank, pdef, filename);
+
724  }
+
725  else {
+
726  char rank_name[64];
+
727  GetDefText(rank_name, pdef, filename);
+
728  min_rank = Player::RankFromName(rank_name);
+
729  }
+
730  }
+
731  else if (pdef->name()->value() == "max_rank") {
+
732  if (pdef->term()->isNumber()) {
+
733  GetDefNumber(max_rank, pdef, filename);
+
734  }
+
735  else {
+
736  char rank_name[64];
+
737  GetDefText(rank_name, pdef, filename);
+
738  max_rank = Player::RankFromName(rank_name);
+
739  }
+
740  }
+
741  else if (pdef->name()->value() == "delay") {
+
742  GetDefNumber(delay, pdef, filename);
+
743  }
+
744  else if (pdef->name()->value() == "probability") {
+
745  GetDefNumber(probability, pdef, filename);
+
746  }
+
747  else if (pdef->name()->value() == "asset_type") {
+
748  char type_name[64];
+
749  GetDefText(type_name, pdef, filename);
+
750  asset_type = CombatGroup::TypeFromName(type_name);
+
751  }
+
752  else if (pdef->name()->value() == "target_type") {
+
753  char type_name[64];
+
754  GetDefText(type_name, pdef, filename);
+
755  target_type = CombatGroup::TypeFromName(type_name);
+
756  }
+
757  else if (pdef->name()->value() == "location" ||
+
758  pdef->name()->value() == "loc") {
+
759  GetDefVec(loc, pdef, filename);
+
760  }
+
761  else if (pdef->name()->value() == "system" ||
+
762  pdef->name()->value() == "sys") {
+
763  GetDefText(system, pdef, filename);
+
764  }
+
765  else if (pdef->name()->value() == "region" ||
+
766  pdef->name()->value() == "rgn" ||
+
767  pdef->name()->value() == "zone") {
+
768  GetDefText(region, pdef, filename);
+
769  }
+
770  else if (pdef->name()->value() == "file") {
+
771  GetDefText(file, pdef, filename);
+
772  }
+
773  else if (pdef->name()->value() == "image") {
+
774  GetDefText(image, pdef, filename);
+
775  }
+
776  else if (pdef->name()->value() == "scene") {
+
777  GetDefText(scene, pdef, filename);
+
778  }
+
779  else if (pdef->name()->value() == "text") {
+
780  GetDefText(text, pdef, filename);
+
781  text = Game::GetText(text);
+
782  }
+
783  else if (pdef->name()->value() == "asset_id") {
+
784  GetDefNumber(asset_id, pdef, filename);
+
785  }
+
786  else if (pdef->name()->value() == "target_id") {
+
787  GetDefNumber(target_id, pdef, filename);
+
788  }
+
789  else if (pdef->name()->value() == "target_iff") {
+
790  GetDefNumber(target_iff, pdef, filename);
+
791  }
+
792 
+
793  else if (pdef->name()->value() == "asset_kill") {
+
794  if (!action)
+
795  action = new(__FILE__,__LINE__) CombatAction(id, type, subtype, team);
+
796 
+
797  if (action) {
+
798  char txt[64];
+
799  GetDefText(txt, pdef, filename);
+
800  action->AssetKills().append(new (__FILE__,__LINE__) Text(txt));
+
801  }
+
802  }
+
803 
+
804  else if (pdef->name()->value() == "target_kill") {
+
805  if (!action)
+
806  action = new(__FILE__,__LINE__) CombatAction(id, type, subtype, team);
+
807 
+
808  if (action) {
+
809  char txt[64];
+
810  GetDefText(txt, pdef, filename);
+
811  action->TargetKills().append(new (__FILE__,__LINE__) Text(txt));
+
812  }
+
813  }
+
814 
+
815  else if (pdef->name()->value() == "req") {
+
816  if (!action)
+
817  action = new(__FILE__,__LINE__) CombatAction(id, type, subtype, team);
+
818 
+
819  if (!pdef->term() || !pdef->term()->isStruct()) {
+
820  ::Print("WARNING: action req struct missing in '%s'\n", filename);
+
821  }
+
822  else if (action) {
+
823  TermStruct* val2 = pdef->term()->isStruct();
+
824 
+
825  int act = 0;
+
826  int stat = CombatAction::COMPLETE;
+
827  bool not = false;
+
828 
+
829  Combatant* c1 = 0;
+
830  Combatant* c2 = 0;
+
831  int comp = 0;
+
832  int score = 0;
+
833  int intel = 0;
+
834  int gtype = 0;
+
835  int gid = 0;
+
836 
+
837  for (int i = 0; i < val2->elements()->size(); i++) {
+
838  TermDef* pdef2 = val2->elements()->at(i)->isDef();
+
839  if (pdef2) {
+
840  if (pdef2->name()->value() == "action") {
+
841  GetDefNumber(act, pdef2, filename);
+
842  }
+
843  else if (pdef2->name()->value() == "status") {
+
844  char txt[64];
+
845  GetDefText(txt, pdef2, filename);
+
846  stat = CombatAction::StatusFromName(txt);
+
847  }
+
848  else if (pdef2->name()->value() == "not") {
+
849  GetDefBool(not, pdef2, filename);
+
850  }
+
851 
+
852  else if (pdef2->name()->value() == "c1") {
+
853  char txt[64];
+
854  GetDefText(txt, pdef2, filename);
+
855  c1 = GetCombatant(txt);
+
856  }
+
857  else if (pdef2->name()->value() == "c2") {
+
858  char txt[64];
+
859  GetDefText(txt, pdef2, filename);
+
860  c2 = GetCombatant(txt);
+
861  }
+
862  else if (pdef2->name()->value() == "comp") {
+
863  char txt[64];
+
864  GetDefText(txt, pdef2, filename);
+
865  comp = CombatActionReq::CompFromName(txt);
+
866  }
+
867  else if (pdef2->name()->value() == "score") {
+
868  GetDefNumber(score, pdef2, filename);
+
869  }
+
870  else if (pdef2->name()->value() == "intel") {
+
871  if (pdef2->term()->isNumber()) {
+
872  GetDefNumber(intel, pdef2, filename);
+
873  }
+
874  else if (pdef2->term()->isText()) {
+
875  char txt[64];
+
876  GetDefText(txt, pdef2, filename);
+
877  intel = Intel::IntelFromName(txt);
+
878  }
+
879  }
+
880  else if (pdef2->name()->value() == "group_type") {
+
881  char type_name[64];
+
882  GetDefText(type_name, pdef2, filename);
+
883  gtype = CombatGroup::TypeFromName(type_name);
+
884  }
+
885  else if (pdef2->name()->value() == "group_id") {
+
886  GetDefNumber(gid, pdef2, filename);
+
887  }
+
888  }
+
889  }
+
890 
+
891  if (act)
+
892  action->AddRequirement(act, stat, not);
+
893 
+
894  else if (gtype)
+
895  action->AddRequirement(c1, gtype, gid, comp, score, intel);
+
896 
+
897  else
+
898  action->AddRequirement(c1, c2, comp, score);
+
899  }
+
900  }
+
901  }
+
902  }
+
903 
+
904  if (!action)
+
905  action = new(__FILE__,__LINE__) CombatAction(id, type, subtype, team);
+
906 
+
907  if (action) {
+
908  action->SetSource(source);
+
909  action->SetOpposingType(opp_type);
+
910  action->SetLocation(loc);
+
911  action->SetSystem(system);
+
912  action->SetRegion(region);
+
913  action->SetFilename(file);
+
914  action->SetImageFile(image);
+
915  action->SetSceneFile(scene);
+
916  action->SetCount(count);
+
917  action->SetStartAfter(start_after);
+
918  action->SetStartBefore(start_before);
+
919  action->SetMinRank(min_rank);
+
920  action->SetMaxRank(max_rank);
+
921  action->SetDelay(delay);
+
922  action->SetProbability(probability);
+
923 
+
924  action->SetAssetId(asset_id);
+
925  action->SetAssetType(asset_type);
+
926  action->SetTargetId(target_id);
+
927  action->SetTargetIFF(target_iff);
+
928  action->SetTargetType(target_type);
+
929  action->SetText(text);
+
930 
+
931  actions.append(action);
+
932  }
+
933 }
+
934 
+
935 // +--------------------------------------------------------------------+
+
936 
+
937 CombatGroup*
+
938 Campaign::CloneOver(CombatGroup* force, CombatGroup* clone, CombatGroup* group)
+
939 {
+
940  CombatGroup* orig_parent = group->GetParent();
+
941 
+
942  if (orig_parent) {
+
943  CombatGroup* clone_parent = clone->FindGroup(orig_parent->Type(), orig_parent->GetID());
+
944 
+
945  if (!clone_parent)
+
946  clone_parent = CloneOver(force, clone, orig_parent);
+
947 
+
948  CombatGroup* new_clone = clone->FindGroup(group->Type(), group->GetID());
+
949 
+
950  if (!new_clone) {
+
951  new_clone = group->Clone(false);
+
952  clone_parent->AddComponent(new_clone);
+
953  }
+
954 
+
955  return new_clone;
+
956  }
+
957  else {
+
958  return clone;
+
959  }
+
960 }
+
961 
+
962 // +--------------------------------------------------------------------+
+
963 
+
964 void
+
965 Campaign::LoadMissionList(DataLoader* loader)
+
966 {
+
967  bool ok = true;
+
968  BYTE* block = 0;
+
969  const char* filename = "Missions.def";
+
970 
+
971  loader->UseFileSystem(true);
+
972  loader->LoadBuffer(filename, block, true);
+
973  loader->UseFileSystem(Starshatter::UseFileSystem());
+
974  Parser parser(new(__FILE__,__LINE__) BlockReader((const char*) block));
+
975 
+
976  Term* term = parser.ParseTerm();
+
977 
+
978  if (!term) {
+
979  return;
+
980  }
+
981  else {
+
982  TermText* file_type = term->isText();
+
983  if (!file_type || file_type->value() != "MISSIONLIST") {
+
984  ::Print("WARNING: invalid mission list file '%s'\n", filename);
+
985  term->print(10);
+
986  return;
+
987  }
+
988  }
+
989 
+
990  do {
+
991  delete term; term = 0;
+
992  term = parser.ParseTerm();
+
993 
+
994  if (term) {
+
995  TermDef* def = term->isDef();
+
996  if (def) {
+
997  if (def->name()->value() == "mission") {
+
998  if (!def->term() || !def->term()->isStruct()) {
+
999  ::Print("WARNING: mission struct missing in '%s'\n", filename);
+
1000  }
+
1001  else {
+
1002  TermStruct* val = def->term()->isStruct();
+
1003 
+
1004  int id = 0;
+
1005  Text name;
+
1006  Text desc;
+
1007  char script[256];
+
1008  char system[256];
+
1009  char region[256];
+
1010  int start = 0;
+
1011  int type = 0;
+
1012 
+
1013  ZeroMemory(script, sizeof(script));
+
1014 
+
1015  strcpy_s(system, "Unknown");
+
1016  strcpy_s(region, "Unknown");
+
1017 
+
1018  for (int i = 0; i < val->elements()->size(); i++) {
+
1019  TermDef* pdef = val->elements()->at(i)->isDef();
+
1020  if (pdef) {
+
1021  if (pdef->name()->value() == "id")
+
1022  GetDefNumber(id, pdef, filename);
+
1023 
+
1024  else if (pdef->name()->value() == "name") {
+
1025  GetDefText(name, pdef, filename);
+
1026  name = Game::GetText(name);
+
1027  }
+
1028 
+
1029  else if (pdef->name()->value() == "desc") {
+
1030  GetDefText(desc, pdef, filename);
+
1031  if (desc.length() > 0 && desc.length() < 32)
+
1032  desc = Game::GetText(desc);
+
1033  }
+
1034 
+
1035  else if (pdef->name()->value() == "start")
+
1036  GetDefTime(start, pdef, filename);
+
1037 
+
1038  else if (pdef->name()->value() == "system")
+
1039  GetDefText(system, pdef, filename);
+
1040 
+
1041  else if (pdef->name()->value() == "region")
+
1042  GetDefText(region, pdef, filename);
+
1043 
+
1044  else if (pdef->name()->value() == "script")
+
1045  GetDefText(script, pdef, filename);
+
1046 
+
1047  else if (pdef->name()->value() == "type") {
+
1048  char typestr[64];
+
1049  GetDefText(typestr, pdef, filename);
+
1050  type = Mission::TypeFromName(typestr);
+
1051  }
+
1052  }
+
1053  }
+
1054 
+
1055  MissionInfo* info = new(__FILE__,__LINE__) MissionInfo;
+
1056  if (info) {
+
1057  info->id = id;
+
1058  info->name = name;
+
1059  info->description = desc;
+
1060  info->system = system;
+
1061  info->region = region;
+
1062  info->script = script;
+
1063  info->start = start;
+
1064  info->type = type;
+
1065  info->mission = 0;
+
1066 
+
1067  info->script.setSensitive(false);
+
1068 
+
1069  missions.append(info);
+
1070  }
+
1071  else {
+
1072  ok = false;
+
1073  }
+
1074  }
+
1075  }
+
1076  }
+
1077  }
+
1078  }
+
1079  while (term);
+
1080 
+
1081  loader->ReleaseBuffer(block);
+
1082 
+
1083  if (!ok)
+
1084  Unload();
+
1085 }
+
1086 
+
1087 void
+
1088 Campaign::LoadCustomMissions(DataLoader* loader)
+
1089 {
+
1090  bool ok = true;
+
1091  List<Text> files;
+
1092  loader->UseFileSystem(true);
+
1093  loader->ListFiles("*.*", files);
+
1094 
+
1095  for (int i = 0; i < files.size(); i++) {
+
1096  Text file = *files[i];
+
1097  file.setSensitive(false);
+
1098 
+
1099  if (file.contains(".def")) {
+
1100  BYTE* block = 0;
+
1101  const char* filename = file.data();
+
1102 
+
1103  loader->UseFileSystem(true);
+
1104  loader->LoadBuffer(filename, block, true);
+
1105  loader->UseFileSystem(Starshatter::UseFileSystem());
+
1106 
+
1107  if (strstr((const char*) block, "MISSION") == (const char*) block) {
+
1108  Text name;
+
1109  Text desc;
+
1110  Text system = "Unknown";
+
1111  Text region = "Unknown";
+
1112  int start = 0;
+
1113  int type = 0;
+
1114  int msn_id = 0;
+
1115 
+
1116  Parser parser(new(__FILE__,__LINE__) BlockReader((const char*) block));
+
1117  Term* term = parser.ParseTerm();
+
1118 
+
1119  if (!term) {
+
1120  Print("ERROR: could not parse '%s'\n", filename);
+
1121  continue;
+
1122  }
+
1123  else {
+
1124  TermText* file_type = term->isText();
+
1125  if (!file_type || file_type->value() != "MISSION") {
+
1126  Print("ERROR: invalid mission file '%s'\n", filename);
+
1127  term->print(10);
+
1128  continue;
+
1129  }
+
1130  }
+
1131 
+
1132  do {
+
1133  delete term; term = 0;
+
1134  term = parser.ParseTerm();
+
1135 
+
1136  if (term) {
+
1137  TermDef* def = term->isDef();
+
1138  if (def) {
+
1139  if (def->name()->value() == "name") {
+
1140  GetDefText(name, def, filename);
+
1141  name = Game::GetText(name);
+
1142  }
+
1143 
+
1144  else if (def->name()->value() == "type") {
+
1145  char typestr[64];
+
1146  GetDefText(typestr, def, filename);
+
1147  type = Mission::TypeFromName(typestr);
+
1148  }
+
1149 
+
1150  else if (def->name()->value() == "id")
+
1151  GetDefNumber(msn_id, def, filename);
+
1152 
+
1153  else if (def->name()->value() == "desc") {
+
1154  GetDefText(desc, def, filename);
+
1155  if (desc.length() > 0 && desc.length() < 32)
+
1156  desc = Game::GetText(desc);
+
1157  }
+
1158 
+
1159  else if (def->name()->value() == "system")
+
1160  GetDefText(system, def, filename);
+
1161 
+
1162  else if (def->name()->value() == "region")
+
1163  GetDefText(region, def, filename);
+
1164 
+
1165  else if (def->name()->value() == "start")
+
1166  GetDefTime(start, def, filename);
+
1167  }
+
1168  }
+
1169  }
+
1170  while (term);
+
1171 
+
1172  loader->ReleaseBuffer(block);
+
1173 
+
1174  if (strstr(filename, "custom") == filename) {
+
1175  sscanf_s(filename+6, "%d", &msn_id);
+
1176 
+
1177  if (msn_id <= i)
+
1178  msn_id = i+1;
+
1179  }
+
1180  else if (msn_id < 1) {
+
1181  msn_id = i+1;
+
1182  }
+
1183 
+
1184  MissionInfo* info = new(__FILE__,__LINE__) MissionInfo;
+
1185  if (info) {
+
1186  info->id = msn_id;
+
1187  info->name = name;
+
1188  info->type = type;
+
1189  info->description = desc;
+
1190  info->system = system;
+
1191  info->region = region;
+
1192  info->script = filename;
+
1193  info->start = start;
+
1194  info->mission = 0;
+
1195 
+
1196  info->script.setSensitive(false);
+
1197 
+
1198  missions.append(info);
+
1199  }
+
1200  else {
+
1201  ok = false;
+
1202  }
+
1203  }
+
1204  else {
+
1205  Print("Invalid Custom Mission File: '%s'\n", filename);
+
1206  }
+
1207 
+
1208  loader->ReleaseBuffer(block);
+
1209  }
+
1210  }
+
1211 
+
1212  files.destroy();
+
1213 
+
1214  if (!ok)
+
1215  Unload();
+
1216  else
+
1217  missions.sort();
+
1218 }
+
1219 
+
1220 void
+
1221 Campaign::LoadTemplateList(DataLoader* loader)
+
1222 {
+
1223  BYTE* block = 0;
+
1224  const char* filename = "Templates.def";
+
1225 
+
1226  loader->UseFileSystem(true);
+
1227  loader->LoadBuffer(filename, block, true);
+
1228  loader->UseFileSystem(Starshatter::UseFileSystem());
+
1229  Parser parser(new(__FILE__,__LINE__) BlockReader((const char*) block));
+
1230 
+
1231  Term* term = parser.ParseTerm();
+
1232 
+
1233  if (!term) {
+
1234  return;
+
1235  }
+
1236  else {
+
1237  TermText* file_type = term->isText();
+
1238  if (!file_type || file_type->value() != "TEMPLATELIST") {
+
1239  ::Print("WARNING: invalid template list file '%s'\n", filename);
+
1240  term->print(10);
+
1241  return;
+
1242  }
+
1243  }
+
1244 
+
1245  do {
+
1246  delete term; term = 0;
+
1247  term = parser.ParseTerm();
+
1248 
+
1249  if (term) {
+
1250  TermDef* def = term->isDef();
+
1251  if (def) {
+
1252  if (def->name()->value() == "mission") {
+
1253  if (!def->term() || !def->term()->isStruct()) {
+
1254  ::Print("WARNING: mission struct missing in '%s'\n", filename);
+
1255  }
+
1256  else {
+
1257  TermStruct* val = def->term()->isStruct();
+
1258 
+
1259  char name[256];
+
1260  char script[256];
+
1261  char region[256];
+
1262  int id = 0;
+
1263  int msn_type = 0;
+
1264  int grp_type = 0;
+
1265 
+
1266  int min_rank = 0;
+
1267  int max_rank = 0;
+
1268  int action_id = 0;
+
1269  int action_status = 0;
+
1270  int exec_once = 0;
+
1271  int start_before = TIME_NEVER;
+
1272  int start_after = 0;
+
1273 
+
1274  name[0] = 0;
+
1275  script[0] = 0;
+
1276  region[0] = 0;
+
1277 
+
1278  for (int i = 0; i < val->elements()->size(); i++) {
+
1279  TermDef* pdef = val->elements()->at(i)->isDef();
+
1280  if (pdef) {
+
1281  if (pdef->name()->value() == "id")
+
1282  GetDefNumber(id, pdef, filename);
+
1283 
+
1284  else if (pdef->name()->value() == "name")
+
1285  GetDefText(name, pdef, filename);
+
1286 
+
1287  else if (pdef->name()->value() == "script")
+
1288  GetDefText(script, pdef, filename);
+
1289 
+
1290  else if (pdef->name()->value() == "rgn" || pdef->name()->value() == "region")
+
1291  GetDefText(region, pdef, filename);
+
1292 
+
1293  else if (pdef->name()->value() == "type") {
+
1294  char typestr[64];
+
1295  GetDefText(typestr, pdef, filename);
+
1296  msn_type = Mission::TypeFromName(typestr);
+
1297  }
+
1298 
+
1299  else if (pdef->name()->value() == "group") {
+
1300  char typestr[64];
+
1301  GetDefText(typestr, pdef, filename);
+
1302  grp_type = CombatGroup::TypeFromName(typestr);
+
1303  }
+
1304 
+
1305  else if (pdef->name()->value() == "min_rank")
+
1306  GetDefNumber(min_rank, pdef, filename);
+
1307 
+
1308  else if (pdef->name()->value() == "max_rank")
+
1309  GetDefNumber(max_rank, pdef, filename);
+
1310 
+
1311  else if (pdef->name()->value() == "action_id")
+
1312  GetDefNumber(action_id, pdef, filename);
+
1313 
+
1314  else if (pdef->name()->value() == "action_status")
+
1315  GetDefNumber(action_status, pdef, filename);
+
1316 
+
1317  else if (pdef->name()->value() == "exec_once")
+
1318  GetDefNumber(exec_once, pdef, filename);
+
1319 
+
1320  else if (pdef->name()->value().contains("before")) {
+
1321  if (pdef->term()->isNumber()) {
+
1322  GetDefNumber(start_before, pdef, filename);
+
1323  }
+
1324  else {
+
1325  GetDefTime(start_before, pdef, filename);
+
1326  start_before -= ONE_DAY;
+
1327  }
+
1328  }
+
1329  else if (pdef->name()->value().contains("after")) {
+
1330  if (pdef->term()->isNumber()) {
+
1331  GetDefNumber(start_after, pdef, filename);
+
1332  }
+
1333  else {
+
1334  GetDefTime(start_after, pdef, filename);
+
1335  start_after -= ONE_DAY;
+
1336  }
+
1337  }
+
1338  }
+
1339  }
+
1340 
+
1341  MissionInfo* info = new(__FILE__,__LINE__) MissionInfo;
+
1342  if (info) {
+
1343  info->id = id;
+
1344  info->name = name;
+
1345  info->script = script;
+
1346  info->region = region;
+
1347  info->type = msn_type;
+
1348  info->min_rank = min_rank;
+
1349  info->max_rank = max_rank;
+
1350  info->action_id = action_id;
+
1351  info->action_status = action_status;
+
1352  info->exec_once = exec_once;
+
1353  info->start_before = start_before;
+
1354  info->start_after = start_after;
+
1355 
+
1356  info->script.setSensitive(false);
+
1357 
+
1358  TemplateList* templist = GetTemplateList(msn_type, grp_type);
+
1359 
+
1360  if (!templist) {
+
1361  templist = new(__FILE__,__LINE__) TemplateList;
+
1362  templist->mission_type = msn_type;
+
1363  templist->group_type = grp_type;
+
1364  templates.append(templist);
+
1365  }
+
1366 
+
1367  templist->missions.append(info);
+
1368  }
+
1369  }
+
1370  }
+
1371  }
+
1372  }
+
1373  }
+
1374  while (term);
+
1375 
+
1376  loader->ReleaseBuffer(block);
+
1377 }
+
1378 
+
1379 // +--------------------------------------------------------------------+
+
1380 
+
1381 void
+
1382 Campaign::CreatePlanners()
+
1383 {
+
1384  if (planners.size() > 0)
+
1385  planners.destroy();
+
1386 
+
1387  CampaignPlan* p;
+
1388 
+
1389  // PLAN EVENT MUST BE FIRST PLANNER:
+
1390  p = new(__FILE__,__LINE__) CampaignPlanEvent(this);
+
1391  if (p)
+
1392  planners.append(p);
+
1393 
+
1394  p = new(__FILE__,__LINE__) CampaignPlanStrategic(this);
+
1395  if (p)
+
1396  planners.append(p);
+
1397 
+
1398  p = new(__FILE__,__LINE__) CampaignPlanAssignment(this);
+
1399  if (p)
+
1400  planners.append(p);
+
1401 
+
1402  p = new(__FILE__,__LINE__) CampaignPlanMovement(this);
+
1403  if (p)
+
1404  planners.append(p);
+
1405 
+
1406  p = new(__FILE__,__LINE__) CampaignPlanMission(this);
+
1407  if (p)
+
1408  planners.append(p);
+
1409 
+
1410  if (lockout > 0 && planners.size()) {
+
1411  ListIter<CampaignPlan> plan = planners;
+
1412  while (++plan)
+
1413  plan->SetLockout(lockout);
+
1414  }
+
1415 }
+
1416 
+
1417 // +--------------------------------------------------------------------+
+
1418 
+
1419 int
+
1420 Campaign::GetPlayerIFF()
+
1421 {
+
1422  int iff = 1;
+
1423 
+
1424  if (player_group)
+
1425  iff = player_group->GetIFF();
+
1426 
+
1427  return iff;
+
1428 }
+
1429 
+
1430 void
+
1431 Campaign::SetPlayerGroup(CombatGroup* pg)
+
1432 {
+
1433  if (player_group != pg) {
+
1434  ::Print("Campaign::SetPlayerGroup(%s)\n", pg ? pg->Name().data() : "0");
+
1435 
+
1436  // should verify that the player group is
+
1437  // actually part of this campaign, first!
+
1438 
+
1439  player_group = pg;
+
1440  player_unit = 0;
+
1441 
+
1442  // need to regenerate missions when changing
+
1443  // player combat group:
+
1444  if (IsDynamic()) {
+
1445  ::Print(" destroying mission list...\n");
+
1446  missions.destroy();
+
1447  }
+
1448  }
+
1449 }
+
1450 
+
1451 void
+
1452 Campaign::SetPlayerUnit(CombatUnit* unit)
+
1453 {
+
1454  if (player_unit != unit) {
+
1455  ::Print("Campaign::SetPlayerUnit(%s)\n", unit ? unit->Name().data() : "0");
+
1456 
+
1457  // should verify that the player unit is
+
1458  // actually part of this campaign, first!
+
1459 
+
1460  player_unit = unit;
+
1461 
+
1462  if (unit)
+
1463  player_group = unit->GetCombatGroup();
+
1464 
+
1465  // need to regenerate missions when changing
+
1466  // player combat unit:
+
1467  if (IsDynamic()) {
+
1468  ::Print(" destroying mission list...\n");
+
1469  missions.destroy();
+
1470  }
+
1471  }
+
1472 }
+
1473 
+
1474 // +--------------------------------------------------------------------+
+
1475 
+
1476 CombatZone*
+
1477 Campaign::GetZone(const char* rgn)
+
1478 {
+
1479  ListIter<CombatZone> z = zones;
+
1480  while (++z) {
+
1481  if (z->HasRegion(rgn))
+
1482  return z.value();
+
1483  }
+
1484 
+
1485  return 0;
+
1486 }
+
1487 
+
1488 StarSystem*
+
1489 Campaign::GetSystem(const char* sys)
+
1490 {
+
1491  return Galaxy::GetInstance()->GetSystem(sys);
+
1492 }
+
1493 
+
1494 Combatant*
+
1495 Campaign::GetCombatant(const char* cname)
+
1496 {
+
1497  ListIter<Combatant> iter = combatants;
+
1498  while (++iter) {
+
1499  Combatant* c = iter.value();
+
1500  if (!strcmp(c->Name(), cname))
+
1501  return c;
+
1502  }
+
1503 
+
1504  return 0;
+
1505 }
+
1506 
+
1507 // +--------------------------------------------------------------------+
+
1508 
+
1509 Mission*
+
1510 Campaign::GetMission()
+
1511 {
+
1512  return GetMission(mission_id);
+
1513 }
+
1514 
+
1515 Mission*
+
1516 Campaign::GetMission(int id)
+
1517 {
+
1518  if (id < 0) {
+
1519  ::Print("ERROR - Campaign::GetMission(%d) invalid mission id\n", id);
+
1520  return 0;
+
1521  }
+
1522 
+
1523  if (mission && mission->Identity() == id) {
+
1524  return mission;
+
1525  }
+
1526 
+
1527  MissionInfo* info = 0;
+
1528  for (int i = 0; !info && i < missions.size(); i++)
+
1529  if (missions[i]->id == id)
+
1530  info = missions[i];
+
1531 
+
1532  if (info) {
+
1533  if (!info->mission) {
+
1534  ::Print("Campaign::GetMission(%d) loading mission...\n", id);
+
1535  info->mission = new(__FILE__,__LINE__) Mission(id, info->script, path);
+
1536  if (info->mission)
+
1537  info->mission->Load();
+
1538  }
+
1539 
+
1540  if (IsDynamic()) {
+
1541  if (info->mission) {
+
1542  if (!_stricmp(info->mission->Situation(), "Unknown")) {
+
1543  ::Print("Campaign::GetMission(%d) generating sitrep...\n", id);
+
1544  CampaignSituationReport sitrep(this, info->mission);
+
1545  sitrep.GenerateSituationReport();
+
1546  }
+
1547  }
+
1548  else {
+
1549  ::Print("Campaign::GetMission(%d) could not find/load mission.\n", id);
+
1550  }
+
1551  }
+
1552 
+
1553  return info->mission;
+
1554  }
+
1555 
+
1556  return 0;
+
1557 }
+
1558 
+
1559 Mission*
+
1560 Campaign::GetMissionByFile(const char* filename)
+
1561 {
+
1562  if (!filename || !*filename) {
+
1563  ::Print("ERROR - Campaign::GetMissionByFile() invalid filename\n");
+
1564  return 0;
+
1565  }
+
1566 
+
1567  int id = 0;
+
1568  int maxid = 0;
+
1569  MissionInfo* info = 0;
+
1570 
+
1571  for (int i = 0; !info && i < missions.size(); i++) {
+
1572  MissionInfo* m = missions[i];
+
1573 
+
1574  if (m->id > maxid)
+
1575  maxid = m->id;
+
1576 
+
1577  if (m->script == filename)
+
1578  info = m;
+
1579  }
+
1580 
+
1581  if (info) {
+
1582  id = info->id;
+
1583 
+
1584  if (!info->mission) {
+
1585  ::Print("Campaign::GetMission(%d) loading mission...\n", id);
+
1586  info->mission = new(__FILE__,__LINE__) Mission(id, info->script, path);
+
1587  if (info->mission)
+
1588  info->mission->Load();
+
1589  }
+
1590 
+
1591  if (IsDynamic()) {
+
1592  if (info->mission) {
+
1593  if (!_stricmp(info->mission->Situation(), "Unknown")) {
+
1594  ::Print("Campaign::GetMission(%d) generating sitrep...\n", id);
+
1595  CampaignSituationReport sitrep(this, info->mission);
+
1596  sitrep.GenerateSituationReport();
+
1597  }
+
1598  }
+
1599  else {
+
1600  ::Print("Campaign::GetMission(%d) could not find/load mission.\n", id);
+
1601  }
+
1602  }
+
1603  }
+
1604 
+
1605  else {
+
1606  info = new(__FILE__,__LINE__) MissionInfo;
+
1607  if (info) {
+
1608  info->id = maxid+1;
+
1609  info->name = "New Custom Mission";
+
1610  info->script = filename;
+
1611  info->mission = new(__FILE__,__LINE__) Mission(info->id, info->script, "Mods/Missions/");
+
1612  info->mission->SetName(info->name);
+
1613 
+
1614  info->script.setSensitive(false);
+
1615 
+
1616  missions.append(info);
+
1617  }
+
1618  }
+
1619 
+
1620  return info->mission;
+
1621 }
+
1622 
+
1623 MissionInfo*
+
1624 Campaign::CreateNewMission()
+
1625 {
+
1626  int id = 0;
+
1627  int maxid = 0;
+
1628  MissionInfo* info = 0;
+
1629 
+
1630  if (campaign_id == MULTIPLAYER_MISSIONS)
+
1631  maxid = 10;
+
1632 
+
1633  for (int i = 0; !info && i < missions.size(); i++) {
+
1634  MissionInfo* m = missions[i];
+
1635 
+
1636  if (m->id > maxid)
+
1637  maxid = m->id;
+
1638  }
+
1639 
+
1640  char filename[64];
+
1641  sprintf_s(filename, "custom%03d.def", maxid+1);
+
1642 
+
1643  info = new(__FILE__,__LINE__) MissionInfo;
+
1644  if (info) {
+
1645  info->id = maxid+1;
+
1646  info->name = "New Custom Mission";
+
1647  info->script = filename;
+
1648  info->mission = new(__FILE__,__LINE__) Mission(info->id, filename, path);
+
1649  info->mission->SetName(info->name);
+
1650 
+
1651  info->script.setSensitive(false);
+
1652 
+
1653  missions.append(info);
+
1654  }
+
1655 
+
1656  return info;
+
1657 }
+
1658 
+
1659 void
+
1660 Campaign::DeleteMission(int id)
+
1661 {
+
1662  if (id < 0) {
+
1663  ::Print("ERROR - Campaign::DeleteMission(%d) invalid mission id\n", id);
+
1664  return;
+
1665  }
+
1666 
+
1667  MissionInfo* m = 0;
+
1668  int index = -1;
+
1669 
+
1670  for (int i = 0; !m && i < missions.size(); i++) {
+
1671  if (missions[i]->id == id) {
+
1672  m = missions[i];
+
1673  index = i;
+
1674  }
+
1675  }
+
1676 
+
1677  if (m) {
+
1678  char full_path[256];
+
1679 
+
1680  if (path[strlen(path)-1] == '/')
+
1681  sprintf_s(full_path, "%s%s", path, m->script.data());
+
1682  else
+
1683  sprintf_s(full_path, "%s/%s", path, m->script.data());
+
1684 
+
1685  DeleteFile(full_path);
+
1686  Load();
+
1687  }
+
1688 
+
1689  else {
+
1690  ::Print("ERROR - Campaign::DeleteMission(%d) could not find mission\n", id);
+
1691  }
+
1692 }
+
1693 
+
1694 MissionInfo*
+
1695 Campaign::GetMissionInfo(int id)
+
1696 {
+
1697  if (id < 0) {
+
1698  ::Print("ERROR - Campaign::GetMissionInfo(%d) invalid mission id\n", id);
+
1699  return 0;
+
1700  }
+
1701 
+
1702  MissionInfo* m = 0;
+
1703  for (int i = 0; !m && i < missions.size(); i++)
+
1704  if (missions[i]->id == id)
+
1705  m = missions[i];
+
1706 
+
1707  if (m) {
+
1708  if (!m->mission) {
+
1709  m->mission = new(__FILE__,__LINE__) Mission(id, m->script);
+
1710  if (m->mission)
+
1711  m->mission->Load();
+
1712  }
+
1713 
+
1714  return m;
+
1715  }
+
1716 
+
1717  else {
+
1718  ::Print("ERROR - Campaign::GetMissionInfo(%d) could not find mission\n", id);
+
1719  }
+
1720 
+
1721  return 0;
+
1722 }
+
1723 
+
1724 void
+
1725 Campaign::ReloadMission(int id)
+
1726 {
+
1727  if (mission && mission == net_mission) {
+
1728  delete net_mission;
+
1729  net_mission = 0;
+
1730  }
+
1731 
+
1732  mission = 0;
+
1733 
+
1734  if (id >= 0 && id < missions.size()) {
+
1735  MissionInfo* m = missions[id];
+
1736  delete m->mission;
+
1737  m->mission = 0;
+
1738  }
+
1739 }
+
1740 
+
1741 void
+
1742 Campaign::LoadNetMission(int id, const char* net_mission_script)
+
1743 {
+
1744  if (mission && mission == net_mission) {
+
1745  delete net_mission;
+
1746  net_mission = 0;
+
1747  }
+
1748 
+
1749  mission_id = id;
+
1750  mission = new(__FILE__,__LINE__) Mission(id);
+
1751 
+
1752  if (mission && mission->ParseMission(net_mission_script))
+
1753  mission->Validate();
+
1754 
+
1755  net_mission = mission;
+
1756 }
+
1757 
+
1758 // +--------------------------------------------------------------------+
+
1759 
+
1760 CombatAction*
+
1761 Campaign::FindAction(int action_id)
+
1762 {
+
1763  ListIter<CombatAction> iter = actions;
+
1764  while (++iter) {
+
1765  CombatAction* a = iter.value();
+
1766 
+
1767  if (a->Identity() == action_id)
+
1768  return a;
+
1769  }
+
1770 
+
1771  return 0;
+
1772 }
+
1773 
+
1774 // +--------------------------------------------------------------------+
+
1775 
+
1776 MissionInfo*
+
1777 Campaign::FindMissionTemplate(int mission_type, CombatGroup* player_group)
+
1778 {
+
1779  MissionInfo* info = 0;
+
1780 
+
1781  if (!player_group)
+
1782  return info;
+
1783 
+
1784  TemplateList* templates = GetTemplateList(mission_type, player_group->Type());
+
1785 
+
1786  if (!templates || !templates->missions.size())
+
1787  return info;
+
1788 
+
1789  int tries = 0;
+
1790  int msize = templates->missions.size();
+
1791 
+
1792  while (!info && tries < msize) {
+
1793  // get next template:
+
1794  int index = templates->index;
+
1795 
+
1796  if (index >= msize)
+
1797  index = 0;
+
1798 
+
1799  info = templates->missions[index];
+
1800  templates->index = index + 1;
+
1801  tries++;
+
1802 
+
1803  // validate the template:
+
1804  if (info) {
+
1805  if (info->action_id) {
+
1806  CombatAction* a = FindAction(info->action_id);
+
1807 
+
1808  if (a && a->Status() != info->action_status)
+
1809  info = 0;
+
1810  }
+
1811 
+
1812  if (info && !info->IsAvailable()) {
+
1813  info = 0;
+
1814  }
+
1815  }
+
1816  }
+
1817 
+
1818  return info;
+
1819 }
+
1820 
+
1821 // +--------------------------------------------------------------------+
+
1822 
+
1823 TemplateList*
+
1824 Campaign::GetTemplateList(int msn_type, int grp_type)
+
1825 {
+
1826  for (int i = 0; i < templates.size(); i++) {
+
1827  if (templates[i]->mission_type == msn_type &&
+
1828  templates[i]->group_type == grp_type)
+
1829  return templates[i];
+
1830  }
+
1831 
+
1832  return 0;
+
1833 }
+
1834 
+
1835 // +--------------------------------------------------------------------+
+
1836 
+
1837 void
+
1838 Campaign::SetMissionId(int id)
+
1839 {
+
1840  ::Print("Campaign::SetMissionId(%d)\n", id);
+
1841 
+
1842  if (id > 0)
+
1843  mission_id = id;
+
1844  else
+
1845  ::Print(" retaining mission id = %d\n", mission_id);
+
1846 }
+
1847 
+
1848 // +--------------------------------------------------------------------+
+
1849 
+
1850 double
+
1851 Campaign::Stardate()
+
1852 {
+
1853  return StarSystem::Stardate();
+
1854 }
+
1855 
+
1856 // +--------------------------------------------------------------------+
+
1857 
+
1858 void
+
1859 Campaign::SelectDefaultPlayerGroup(CombatGroup* g, int type)
+
1860 {
+
1861  if (player_group || !g) return;
+
1862 
+
1863  if (g->Type() == type && !g->IsReserve() && g->Value() > 0) {
+
1864  player_group = g;
+
1865  player_unit = 0;
+
1866  return;
+
1867  }
+
1868 
+
1869  for (int i = 0; i < g->GetComponents().size(); i++)
+
1870  SelectDefaultPlayerGroup(g->GetComponents()[i], type);
+
1871 }
+
1872 
+
1873 // +--------------------------------------------------------------------+
+
1874 
+
1875 void
+
1876 Campaign::Prep()
+
1877 {
+
1878  // if this is a new campaign,
+
1879  // create combatants from roster and template:
+
1880  if (IsDynamic() && combatants.isEmpty()) {
+
1881  DataLoader* loader = DataLoader::GetLoader();
+
1882  loader->SetDataPath(path);
+
1883  LoadCampaign(loader, true);
+
1884  }
+
1885 
+
1886  StarSystem::SetBaseTime(loadTime);
+
1887 
+
1888  // load scripted missions:
+
1889  if (IsScripted() && actions.isEmpty()) {
+
1890  DataLoader* loader = DataLoader::GetLoader();
+
1891  loader->SetDataPath(path);
+
1892  LoadCampaign(loader, true);
+
1893 
+
1894  ListIter<MissionInfo> m = missions;
+
1895  while (++m) {
+
1896  GetMission(m->id);
+
1897  }
+
1898  }
+
1899 
+
1900  CheckPlayerGroup();
+
1901 }
+
1902 
+
1903 void
+
1904 Campaign::Start()
+
1905 {
+
1906  ::Print("Campaign::Start()\n");
+
1907 
+
1908  Prep();
+
1909 
+
1910  // create planners:
+
1911  CreatePlanners();
+
1912  SetStatus(CAMPAIGN_ACTIVE);
+
1913 }
+
1914 
+
1915 void
+
1916 Campaign::ExecFrame()
+
1917 {
+
1918  if (InCutscene())
+
1919  return;
+
1920 
+
1921  time = Stardate() - startTime;
+
1922 
+
1923  if (status < CAMPAIGN_ACTIVE)
+
1924  return;
+
1925 
+
1926  if (IsDynamic()) {
+
1927  bool completed = false;
+
1928  ListIter<MissionInfo> m = missions;
+
1929  while (++m) {
+
1930  if (m->mission && m->mission->IsComplete()) {
+
1931  ::Print("Campaign::ExecFrame() completed mission %d '%s'\n", m->id, m->name.data());
+
1932  completed = true;
+
1933  }
+
1934  }
+
1935 
+
1936  if (completed) {
+
1937  ::Print("Campaign::ExecFrame() destroying mission list after completion...\n");
+
1938  missions.destroy();
+
1939 
+
1940  if (!player_group || player_group->IsFighterGroup())
+
1941  time += 10 * 3600;
+
1942  else
+
1943  time += 20 * 3600;
+
1944 
+
1945  StarSystem::SetBaseTime(startTime + time - Game::GameTime()/1000.0);
+
1946  }
+
1947  else {
+
1948  m.reset();
+
1949 
+
1950  while (++m) {
+
1951  if (m->start < time && !m->mission->IsActive()) {
+
1952  MissionInfo* info = m.removeItem();
+
1953 
+
1954  if (info)
+
1955  ::Print("Campaign::ExecFrame() deleting expired mission %d start: %d current: %d\n",
+
1956  info->id,
+
1957  info->start,
+
1958  (int) time);
+
1959 
+
1960  delete info;
+
1961  }
+
1962  }
+
1963  }
+
1964 
+
1965  // PLAN EVENT MUST BE FIRST PLANNER:
+
1966  if (loaded_from_savegame && planners.size() > 0) {
+
1967  CampaignPlanEvent* plan_event = (CampaignPlanEvent*) planners.first();
+
1968  plan_event->ExecScriptedEvents();
+
1969 
+
1970  loaded_from_savegame = false;
+
1971  }
+
1972 
+
1973  ListIter<CampaignPlan> plan = planners;
+
1974  while (++plan) {
+
1975  CheckPlayerGroup();
+
1976  plan->ExecFrame();
+
1977  }
+
1978 
+
1979  CheckPlayerGroup();
+
1980 
+
1981  // Auto save game AFTER planners have run!
+
1982  // This is done to ensure that campaign status
+
1983  // is properly recorded after winning or losing
+
1984  // the campaign.
+
1985 
+
1986  if (completed) {
+
1987  CampaignSaveGame save(this);
+
1988  save.SaveAuto();
+
1989  }
+
1990  }
+
1991  else {
+
1992  // PLAN EVENT MUST BE FIRST PLANNER:
+
1993  if (planners.size() > 0) {
+
1994  CampaignPlanEvent* plan_event = (CampaignPlanEvent*) planners.first();
+
1995  plan_event->ExecScriptedEvents();
+
1996  }
+
1997  }
+
1998 }
+
1999 
+
2000 // +--------------------------------------------------------------------+
+
2001 
+
2002 void
+
2003 Campaign::LockoutEvents(int seconds)
+
2004 {
+
2005  lockout = seconds;
+
2006 }
+
2007 
+
2008 void
+
2009 Campaign::CheckPlayerGroup()
+
2010 {
+
2011  if (!player_group || player_group->IsReserve() || player_group->CalcValue() < 1) {
+
2012  int player_iff = GetPlayerIFF();
+
2013  player_group = 0;
+
2014 
+
2015  CombatGroup* force = 0;
+
2016  for (int i = 0; i < combatants.size() && !force; i++) {
+
2017  if (combatants[i]->GetIFF() == player_iff) {
+
2018  force = combatants[i]->GetForce();
+
2019  }
+
2020  }
+
2021 
+
2022  if (force) {
+
2023  force->CalcValue();
+
2024  SelectDefaultPlayerGroup(force, CombatGroup::WING);
+
2025 
+
2026  if (!player_group)
+
2027  SelectDefaultPlayerGroup(force, CombatGroup::DESTROYER_SQUADRON);
+
2028  }
+
2029  }
+
2030 
+
2031  if (player_unit && player_unit->GetValue() < 1)
+
2032  SetPlayerUnit(0);
+
2033 }
+
2034 
+
2035 // +--------------------------------------------------------------------+
+
2036 
+
2037 void FPU2Extended();
+
2038 void FPURestore();
+
2039 
+
2040 void
+
2041 Campaign::StartMission()
+
2042 {
+
2043  Mission* m = GetMission();
+
2044 
+
2045  if (m) {
+
2046  ::Print("\n\nCampaign Start Mission - %d. '%s'\n", m->Identity(), m->Name());
+
2047 
+
2048  if (!scripted) {
+
2049  FPU2Extended();
+
2050 
+
2051  double gtime = (double) Game::GameTime() / 1000.0;
+
2052  double base = startTime + m->Start() - 15 - gtime;
+
2053 
+
2054  StarSystem::SetBaseTime(base);
+
2055 
+
2056  double current_time = Stardate() - startTime;
+
2057 
+
2058  char buffer[32];
+
2059  FormatDayTime(buffer, current_time);
+
2060  ::Print(" current time: %s\n", buffer);
+
2061 
+
2062  FormatDayTime(buffer, m->Start());
+
2063  ::Print(" mission start: %s\n", buffer);
+
2064  ::Print("\n");
+
2065  }
+
2066  }
+
2067 }
+
2068 
+
2069 void
+
2070 Campaign::RollbackMission()
+
2071 {
+
2072  ::Print("Campaign::RollbackMission()\n");
+
2073 
+
2074  Mission* m = GetMission();
+
2075 
+
2076  if (m) {
+
2077  if (!scripted) {
+
2078  FPU2Extended();
+
2079 
+
2080  double gtime = (double) Game::GameTime() / 1000.0;
+
2081  double base = startTime + m->Start() - 60 - gtime;
+
2082 
+
2083  StarSystem::SetBaseTime(base);
+
2084 
+
2085  double current_time = Stardate() - startTime;
+
2086  ::Print(" mission start: %d\n", m->Start());
+
2087  ::Print(" current time: %d\n", (int) current_time);
+
2088  }
+
2089 
+
2090  m->SetActive(false);
+
2091  m->SetComplete(false);
+
2092  }
+
2093 }
+
2094 
+
2095 // +--------------------------------------------------------------------+
+
2096 
+
2097 bool
+
2098 Campaign::InCutscene() const
+
2099 {
+
2100  Starshatter* stars = Starshatter::GetInstance();
+
2101  return stars ? stars->InCutscene() : false;
+
2102 }
+
2103 
+
2104 bool
+
2105 Campaign::IsDynamic() const
+
2106 {
+
2107  return campaign_id >= DYNAMIC_CAMPAIGN &&
+
2108  campaign_id < SINGLE_MISSIONS;
+
2109 }
+
2110 
+
2111 bool
+
2112 Campaign::IsTraining() const
+
2113 {
+
2114  return campaign_id == TRAINING_CAMPAIGN;
+
2115 }
+
2116 
+
2117 bool
+
2118 Campaign::IsScripted() const
+
2119 {
+
2120  return scripted;
+
2121 }
+
2122 
+
2123 bool
+
2124 Campaign::IsSequential() const
+
2125 {
+
2126  return sequential;
+
2127 }
+
2128 
+
2129 // +--------------------------------------------------------------------+
+
2130 
+
2131 static CombatGroup* FindGroup(CombatGroup* g, int type, int id)
+
2132 {
+
2133  if (g->Type() == type && g->GetID() == id)
+
2134  return g;
+
2135 
+
2136  CombatGroup* result = 0;
+
2137 
+
2138  ListIter<CombatGroup> subgroup = g->GetComponents();
+
2139  while (++subgroup && !result)
+
2140  result = FindGroup(subgroup.value(), type, id);
+
2141 
+
2142  return result;
+
2143 }
+
2144 
+
2145 CombatGroup*
+
2146 Campaign::FindGroup(int iff, int type, int id)
+
2147 {
+
2148  CombatGroup* result = 0;
+
2149 
+
2150  ListIter<Combatant> combatant = combatants;
+
2151  while (++combatant && !result) {
+
2152  if (combatant->GetIFF() == iff) {
+
2153  result = ::FindGroup(combatant->GetForce(), type, id);
+
2154  }
+
2155  }
+
2156 
+
2157  return result;
+
2158 }
+
2159 
+
2160 // +--------------------------------------------------------------------+
+
2161 
+
2162 static void FindGroups(CombatGroup* g, int type, CombatGroup* near_group,
+
2163 List<CombatGroup>& groups)
+
2164 {
+
2165  if (g->Type() == type && g->IntelLevel() > Intel::RESERVE) {
+
2166  if (!near_group || g->GetAssignedZone() == near_group->GetAssignedZone())
+
2167  groups.append(g);
+
2168  }
+
2169 
+
2170  ListIter<CombatGroup> subgroup = g->GetComponents();
+
2171  while (++subgroup)
+
2172  FindGroups(subgroup.value(), type, near_group, groups);
+
2173 }
+
2174 
+
2175 CombatGroup*
+
2176 Campaign::FindGroup(int iff, int type, CombatGroup* near_group)
+
2177 {
+
2178  CombatGroup* result = 0;
+
2179  List<CombatGroup> groups;
+
2180 
+
2181  ListIter<Combatant> combatant = combatants;
+
2182  while (++combatant) {
+
2183  if (combatant->GetIFF() == iff) {
+
2184  FindGroups(combatant->GetForce(), type, near_group, groups);
+
2185  }
+
2186  }
+
2187 
+
2188  if (groups.size() > 0) {
+
2189  int index = (int) Random(0, groups.size());
+
2190  if (index >= groups.size()) index = groups.size() - 1;
+
2191  result = groups[index];
+
2192  }
+
2193 
+
2194  return result;
+
2195 }
+
2196 
+
2197 // +--------------------------------------------------------------------+
+
2198 
+
2199 static void FindStrikeTargets(CombatGroup* g, CombatGroup* strike_group,
+
2200 List<CombatGroup>& groups)
+
2201 {
+
2202  if (!strike_group || !strike_group->GetAssignedZone()) return;
+
2203 
+
2204  if (g->IsStrikeTarget() && g->IntelLevel() > Intel::RESERVE) {
+
2205  if (strike_group->GetAssignedZone() == g->GetAssignedZone() ||
+
2206  strike_group->GetAssignedZone()->HasRegion(g->GetRegion()))
+
2207  groups.append(g);
+
2208  }
+
2209 
+
2210  ListIter<CombatGroup> subgroup = g->GetComponents();
+
2211  while (++subgroup)
+
2212  FindStrikeTargets(subgroup.value(), strike_group, groups);
+
2213 }
+
2214 
+
2215 CombatGroup*
+
2216 Campaign::FindStrikeTarget(int iff, CombatGroup* strike_group)
+
2217 {
+
2218  CombatGroup* result = 0;
+
2219 
+
2220  List<CombatGroup> groups;
+
2221 
+
2222  ListIter<Combatant> combatant = GetCombatants();
+
2223  while (++combatant) {
+
2224  if (combatant->GetIFF() != 0 && combatant->GetIFF() != iff) {
+
2225  FindStrikeTargets(combatant->GetForce(), strike_group, groups);
+
2226  }
+
2227  }
+
2228 
+
2229  if (groups.size() > 0) {
+
2230  int index = rand() % groups.size();
+
2231  result = groups[index];
+
2232  }
+
2233 
+
2234  return result;
+
2235 }
+
2236 
+
2237 // +--------------------------------------------------------------------+
+
2238 
+
2239 void
+
2240 Campaign::CommitExpiredActions()
+
2241 {
+
2242  ListIter<CombatAction> iter = actions;
+
2243  while (++iter) {
+
2244  CombatAction* a = iter.value();
+
2245 
+
2246  if (a->IsAvailable())
+
2247  a->SetStatus(CombatAction::COMPLETE);
+
2248  }
+
2249 
+
2250  updateTime = time;
+
2251 }
+
2252 
+
2253 // +--------------------------------------------------------------------+
+
2254 
+
2255 int
+
2256 Campaign::GetPlayerTeamScore()
+
2257 {
+
2258  int score_us = 0;
+
2259  int score_them = 0;
+
2260 
+
2261  if (player_group) {
+
2262  int iff = player_group->GetIFF();
+
2263 
+
2264  ListIter<Combatant> iter = combatants;
+
2265  while (++iter) {
+
2266  Combatant* c = iter.value();
+
2267 
+
2268  if (iff <= 1) {
+
2269  if (c->GetIFF() <= 1)
+
2270  score_us += c->Score();
+
2271  else
+
2272  score_them += c->Score();
+
2273  }
+
2274 
+
2275  else {
+
2276  if (c->GetIFF() <= 1)
+
2277  score_them += c->Score();
+
2278  else
+
2279  score_us += c->Score();
+
2280  }
+
2281  }
+
2282  }
+
2283 
+
2284  return score_us - score_them;
+
2285 }
+
2286 
+
2287 // +--------------------------------------------------------------------+
+
2288 
+
2289 void
+
2290 Campaign::SetStatus(int s)
+
2291 {
+
2292  status = s;
+
2293 
+
2294  // record the win in player profile:
+
2295  if (status == CAMPAIGN_SUCCESS) {
+
2296  Player* player = Player::GetCurrentPlayer();
+
2297 
+
2298  if (player)
+
2299  player->SetCampaignComplete(campaign_id);
+
2300  }
+
2301 
+
2302  if (status > CAMPAIGN_ACTIVE) {
+
2303  ::Print("Campaign::SetStatus() destroying mission list at campaign end\n");
+
2304  missions.destroy();
+
2305  }
+
2306 }
+
2307 
+
2308 // +--------------------------------------------------------------------+
+
2309 
+
2310 static void GetCombatUnits(CombatGroup* g, List<CombatUnit>& units)
+
2311 {
+
2312  if (g) {
+
2313  ListIter<CombatUnit> unit = g->GetUnits();
+
2314  while (++unit) {
+
2315  CombatUnit* u = unit.value();
+
2316 
+
2317  if (u->Count() - u->DeadCount() > 0)
+
2318  units.append(u);
+
2319  }
+
2320 
+
2321  ListIter<CombatGroup> comp = g->GetComponents();
+
2322  while (++comp) {
+
2323  CombatGroup* g2 = comp.value();
+
2324 
+
2325  if (!g2->IsReserve())
+
2326  GetCombatUnits(g2, units);
+
2327  }
+
2328  }
+
2329 }
+
2330 
+
2331 int
+
2332 Campaign::GetAllCombatUnits(int iff, List<CombatUnit>& units)
+
2333 {
+
2334  units.clear();
+
2335 
+
2336  ListIter<Combatant> iter = combatants;
+
2337  while (++iter) {
+
2338  Combatant* c = iter.value();
+
2339 
+
2340  if (iff < 0 || c->GetIFF() == iff) {
+
2341  GetCombatUnits(c->GetForce(), units);
+
2342  }
+
2343  }
+
2344 
+
2345  return units.size();
+
2346 }
+
+
+ + + + -- cgit v1.1