CombatGroup*
CombatGroup::LoadOrderOfBattle(const char* filename, int team, Combatant* combatant)
{
CombatGroup* force = 0;
DataLoader* loader = DataLoader::GetLoader();
BYTE* block;
loader->LoadBuffer(filename, block, true);
Parser parser(new(__FILE__,__LINE__) BlockReader((const char*) block));
Term* term = parser.ParseTerm();
if (!term) {
Print("ERROR: could not parse order of battle '%s'\n", filename);
return 0;
}
else {
TermText* file_type = term->isText();
if (!file_type || file_type->value() != "ORDER_OF_BATTLE") {
Print("ERROR: invalid Order of Battle file '%s'\n", filename);
term->print(10);
return 0;
}
}
do {
delete term; term = 0;
term = parser.ParseTerm();
if (term) {
TermDef* def = term->isDef();
if (def) {
if (def->name()->value() == "group") {
if (!def->term() || !def->term()->isStruct()) {
Print("WARNING: group struct missing in '%s'\n", filename);
}
else {
TermStruct* val = def->term()->isStruct();
char name[256];
char type[64];
char intel[64];
char region[64];
char system[64];
char parent_type[64];
int parent_id = 0;
int id = 0;
int iff = -1;
Vec3 loc = Vec3(1.0e9f,0.0f,0.0f);
List<CombatUnit> unit_list;
char unit_name[64];
char unit_regnum[16];
char unit_design[64];
char unit_skin[64];
int unit_class = 0;
int unit_count = 1;
int unit_dead = 0;
int unit_damage = 0;
int unit_heading= 0;
int unit_index = 0;
*name = 0;
*type = 0;
*intel = 0;
*region = 0;
*system = 0;
*parent_type = 0;
*unit_name = 0;
*unit_regnum = 0;
*unit_design = 0;
*unit_skin = 0;
strcpy_s(intel, "KNOWN");
// all groups in this OOB default to the IFF of the main force
if (force)
iff = force->GetIFF();
for (int i = 0; i < val->elements()->size(); i++) {
TermDef* pdef = val->elements()->at(i)->isDef();
if (pdef && (iff < 0 || team < 0 || iff == team)) {
GET_DEF_TEXT(name);
else GET_DEF_TEXT(type);
else GET_DEF_TEXT(intel);
else GET_DEF_TEXT(region);
else GET_DEF_TEXT(system);
else GET_DEF_VEC(loc);
else GET_DEF_TEXT(parent_type);
else GET_DEF_NUM(parent_id);
void
CampaignPlanStrategic::AssignZones(Combatant* c)
{
// find the list of assignable groups, in priority order:
List<CombatGroup> groups;
BuildGroupList(c->GetForce(), groups);
groups.sort();
// for each group, assign a zone:
ListIter<CombatGroup> g_iter = groups;
// first pass: fighter and attack squadrons assigned to star bases
while (++g_iter) {
CombatGroup* g = g_iter.value();
int gtype = g->Type();
if (gtype == CombatGroup::ATTACK_SQUADRON ||
gtype == CombatGroup::FIGHTER_SQUADRON ||
gtype == CombatGroup::INTERCEPT_SQUADRON) {
CombatGroup* parent = g->GetParent();
if (parent && parent->Type() == CombatGroup::WING)
parent = parent->GetParent();
if (!parent || parent->Type() == CombatGroup::CARRIER_GROUP)
continue;
// these groups are attached to fixed resources,
// so they must be assigned to the parent's zone:
CombatZone* parent_zone = campaign->GetZone(parent->GetRegion());
if (parent_zone) {
ZoneForce* parent_force = parent_zone->FindForce(g->GetIFF());
if (parent_force) {
g->SetAssignedZone(parent_zone);
parent_force->AddNeed(g->Type(), -(g->Value()));
}
}
}
}
// second pass: carrier groups
g_iter.reset();
while (++g_iter) {
CombatGroup* g = g_iter.value();
int gtype = g->Type();
if (gtype == CombatGroup::CARRIER_GROUP) {
int current_zone_need = 0;
int highest_zone_need = 0;
CombatZone* highest_zone = 0;
ZoneForce* highest_force = 0;
CombatZone* current_zone = 0;
ZoneForce* current_force = 0;
List<CombatZone> possible_zones;
if (g->IsZoneLocked()) {
current_zone = g->GetAssignedZone();
current_force = current_zone->FindForce(g->GetIFF());
}
else {
ListIter<CombatZone> z_iter = campaign->GetZones();
while (++z_iter) {
CombatZone* zone = z_iter.value();
ZoneForce* force = zone->FindForce(g->GetIFF());
int need = force->GetNeed(CombatGroup::CARRIER_GROUP) +
force->GetNeed(CombatGroup::ATTACK_SQUADRON) +
force->GetNeed(CombatGroup::FIGHTER_SQUADRON) +
force->GetNeed(CombatGroup::INTERCEPT_SQUADRON);
if (g->IsSystemLocked() && zone->System() != g->GetAssignedSystem())
continue;
possible_zones.append(zone);
if (zone->HasRegion(g->GetRegion())) {
current_zone_need = need;
current_zone = zone;
current_force = force;
}
if (need > highest_zone_need) {
highest_zone_need = need;
highest_zone = zone;
highest_force = force;
}
}
}
CombatZone* assigned_zone = current_zone;
ZoneForce* assigned_force = current_force;
if (highest_zone_need > current_zone_need) {
assigned_zone = highest_zone;
assigned_force = highest_force;
}
// if we couldn't find anything suitable,
// just pick a zone at random:
if (!assigned_zone) {
if (possible_zones.isEmpty())
possible_zones.append(campaign->GetZones());
int nzones = possible_zones.size();
int n = RandomIndex() % nzones;
assigned_zone = possible_zones.at(n);
assigned_force = assigned_zone->FindForce(g->GetIFF());
}
if (assigned_force && assigned_zone) {
Text assigned_rgn;
if (!campaign->GetZone(g->GetRegion())) {
assigned_rgn = *assigned_zone->GetRegions().at(0);
g->AssignRegion(assigned_rgn);
}
g->SetAssignedZone(assigned_zone);
assigned_force->AddNeed(g->Type(), -(g->Value()));
// also assign the carrier's wing and squadrons to the same zone:
ListIter<CombatGroup> squadron = g->GetComponents();
while (++squadron) {
squadron->SetAssignedZone(assigned_zone);
assigned_force->AddNeed(squadron->Type(), -(squadron->Value()));
if (squadron->Type() == CombatGroup::WING) {
ListIter<CombatGroup> s = squadron->GetComponents();
while (++s) {
s->SetAssignedZone(assigned_zone);
assigned_force->AddNeed(s->Type(), -(s->Value()));
}
}
}
}
}
}
// third pass: everything else
g_iter.reset();
while (++g_iter) {
CombatGroup* g = g_iter.value();
int gtype = g->Type();
if (gtype == CombatGroup::BATTLE_GROUP || gtype == CombatGroup::DESTROYER_SQUADRON) {
int current_zone_need = 0;
int highest_zone_need = 0;
CombatZone* highest_zone = 0;
ZoneForce* highest_force = 0;
CombatZone* current_zone = 0;
ZoneForce* current_force = 0;
List<CombatZone> possible_zones;
if (g->IsZoneLocked()) {
current_zone = g->GetAssignedZone();
current_force = current_zone->FindForce(g->GetIFF());
}
else {
ListIter<CombatZone> z_iter = campaign->GetZones();
while (++z_iter) {
CombatZone* zone = z_iter.value();
ZoneForce* force = zone->FindForce(g->GetIFF());
int need = force->GetNeed(g->Type());
if (g->IsSystemLocked() && zone->System() != g->GetAssignedSystem())
continue;
possible_zones.append(zone);
// battle groups can do double-duty:
if (gtype == CombatGroup::BATTLE_GROUP)
need += force->GetNeed(CombatGroup::DESTROYER_SQUADRON);
if (zone->HasRegion(g->GetRegion())) {
current_zone_need = need;
current_zone = zone;
current_force = force;
}
if (need > highest_zone_need) {
highest_zone_need = need;
highest_zone = zone;
highest_force = force;
}
}
}
if (highest_zone_need > current_zone_need) {
g->SetAssignedZone(highest_zone);
if (highest_force)
highest_force->AddNeed(g->Type(), -(g->Value()));
}
else {
if (!current_zone) {
if (possible_zones.isEmpty())
possible_zones.append(campaign->GetZones());
int nzones = possible_zones.size();
int n = RandomIndex() % nzones;
current_zone = possible_zones.at(n);
current_force = current_zone->FindForce(g->GetIFF());
}
g->SetAssignedZone(current_zone);
if (current_force)
current_force->AddNeed(g->Type(), -(g->Value()));
Text assigned_rgn;
if (!campaign->GetZone(g->GetRegion())) {
assigned_rgn = *current_zone->GetRegions().at(0);
g->AssignRegion(assigned_rgn);
}
}
}
}
}
