_debugMode(false), _aborted(false), _itemId(0), _objectiveType(-1), _objectivesDestroyed(0), _objectivesNeeded(0), _unitsFalling(false), _cheating(false), _tuReserved(BA_NONE), _kneelReserved(false), _depth(0), _ambience(-1)

{

_tileSearch.resize(11*11);

for (int i = 0; i < 121; ++i)

{

_tileSearch[i].x = ((i%11) - 5);

_tileSearch[i].y = ((i/11) - 5);

}

{

_mapsize_x = node["width"].as<int>(_mapsize_x);

_mapsize_y = node["length"].as<int>(_mapsize_y);

_mapsize_z = node["height"].as<int>(_mapsize_z);

_missionType = node["missionType"].as<std::string>(_missionType);

_globalShade = node["globalshade"].as<int>(_globalShade);

_turn = node["turn"].as<int>(_turn);

_depth = node["depth"].as<int>(_depth);

int selectedUnit = node["selectedUnit"].as<int>();

for (YAML::const_iterator i = node["mapdatasets"].begin(); i != node["mapdatasets"].end(); ++i)

{

std::string name = i->as<std::string>();

MapDataSet *mds = rule->getMapDataSet(name);

_mapDataSets.push_back(mds);

}

initMap(_mapsize_x, _mapsize_y, _mapsize_z);

if (!node["tileTotalBytesPer"])

{

// binary tile data not found, load old-style text tiles :(

for (YAML::const_iterator i = node["tiles"].begin(); i != node["tiles"].end(); ++i)

{

Position pos = (*i)["position"].as<Position>();

getTile(pos)->load((*i));

}

}

else

{

// load key to how the tile data was saved

Tile::SerializationKey serKey;

size_t totalTiles = node["totalTiles"].as<size_t>();

memset(&serKey, 0, sizeof(Tile::SerializationKey));

serKey.index = node["tileIndexSize"].as<Uint8>(serKey.index);

serKey.totalBytes = node["tileTotalBytesPer"].as<Uint32>(serKey.totalBytes);

serKey._fire = node["tileFireSize"].as<Uint8>(serKey._fire);

serKey._smoke = node["tileSmokeSize"].as<Uint8>(serKey._smoke);

serKey._mapDataID = node["tileIDSize"].as<Uint8>(serKey._mapDataID);

serKey._mapDataSetID = node["tileSetIDSize"].as<Uint8>(serKey._mapDataSetID);

serKey.boolFields = node["tileBoolFieldsSize"].as<Uint8>(1); // boolean flags used to be stored in an unmentioned byte (Uint8) :|

// load binary tile data!

YAML::Binary binTiles = node["binTiles"].as<YAML::Binary>();

Uint8 *r = (Uint8*)binTiles.data();

Uint8 *dataEnd = r + totalTiles * serKey.totalBytes;

while (r < dataEnd)

{

int index = unserializeInt(&r, serKey.index);

assert (index >= 0 && index < _mapsize_x * _mapsize_z * _mapsize_y);

_tiles[index]->loadBinary(r, serKey); // loadBinary's privileges to advance *r have been revoked

r += serKey.totalBytes-serKey.index; // r is now incremented strictly by totalBytes in case there are obsolete fields present in the data

}

}

if (_missionType == "STR_BASE_DEFENSE")

{

if (node["moduleMap"])

{

_baseModules = node["moduleMap"].as<std::vector< std::vector<std::pair<int, int> > > >();

}

else

{

// backwards compatibility: imperfect solution, modules that were completely destroyed

// prior to saving and updating builds will be counted as indestructible.

calculateModuleMap();

}

}

for (YAML::const_iterator i = node["nodes"].begin(); i != node["nodes"].end(); ++i)

{

Node *n = new Node();

n->load(*i);

_nodes.push_back(n);

}

for (YAML::const_iterator i = node["units"].begin(); i != node["units"].end(); ++i)

{

UnitFaction faction = (UnitFaction)(*i)["faction"].as<int>();

UnitFaction originalFaction = (UnitFaction)(*i)["originalFaction"].as<int>(faction);

int id = (*i)["soldierId"].as<int>();

BattleUnit *unit;

if (id < BattleUnit::MAX_SOLDIER_ID) // Unit is linked to a geoscape soldier

{

// look up the matching soldier

unit = new BattleUnit(savedGame->getSoldier(id), _depth);

}

else

{

std::string type = (*i)["genUnitType"].as<std::string>();

std::string armor = (*i)["genUnitArmor"].as<std::string>();

// create a new Unit.

if(!rule->getUnit(type) || !rule->getArmor(armor)) continue;

unit = new BattleUnit(rule->getUnit(type), originalFaction, id, rule->getArmor(armor), savedGame->getDifficulty(), _depth);

}

unit->load(*i);

unit->setSpecialWeapon(this, rule);

_units.push_back(unit);

if (faction == FACTION_PLAYER)

{

if ((unit->getId() == selectedUnit) || (_selectedUnit == 0 && !unit->isOut()))

_selectedUnit = unit;

}

if (unit->getStatus() != STATUS_DEAD)

{

if (const YAML::Node &ai = (*i)["AI"])

{

BattleAIState *aiState;

if (faction == FACTION_NEUTRAL)

{

aiState = new CivilianBAIState(this, unit, 0);

}

else if (faction == FACTION_HOSTILE)

{

aiState = new AlienBAIState(this, unit, 0);

}

else

{

continue;

}

aiState->load(ai);

unit->setAIState(aiState);

}

}

}

// matches up tiles and units

resetUnitTiles();

std::string fromContainer[3] = { "items", "recoverConditional", "recoverGuaranteed" };

std::vector<BattleItem*> *toContainer[3] = {&_items, &_recoverConditional, &_recoverGuaranteed};

for (int pass = 0; pass != 3; ++pass)

{

for (YAML::const_iterator i = node[fromContainer[pass]].begin(); i != node[fromContainer[pass]].end(); ++i)

{

std::string type = (*i)["type"].as<std::string>();

_itemId = (*i)["id"].as<int>(_itemId);

if (rule->getItem(type))

{

BattleItem *item = new BattleItem(rule->getItem(type), &_itemId);

item->load(*i);

type = (*i)["inventoryslot"].as<std::string>();

if (type != "NULL")

item->setSlot(rule->getInventory(type));

int owner = (*i)["owner"].as<int>();

int prevOwner = (*i)["previousOwner"].as<int>(-1);

int unit = (*i)["unit"].as<int>();

// match up items and units

for (std::vector<BattleUnit*>::iterator bu = _units.begin(); bu != _units.end(); ++bu)

{

if ((*bu)->getId() == owner)

{

item->moveToOwner(*bu);

}

if ((*bu)->getId() == unit)

{

item->setUnit(*bu);

}

}

for (std::vector<BattleUnit*>::iterator bu = _units.begin(); bu != _units.end(); ++bu)

{

if ((*bu)->getId() == prevOwner)

{

item->setPreviousOwner(*bu);

}

}

// match up items and tiles

if (item->getSlot() && item->getSlot()->getType() == INV_GROUND)

{

Position pos = (*i)["position"].as<Position>();

if (pos.x != -1)

getTile(pos)->addItem(item, rule->getInventory("STR_GROUND"));

}

toContainer[pass]->push_back(item);

}

}

}

// tie ammo items to their weapons, running through the items again

std::vector<BattleItem*>::iterator weaponi = _items.begin();

for (YAML::const_iterator i = node["items"].begin(); i != node["items"].end(); ++i)

{

if (rule->getItem((*i)["type"].as<std::string>()))

{

int ammo = (*i)["ammoItem"].as<int>();

if (ammo != -1)

{

for (std::vector<BattleItem*>::iterator ammoi = _items.begin(); ammoi != _items.end(); ++ammoi)

{

if ((*ammoi)->getId() == ammo)

{

(*weaponi)->setAmmoItem((*ammoi));

break;

}

}

}

++weaponi;

}

}

_objectiveType = node["objectiveType"].as<int>(_objectiveType);

_objectivesDestroyed = node["objectivesDestroyed"].as<int>(_objectivesDestroyed);

_objectivesNeeded = node["objectivesNeeded"].as<int>(_objectivesNeeded);

_tuReserved = (BattleActionType)node["tuReserved"].as<int>(_tuReserved);

_kneelReserved = node["kneelReserved"].as<bool>(_kneelReserved);

_ambience = node["ambience"].as<int>(_ambience);

_music = node["music"].as<std::string>(_music);

{

ResourcePack *res = game->getResourcePack();

for (std::vector<MapDataSet*>::const_iterator i = _mapDataSets.begin(); i != _mapDataSets.end(); ++i)

{

(*i)->loadData();

if (game->getRuleset()->getMCDPatch((*i)->getName()))

{

game->getRuleset()->getMCDPatch((*i)->getName())->modifyData(*i);

}

}

int mdsID, mdID;

for (int i = 0; i < _mapsize_z * _mapsize_y * _mapsize_x; ++i)

{

for (int part = 0; part < 4; ++part)

{

_tiles[i]->getMapData(&mdID, &mdsID, part);

if (mdID != -1 && mdsID != -1)

{

_tiles[i]->setMapData(_mapDataSets[mdsID]->getObjects()->at(mdID), mdID, mdsID, part);

}

}

}

initUtilities(res);

getTileEngine()->calculateSunShading();

getTileEngine()->calculateTerrainLighting();

getTileEngine()->calculateUnitLighting();

getTileEngine()->recalculateFOV();

{

YAML::Node node;

if (_objectivesNeeded)

{

node["objectivesDestroyed"] = _objectivesDestroyed;

node["objectivesNeeded"] = _objectivesNeeded;

node["objectiveType"] = _objectiveType;

}

node["width"] = _mapsize_x;

node["length"] = _mapsize_y;

node["height"] = _mapsize_z;

node["missionType"] = _missionType;

node["globalshade"] = _globalShade;

node["turn"] = _turn;

node["selectedUnit"] = (_selectedUnit?_selectedUnit->getId():-1);

for (std::vector<MapDataSet*>::const_iterator i = _mapDataSets.begin(); i != _mapDataSets.end(); ++i)

{

node["mapdatasets"].push_back((*i)->getName());

}

#if 0

for (int i = 0; i < _mapsize_z * _mapsize_y * _mapsize_x; ++i)

{

if (!_tiles[i]->isVoid())

{

node["tiles"].push_back(_tiles[i]->save());

}

}

#else

// first, write out the field sizes we're going to use to write the tile data

node["tileIndexSize"] = Tile::serializationKey.index;

node["tileTotalBytesPer"] = Tile::serializationKey.totalBytes;

node["tileFireSize"] = Tile::serializationKey._fire;

node["tileSmokeSize"] = Tile::serializationKey._smoke;

node["tileIDSize"] = Tile::serializationKey._mapDataID;

node["tileSetIDSize"] = Tile::serializationKey._mapDataSetID;

node["tileBoolFieldsSize"] = Tile::serializationKey.boolFields;

size_t tileDataSize = Tile::serializationKey.totalBytes * _mapsize_z * _mapsize_y * _mapsize_x;

Uint8* tileData = (Uint8*) calloc(tileDataSize, 1);

Uint8* w = tileData;

for (int i = 0; i < _mapsize_z * _mapsize_y * _mapsize_x; ++i)

{

if (!_tiles[i]->isVoid())

{

serializeInt(&w, Tile::serializationKey.index, i);

_tiles[i]->saveBinary(&w);

}

else

{

tileDataSize -= Tile::serializationKey.totalBytes;

}

}

node["totalTiles"] = tileDataSize / Tile::serializationKey.totalBytes; // not strictly necessary, just convenient

node["binTiles"] = YAML::Binary(tileData, tileDataSize);

free(tileData);

#endif

for (std::vector<Node*>::const_iterator i = _nodes.begin(); i != _nodes.end(); ++i)

{

node["nodes"].push_back((*i)->save());

}

if (_missionType == "STR_BASE_DEFENSE")

{

node["moduleMap"] = _baseModules;

}

for (std::vector<BattleUnit*>::const_iterator i = _units.begin(); i != _units.end(); ++i)

{

node["units"].push_back((*i)->save());

}

for (std::vector<BattleItem*>::const_iterator i = _items.begin(); i != _items.end(); ++i)

{

node["items"].push_back((*i)->save());

}

node["tuReserved"] = (int)_tuReserved;

node["kneelReserved"] = _kneelReserved;

node["depth"] = _depth;

node["ambience"] = _ambience;

for (std::vector<BattleItem*>::const_iterator i = _recoverGuaranteed.begin(); i != _recoverGuaranteed.end(); ++i)

{

node["recoverGuaranteed"].push_back((*i)->save());

}

for (std::vector<BattleItem*>::const_iterator i = _recoverConditional.begin(); i != _recoverConditional.end(); ++i)

{

node["recoverConditional"].push_back((*i)->save());

}

node["music"] = _music;

return node;

{

if (!_nodes.empty())

{

for (int i = 0; i < _mapsize_z * _mapsize_y * _mapsize_x; ++i)

{

delete _tiles[i];

}

delete[] _tiles;

for (std::vector<Node*>::iterator i = _nodes.begin(); i != _nodes.end(); ++i)

{

delete *i;

}

_nodes.clear();

_mapDataSets.clear();

}

_mapsize_x = mapsize_x;

_mapsize_y = mapsize_y;

_mapsize_z = mapsize_z;

_tiles = new Tile*[_mapsize_z * _mapsize_y * _mapsize_x];

/* create tile objects */

for (int i = 0; i < _mapsize_z * _mapsize_y * _mapsize_x; ++i)

{

Position pos;

getTileCoords(i, &pos.x, &pos.y, &pos.z);

_tiles[i] = new Tile(pos);

}

{

delete _pathfinding;

delete _tileEngine;

_pathfinding = new Pathfinding(this);

_tileEngine = new TileEngine(this, res->getVoxelData());

{

*z = index / (_mapsize_y * _mapsize_x);

*y = (index % (_mapsize_y * _mapsize_x)) / _mapsize_x;

*x = (index % (_mapsize_y * _mapsize_x)) % _mapsize_x;

{

if (_side == FACTION_PLAYER)

{

if (_selectedUnit && _selectedUnit->getOriginalFaction() == FACTION_PLAYER)

_lastSelectedUnit = _selectedUnit;

_selectedUnit = 0;

_side = FACTION_HOSTILE;

}

else if (_side == FACTION_HOSTILE)

{

_side = FACTION_NEUTRAL;

// if there is no neutral team, we skip this and instantly prepare the new turn for the player

if (selectNextPlayerUnit() == 0)

{

prepareNewTurn();

_turn++;

_side = FACTION_PLAYER;

if (_lastSelectedUnit && _lastSelectedUnit->isSelectable(FACTION_PLAYER, false, false))

_selectedUnit = _lastSelectedUnit;

else

selectNextPlayerUnit();

while (_selectedUnit && _selectedUnit->getFaction() != FACTION_PLAYER)

selectNextPlayerUnit();

}

}

else if (_side == FACTION_NEUTRAL)

{

prepareNewTurn();

_turn++;

_side = FACTION_PLAYER;

if (_lastSelectedUnit && _lastSelectedUnit->isSelectable(FACTION_PLAYER, false, false))

_selectedUnit = _lastSelectedUnit;

else

selectNextPlayerUnit();

while (_selectedUnit && _selectedUnit->getFaction() != FACTION_PLAYER)

selectNextPlayerUnit();

}

int liveSoldiers, liveAliens;

_battleState->getBattleGame()->tallyUnits(liveAliens, liveSoldiers);

if ((_turn > 10 && liveAliens <= 2) || _turn > 20)

{

_cheating = true;

}

if (_side == FACTION_PLAYER)

{

// update the "number of turns since last spotted"

for (std::vector<BattleUnit*>::iterator i = _units.begin(); i != _units.end(); ++i)

{

if ((*i)->getTurnsSinceSpotted() < 255)

{

(*i)->setTurnsSinceSpotted((*i)->getTurnsSinceSpotted() + 1);

}

if (_cheating && (*i)->getFaction() == FACTION_PLAYER && !(*i)->isOut())

{

(*i)->setTurnsSinceSpotted(0);

}

}

}

// hide all aliens (VOF calculations below will turn them visible again)

for (std::vector<BattleUnit*>::iterator i = _units.begin(); i != _units.end(); ++i)

{

if ((*i)->getFaction() == _side)

{

(*i)->prepareNewTurn();

}

if ((*i)->getFaction() != FACTION_PLAYER)

{

(*i)->setVisible(false);

}

}

// re-run calculateFOV() *after* all aliens have been set not-visible

_tileEngine->recalculateFOV();

if (_side != FACTION_PLAYER)

selectNextPlayerUnit();

{

for (int i = 0; i < _mapsize_z * _mapsize_y * _mapsize_x; ++i)

{

_tiles[i]->setDiscovered(true, 2);

}

_debugMode = true;

{

for (std::vector<BattleUnit*>::iterator i = _units.begin(); i != _units.end(); ++i)

{

if (!(*i)->isOut())

{

int size = (*i)->getArmor()->getSize() - 1;

if ((*i)->getTile() && (*i)->getTile()->getUnit() == (*i))

{

for (int x = size; x >= 0; x--)

{

for (int y = size; y >= 0; y--)

{

getTile((*i)->getTile()->getPosition() + Position(x,y,0))->setUnit(0);

}

}

}

for (int x = size; x >= 0; x--)

{

for (int y = size; y >= 0; y--)

{

Tile *t = getTile((*i)->getPosition() + Position(x,y,0));

t->setUnit((*i), getTile(t->getPosition() + Position(0,0,-1)));

}

}

}

if ((*i)->getFaction() == FACTION_PLAYER)

{

(*i)->setVisible(true);

}

}

{

if (!_storageSpace.empty())

{

for (std::vector<BattleItem*>::iterator it = t->getInventory()->begin(); it != t->getInventory()->end();)

{

if ((*it)->getSlot()->getId() == "STR_GROUND")

{

getTile(_storageSpace.at(RNG::generate(0, _storageSpace.size() -1)))->addItem(*it, (*it)->getSlot());

it = t->getInventory()->erase(it);

}