nofAttacker::nofAttacker(SerializedGameData& sgd, const unsigned obj_id) : nofActiveSoldier(sgd, obj_id)
{
if(state != STATE_WALKINGHOME && state != STATE_FIGUREWORK)
{
attacked_goal = sgd.PopObject<nobBaseMilitary>(GOT_UNKNOWN);
mayBeHunted = sgd.PopBool();
sgd.PopContainer(canPlayerSendAggDefender);
RTTR_Assert(canPlayerSendAggDefender.size() == gwg->GetNumPlayers());
huntingDefender = sgd.PopObject<nofAggressiveDefender>(GOT_NOF_AGGRESSIVEDEFENDER);
radius = sgd.PopUnsignedShort();
if(state == STATE_ATTACKING_WAITINGFORDEFENDER)
blocking_event = sgd.PopEvent();
else
blocking_event = nullptr;
harborPos = sgd.PopMapPoint();
shipPos = sgd.PopMapPoint();
ship_obj_id = sgd.PopUnsignedInt();
} else
{
attacked_goal = nullptr;
mayBeHunted = false;
canPlayerSendAggDefender.resize(gwg->GetNumPlayers(), 2);
huntingDefender = nullptr;
radius = 0;
blocking_event = nullptr;
harborPos = MapPoint::Invalid();
shipPos = MapPoint::Invalid(); //-V656
ship_obj_id = 0;
}
}
nobHarborBuilding::nobHarborBuilding(SerializedGameData& sgd, const unsigned obj_id)
: nobBaseWarehouse(sgd, obj_id),
expedition(sgd),
exploration_expedition(sgd),
orderware_ev(sgd.PopObject<EventManager::Event>(GOT_EVENT))
{
// ins Militärquadrat einfügen
gwg->GetMilitarySquares().Add(this);
for(unsigned i = 0; i < 6; ++i)
sea_ids[i] = sgd.PopUnsignedShort();
sgd.PopObjectContainer(wares_for_ships, GOT_WARE);
unsigned count = sgd.PopUnsignedInt();
for(unsigned i = 0; i < count; ++i)
{
FigureForShip ffs;
ffs.dest = sgd.PopMapPoint();
ffs.fig = sgd.PopObject<noFigure>(GOT_UNKNOWN);
figures_for_ships.push_back(ffs);
}
count = sgd.PopUnsignedInt();
for(unsigned i = 0; i < count; ++i)
{
SoldierForShip ffs;
ffs.dest = sgd.PopMapPoint();
ffs.attacker = sgd.PopObject<nofAttacker>(GOT_NOF_ATTACKER);
soldiers_for_ships.push_back(ffs);
}
}
CatapultStone::CatapultStone(SerializedGameData& sgd, const unsigned obj_id) : GameObject(sgd, obj_id),
dest_building(sgd.PopMapPoint()),
dest_map(sgd.PopMapPoint()),
start_x(sgd.PopSignedInt()),
start_y(sgd.PopSignedInt()),
dest_x(sgd.PopSignedInt()),
dest_y(sgd.PopSignedInt()),
explode(sgd.PopBool()),
event(sgd.PopObject<EventManager::Event>(GOT_EVENT))
{
}
nofGeologist::nofGeologist(SerializedGameData& sgd, const unsigned obj_id) : nofFlagWorker(sgd, obj_id), signs(sgd.PopUnsignedShort())
{
unsigned available_nodes_count = sgd.PopUnsignedInt();
for(unsigned i = 0; i < available_nodes_count; ++i)
{
MapPoint p = sgd.PopMapPoint();
available_nodes.push_back(p);
}
node_goal = sgd.PopMapPoint();
for(unsigned i = 0; i < 5; ++i)
resAlreadyFound[i] = sgd.PopBool();
}
noFigure::noFigure(SerializedGameData& sgd, const unsigned obj_id) : noMovable(sgd, obj_id),
fs(FigureState(sgd.PopUnsignedChar())),
job_(Job(sgd.PopUnsignedChar())),
player(sgd.PopUnsignedChar()),
cur_rs(sgd.PopObject<RoadSegment>(GOT_ROADSEGMENT)),
rs_pos(sgd.PopUnsignedShort()),
rs_dir(sgd.PopBool()),
on_ship(sgd.PopBool()),
last_id(0xFFFFFFFF)
{
if(fs == FS_GOTOGOAL || fs == FS_GOHOME)
goal_ = sgd.PopObject<noRoadNode>(GOT_UNKNOWN);
else
goal_ = 0;
waiting_for_free_node = sgd.PopBool();
if(fs == FS_WANDER)
{
wander_way = sgd.PopUnsignedShort();
wander_tryings = sgd.PopUnsignedShort();
flagPos_ = sgd.PopMapPoint();
flag_obj_id = sgd.PopUnsignedInt();
burned_wh_id = sgd.PopUnsignedInt();
}
}
TradeGraph::TradeGraph(SerializedGameData& sgd, const GameWorldGame* const gwg) :
gwg(gwg), player(sgd.PopUnsignedChar()), size(sgd.PopMapPoint()),
trade_graph(size.x* size.y)
{
for(unsigned i = 0; i < trade_graph.size(); ++i)
trade_graph[i].Deserialize(sgd);
}
Ware::Ware(SerializedGameData& sgd, const unsigned obj_id) : GameObject(sgd, obj_id),
next_dir(sgd.PopUnsignedChar()),
state(State(sgd.PopUnsignedChar())),
location(sgd.PopObject<noRoadNode>(GOT_UNKNOWN)),
type(GoodType(sgd.PopUnsignedChar())),
goal(sgd.PopObject<noBaseBuilding>(GOT_UNKNOWN)),
next_harbor(sgd.PopMapPoint())
{}
nofTradeLeader::nofTradeLeader(SerializedGameData& sgd, const unsigned obj_id)
: noFigure(sgd, obj_id),
tr(sgd, gwg, player),
successor(sgd.PopObject<nofTradeDonkey>(GOT_NOF_TRADEDONKEY)),
start(sgd.PopMapPoint()),
goal_(sgd.PopMapPoint()),
fails(sgd.PopUnsignedChar())
{
}
nofFarmhand::nofFarmhand(SerializedGameData& sgd, const unsigned obj_id) : nofBuildingWorker(sgd, obj_id), dest(sgd.PopMapPoint())
{}
TradeRoute::TradeRoute(SerializedGameData& sgd, const GameWorldGame& gwg, const unsigned char player)
: gwg(gwg), player(player), path(sgd), curPos(sgd.PopMapPoint()), curRouteIdx(sgd.PopUnsignedInt())
{}
nofCatapultMan::PossibleTarget::PossibleTarget(SerializedGameData& sgd) : pos(sgd.PopMapPoint()), distance(sgd.PopUnsignedInt())
{}
void GameWorld::Deserialize(SerializedGameData& sgd)
{
// Headinformationen
width_ = sgd.PopUnsignedShort();
height_ = sgd.PopUnsignedShort();
lt = LandscapeType(sgd.PopUnsignedChar());
// Initialisierungen
Init();
// Obj-ID-Counter setzen
GameObject::SetObjIDCounter(sgd.PopUnsignedInt());
// Trade graphs
// Only if trade is enabled
if(GAMECLIENT.GetGGS().isEnabled(ADDON_TRADE))
{
tgs.resize(sgd.PopUnsignedChar());
for(unsigned i = 0; i < tgs.size(); ++i)
tgs[i] = new TradeGraph(sgd, this);
}
// Alle Weltpunkte serialisieren
for(unsigned i = 0; i < map_size; ++i)
{
for(unsigned z = 0; z < 3; ++z)
{
nodes[i].roads[z] = sgd.PopUnsignedChar();
nodes[i].roads_real[z] = nodes[i].roads[z] ? true : false;
}
nodes[i].altitude = sgd.PopUnsignedChar();
nodes[i].shadow = sgd.PopUnsignedChar();
nodes[i].t1 = TerrainType(sgd.PopUnsignedChar());
nodes[i].t2 = TerrainType(sgd.PopUnsignedChar());
nodes[i].resources = sgd.PopUnsignedChar();
nodes[i].reserved = sgd.PopBool();
nodes[i].owner = sgd.PopUnsignedChar();
for(unsigned b = 0; b < 4; ++b)
nodes[i].boundary_stones[b] = sgd.PopUnsignedChar();
nodes[i].bq = BuildingQuality(sgd.PopUnsignedChar());
for(unsigned z = 0; z < GAMECLIENT.GetPlayerCount(); ++z)
{
MapNode::FoWData& fow = nodes[i].fow[z];
fow.visibility = Visibility(sgd.PopUnsignedChar());
// Nur im FoW können FOW-Objekte stehen
if(fow.visibility == VIS_FOW)
{
fow.last_update_time = sgd.PopUnsignedInt();
fow.object = sgd.PopFOWObject();
for(unsigned r = 0; r < 3; ++r)
fow.roads[r] = sgd.PopUnsignedChar();
fow.owner = sgd.PopUnsignedChar();
for(unsigned b = 0; b < 4; ++b)
fow.boundary_stones[b] = sgd.PopUnsignedChar();
}
else
{
fow.last_update_time = 0;
fow.object = NULL;
for(unsigned r = 0; r < 3; ++r)
fow.roads[r] = 0;
fow.owner = 0;
for(unsigned b = 0; b < 4; ++b)
fow.boundary_stones[b] = 0;
}
}
nodes[i].obj = sgd.PopObject<noBase>(GOT_UNKNOWN);
sgd.PopObjectContainer(nodes[i].figures, GOT_UNKNOWN);
nodes[i].sea_id = sgd.PopUnsignedShort();
nodes[i].harbor_id = sgd.PopUnsignedInt();
if (nodes[i].harbor_id)
{
GameWorldBase::HarborPos p(MapPoint((MapCoord) (i % width_), (MapCoord) (i / width_)));
harbor_pos.push_back(p);
}
}
// Katapultsteine deserialisieren
sgd.PopObjectContainer(catapult_stones, GOT_CATAPULTSTONE);
// Meeresinformationen deserialisieren
seas.resize(sgd.PopUnsignedInt());
for(unsigned i = 0; i < seas.size(); ++i)
{
seas[i].nodes_count = sgd.PopUnsignedInt();
}
// Hafenpositionen serialisieren
harbor_pos.resize(sgd.PopUnsignedInt());
for(unsigned i = 0; i < harbor_pos.size(); ++i)
{
harbor_pos[i].pos = sgd.PopMapPoint();
for(unsigned z = 0; z < 6; ++z)
harbor_pos[i].cps[z].sea_id = sgd.PopUnsignedShort();
for(unsigned z = 0; z < 6; ++z)
{
harbor_pos[i].neighbors[z].resize(sgd.PopUnsignedInt());
for(unsigned c = 0; c < harbor_pos[i].neighbors[z].size(); ++c)
{
harbor_pos[i].neighbors[z][c].id = sgd.PopUnsignedInt();
harbor_pos[i].neighbors[z][c].distance = sgd.PopUnsignedInt();
}
}
}
sgd.PopObjectContainer(harbor_building_sites_from_sea, GOT_BUILDINGSITE);
// BQ neu berechnen
for(unsigned y = 0; y < height_; ++y)
{
for(unsigned x = 0; x < width_; ++x)
{
SetBQ(MapPoint(x, y), GAMECLIENT.GetPlayerID());
}
}
tr.GenerateOpenGL(*this);
// Zum HQ am Anfang springen, falls dieses existiert
if(GetPlayer(GAMECLIENT.GetPlayerID()).hqPos.x != 0xFFFF)
this->MoveToMapObject(GetPlayer(GAMECLIENT.GetPlayerID()).hqPos);
}
nofActiveSoldier::nofActiveSoldier(SerializedGameData& sgd, const unsigned obj_id) : nofSoldier(sgd, obj_id),
state(SoldierState(sgd.PopUnsignedChar())),
enemy(sgd.PopObject<nofActiveSoldier>(GOT_UNKNOWN))
{
fightSpot_ = sgd.PopMapPoint();
}
TradePath::TradePath(SerializedGameData& sgd): start(sgd.PopMapPoint()), goal(sgd.PopMapPoint()), route(sgd.PopContainer(route)){}
nofShipWright::nofShipWright(SerializedGameData& sgd, const unsigned obj_id)
: nofWorkman(sgd, obj_id),
dest(sgd.PopMapPoint())
{
}