void NetCityResources::Unpacketize(uint16 id, uint8 *buf, uint16 size)
{
uint16 pos = 0;
uint16 packid;
PULLID(packid);
Assert(packid == k_PACKET_RESOURCES_ID);
Unit city;
PULLLONGTYPE(city, Unit);
Assert(g_theUnitPool->IsValid(city));
if(!g_theUnitPool->IsValid(city))
return;
m_cityData = city.AccessData()->GetCityData();
#ifdef CTP1_TRADE
PULLLONG(m_cityData->m_resources.m_numGoods);
PULLLONG(m_cityData->m_resources.m_totalResources);
Assert(m_cityData->m_resources.m_numGoods == g_theResourceDB->NumRecords());
sint32 i;
for(i = 0; i < m_cityData->m_resources.m_numGoods; i++) {
PULLLONG(m_cityData->m_resources.m_supply[i]);
}
#endif
Assert(pos == size);
}
void NetExclusions::Unpacketize(uint16 id, uint8 *buf, uint16 size)
{
uint16 packid;
uint16 pos = 0;
PULLID(packid);
Assert(packid == k_PACKET_EXCLUSIONS_ID);
if(!g_exclusions) {
g_exclusions = new Exclusions();
}
PULLLONG(g_exclusions->m_numUnits);
PULLLONG(g_exclusions->m_numBuildings);
PULLLONG(g_exclusions->m_numWonders);
delete [] g_exclusions->m_units;
delete [] g_exclusions->m_buildings;
delete [] g_exclusions->m_wonders;
g_exclusions->m_units = new sint32[g_exclusions->m_numUnits];
g_exclusions->m_buildings = new sint32[g_exclusions->m_numBuildings];
g_exclusions->m_wonders = new sint32[g_exclusions->m_numWonders];
memset(g_exclusions->m_units, 0, sizeof(sint32) * g_exclusions->m_numUnits);
memset(g_exclusions->m_buildings, 0, sizeof(sint32) * g_exclusions->m_numBuildings);
memset(g_exclusions->m_wonders, 0, sizeof(sint32) * g_exclusions->m_numWonders);
sint32 i;
sint32 bitPos;
uint8 next;
for(i = 0; i < g_exclusions->m_numUnits; i += 8) {
PULLBYTE(next);
for(bitPos = 0; (bitPos < 8) && ((i + bitPos) < g_exclusions->m_numUnits); bitPos++) {
if(next & (1 << bitPos)) {
g_exclusions->ExcludeUnit(i + bitPos, TRUE);
}
}
}
for(i = 0; i < g_exclusions->m_numBuildings; i += 8) {
PULLBYTE(next);
for(bitPos = 0; (bitPos < 8) && ((i + bitPos) < g_exclusions->m_numBuildings); bitPos++) {
if(next & (1 << bitPos)) {
g_exclusions->ExcludeBuilding(i + bitPos, TRUE);
}
}
}
for(i = 0; i < g_exclusions->m_numWonders; i += 8) {
PULLBYTE(next);
for(bitPos = 0; (bitPos < 8) && ((i + bitPos) < g_exclusions->m_numWonders); bitPos++) {
if(next & (1 << bitPos)) {
g_exclusions->ExcludeWonder(i + bitPos, TRUE);
}
}
}
}
void NetGuid::Unpacketize(uint16 id, uint8 *buf, uint16 size)
{
sint32 pos = 0;
uint16 packid;
PULLID(packid);
Assert(packid == k_PACKET_GUID_ID);
GUID guid;
memcpy((uint8*)&guid, &buf[pos], sizeof(GUID));
pos += sizeof(GUID);
g_network.SetGuid(id, &guid);
Assert(pos == size);
}
void NetCivilization::Unpacketize(uint16 id, uint8 *buf, uint16 size)
{
sint32 pos = 0;
uint16 packid;
uint16 tmp ;
PULLID(packid);
Assert(packid == k_PACKET_CIVILIZATION_ID);
Civilisation cid;
PULLLONGTYPE(cid, Civilisation);
g_network.CheckReceivedObject((uint32)cid);
if(!g_theCivilisationPool)
return;
if(!g_theCivilisationPool->IsValid(cid)) {
m_data = new CivilisationData(cid);
} else {
m_data = g_theCivilisationPool->AccessData(cid);
}
m_data->m_id = (uint32)cid;
PULLBYTETYPE(m_data->m_owner, PLAYER_INDEX);
PULLBYTETYPE(m_data->m_gender, GENDER);
PULLSHORT(tmp) ;
m_data->m_civ = static_cast<sint32>(tmp);
PULLSTRING(m_data->m_leader_name);
PULLSTRING(m_data->m_civilisation_name);
PULLSTRING(m_data->m_country_name);
PULLSTRING(m_data->m_singular_name);
PULLSTRING(m_data->m_personality_description);
uint16 numCityNames;
PULLSHORT(numCityNames);
sint32 i;
for(i = 0; i < numCityNames; i++) {
PULLBYTE(m_data->m_cityname_count[i]);
}
if(!g_theCivilisationPool->IsValid(cid)) {
g_theCivilisationPool->HackSetKey(((uint32)cid + k_ID_KEY_MASK) + 1);
g_theCivilisationPool->Insert(m_data);
*g_player[m_data->m_owner]->m_civilisation = cid;
}
}
void NetSetPlayerGuid::Unpacketize(uint16 id, uint8 *buf, uint16 size)
{
sint32 pos = 0;
uint16 packid;
PULLID(packid);
Assert(packid == k_PACKET_SET_PLAYER_GUID_ID);
PULLBYTE(m_player);
GUID guid;
memcpy((uint8*)&guid, &buf[pos], sizeof(GUID));
pos += sizeof(GUID);
if(g_player[m_player]) {
g_player[m_player]->m_networkGuid = guid;
}
Assert(pos == size);
}
void NetSetLeaderName::Unpacketize(uint16 id, uint8 *buf, uint16 size)
{
sint32 pos = 0;
uint16 packid;
PULLID(packid);
Assert(packid == k_PACKET_SET_LEADER_NAME_ID);
MBCHAR nbuf[1024];
PULLBYTE(m_player);
PULLSTRING(nbuf);
if(g_player[m_player]) {
g_player[m_player]->m_civilisation->AccessData()->SetLeaderName(nbuf);
if(g_networkPlayersScreen) {
g_networkPlayersScreen->UpdateData();
}
}
}
//----------------------------------------------------------------------------
//
// Name : NetVision::Unpacketize
//
// Description: Retrieve the data from a received application data packet.
//
// Parameters : id : Sender identification?
// buf : Buffer with received message
// size : Length of received message (in bytes)
//
// Globals : -
//
// Returns : -
//
// Remark(s) : -
//
//----------------------------------------------------------------------------
void NetVision::Unpacketize(uint16 id, uint8 *buf, uint16 size)
{
sint32 pos = 0;
uint16 packid;
PULLID(packid);
Assert(packid == k_PACKET_VISION_ID);
PULLBYTE(m_owner);
PULLSHORT(m_row);
PULLBYTE(m_numRows);
uint8 * ptr = NULL;
uint8 bitPos = 0;
Vision * vision = g_player[m_owner]->m_vision;
sint32 w = vision->m_width;
sint32 const bottom =
std::min<sint32>(m_row + m_numRows, vision->m_height);
for (sint32 y = m_row; y < bottom; ++y)
{
bitPos = 0;
ptr = &buf[pos] + ((y - m_row) * ((w+7) / 8));
for (sint32 x = 0; x < vision->m_width; ++x)
{
if(*ptr & (1 << bitPos)) {
vision->m_array[x][y] |= 0x8000;
} else {
vision->m_array[x][y] &= 0x7fff;
}
bitPos++;
if(bitPos >= 8) {
bitPos = 0;
ptr++;
}
}
}
if(bitPos != 0) {
ptr++;
}
Assert(size == ptr - buf + 1);
}
void NetCityName::Unpacketize(uint16 id, uint8* buf, uint16 size)
{
sint32 pos = 0;
uint16 packid;
PULLID(packid);
Assert(packid == k_PACKET_CITY_NAME_ID);
Unit home_city;
PULLLONGTYPE(home_city, Unit);
char name[k_MAX_NAME_LEN];
PULLSTRING(name);
if(g_theUnitPool->IsValid(home_city)) {
if(!home_city->GetCityData()) {
if(g_network.IsHost()) {
g_network.Resync(g_network.IdToIndex(id));
} else {
g_network.RequestResync(RESYNC_INVALID_UNIT);
}
} else {
strcpy(home_city.GetData()->GetCityData()->m_name, name);
if(g_network.IsHost()) {
g_network.Block(home_city.GetOwner());
g_network.SendCityName(home_city.GetData()->GetCityData());
g_network.Unblock(home_city.GetOwner());
}
if(home_city.GetOwner() == g_selected_item->GetVisiblePlayer()) {
MainControlPanel::UpdateCityList();
}
}
}
Assert(pos == size);
}
void NetCityBuildQueue::Unpacketize(uint16 id, uint8 *buf, uint16 size)
{
sint32 pos = 0;
uint16 packid;
PULLID(packid);
Assert(packid == k_PACKET_CITY_BQ_ID);
if(packid != k_PACKET_CITY_BQ_ID)
return;
Unit city;
PULLLONGTYPE(city, Unit);
Assert(g_theUnitPool->IsValid(city));
if(!g_theUnitPool->IsValid(city))
return;
m_cityData = city.AccessData()->GetCityData();
m_cityData->m_build_queue.Clear(TRUE);
sint32 len;
PULLLONG(len);
BuildNode *bn = NULL;
for(sint32 i = 0; i < len; i++) {
bn = new BuildNode;
PULLLONG(bn->m_cost);
PULLLONG(bn->m_type);
PULLLONG(bn->m_category);
PULLBYTE(bn->m_flags);
m_cityData->m_build_queue.m_list->AddTail(bn);
}
if(g_network.IsHost()) {
g_network.Block(m_cityData->m_owner);
g_network.Enqueue(m_cityData);
g_network.Unblock(m_cityData->m_owner);
}
}
void NetGameSettings::Unpacketize(uint16 id, uint8 *buf, uint16 size)
{
uint16 packid;
uint16 pos = 0;
uint32 playerMask;
PULLID(packid);
Assert(packid == k_PACKET_GAME_SETTINGS_ID);
PULLLONG(m_x);
PULLLONG(m_y);
PULLLONG(m_numPlayers);
PULLBYTE(m_gameStyle);
PULLLONG(m_movesPerSlice);
PULLLONG(m_totalTime);
PULLLONG(m_turnTime);
PULLLONG(m_cityTime);
PULLLONG(playerMask);
PULLLONG(g_theGameSettings->m_difficulty);
PULLLONG(g_theGameSettings->m_risk);
PULLLONG(g_theGameSettings->m_alienEndGame);
PULLLONG(g_theGameSettings->m_pollution);
BOOL isYwrap, isXwrap;
PULLLONG(isYwrap);
PULLLONG(isXwrap);
Assert(pos == size);
if(g_controlPanel) {
}
g_tiledMap->CopyVision();
for(sint32 p = 0; p < k_MAX_PLAYERS; p++) {
if(g_player[p]) {
g_player[p]->m_all_armies->FastKillList();
g_player[p]->GetAllUnitList()->FastKillList();
g_player[p]->GetAllCitiesList()->FastKillList();
g_player[p]->GetTradersList()->FastKillList();
g_player[p]->m_vision->Clear();
}
}
g_theUnitTree->Clear();
g_theInstallationTree->Clear();
delete g_theUnitTree;
g_theUnitTree = NULL;
delete g_theInstallationTree;
g_theInstallationTree = NULL;
g_network.ClearDeadUnits();
g_theWorld->Reset(sint16(m_x), sint16(m_y), isYwrap, isXwrap);
sint32 i;
for(i = 0; i < k_MAX_PLAYERS; i++) {
if(g_player[i]) {
delete g_player[i];
}
}
delete [] g_player;
g_player = new Player *[k_MAX_PLAYERS];
for(i = 0; i < k_MAX_PLAYERS; i++) {
g_player[i] = NULL;
}
for(i = 0; i < k_MAX_PLAYERS; i++) {
if(playerMask & (1 << i)) {
g_player[i] = new Player(i, 0, PLAYER_TYPE_HUMAN);
}
}
delete g_selected_item;
g_selected_item = new SelectedItem(m_numPlayers);
g_theUnitTree = new QuadTree<Unit>((sint16)g_theWorld->GetXWidth(),
(sint16)g_theWorld->GetYHeight(),
g_theWorld->IsYwrap());
g_theInstallationTree = new InstallationQuadTree((sint16)g_theWorld->GetXWidth(),
(sint16)g_theWorld->GetYHeight(),
g_theWorld->IsYwrap());
g_network.SetStyleFromServer(m_gameStyle, m_movesPerSlice, m_totalTime, m_turnTime, m_cityTime);
g_tiledMap->CopyVision();
gameinit_ResetForNetwork();
g_network.SetLoop(TRUE);
}
void NetCity2::Unpacketize(uint16 id, uint8 *buf, uint16 size)
{
sint32 pos = 0;
uint16 packid;
PULLID(packid);
Assert(packid == k_PACKET_CITY2_ID);
if(packid != k_PACKET_CITY2_ID)
return;
Unit home_city;
PULLLONGTYPE(home_city, Unit);
if(!g_theUnitPool->IsValid(home_city))
return;
m_data = home_city.AccessData()->GetCityData();
if(!m_data) {
if(g_network.IsClient()) {
g_network.RequestResync(RESYNC_INVALID_UNIT);
return;
} else {
g_network.Resync(g_network.IdToIndex(id));
return;
}
}
double oldgross = m_data->m_gross_food,
oldproduced = m_data->m_net_food,
oldconsumed = m_data->m_food_consumed_this_turn;
double oldLostToCrime = m_data->m_food_lost_to_crime;
sint32 oldaccum = m_data->m_accumulated_food;
PULLLONG(m_data->m_gold_lost_to_crime);
PULLLONG(m_data->m_gross_gold);
PULLLONG(m_data->m_goldFromTradeRoutes);
PULLLONG(m_data->m_gross_production);
PULLLONG(m_data->m_net_production);
PULLLONG(m_data->m_production_lost_to_crime);
PULLLONG64(m_data->m_builtWonders);
PULLDOUBLE(m_data->m_food_delta);
PULLDOUBLE(m_data->m_gross_food);
PULLDOUBLE(m_data->m_net_food);
PULLDOUBLE(m_data->m_food_lost_to_crime);
PULLDOUBLE(m_data->m_food_consumed_this_turn);
PULLLONG(m_data->m_total_pollution);
uint8 flags;
PULLBYTE(flags);
m_data->m_contribute_materials = flags & 0x01;
m_data->m_contribute_military = (flags & 0x02) >> 1;
m_data->m_buildCapitalization = (flags & 0x10) >> 4;
m_data->m_walls_nullified = (flags & 0x20) >> 5;
m_data->m_isInjoined = (flags & 0x40) >> 6;
m_data->m_buildInfrastructure = (flags & 0x80) >> 7;
PULLBYTETYPE(m_data->m_spied_upon, sint32);
PULLBYTETYPE(m_data->m_franchise_owner, sint8);
PULLBYTETYPE(m_data->m_franchiseTurnsRemaining, sint8);
PULLBYTETYPE(m_data->m_watchfulTurns, sint8);
PULLBYTETYPE(m_data->m_bioInfectionTurns, sint8);
PULLBYTETYPE(m_data->m_nanoInfectionTurns, sint8);
PULLBYTETYPE(m_data->m_convertedTo, sint8);
PULLBYTETYPE(m_data->m_convertedBy, CONVERTED_BY);
PULLLONG(m_data->m_convertedGold);
PULLLONG(m_data->m_accumulated_food);
PULLLONG(m_data->m_foodVatPollution);
sint8 govSetting;
PULLBYTE(govSetting);
if(govSetting == -1) {
m_data->m_useGovernor = FALSE;
m_data->m_buildListSequenceIndex = 0;
} else {
m_data->m_useGovernor = TRUE;
m_data->m_buildListSequenceIndex = govSetting;
}
uint8 isInitialPacket;
PULLBYTE(isInitialPacket);
#if 0
DPRINTF(k_DBG_NET, ("city: %d, %d, %d, %d, %d, %d, %d, %d, %d\n",
m_data->m_spied_upon,
m_data->m_franchise_owner,
m_data->m_franchiseTurnsRemaining,
m_data->m_ignore_happiness,
m_data->m_watchfulTurns,
m_data->m_bioInfectionTurns,
m_data->m_nanoInfectionTurns,
m_data->m_convertedTo,
m_data->m_convertedBy));
#endif
if(m_data->m_owner == g_network.GetPlayerIndex() &&
!isInitialPacket) {
Assert(oldgross == m_data->m_gross_food);
Assert(oldLostToCrime == m_data->m_food_lost_to_crime);
Assert(oldproduced == m_data->m_net_food);
Assert(oldconsumed == m_data->m_food_consumed_this_turn);
Assert(oldaccum == m_data->m_accumulated_food);
if(oldgross != m_data->m_gross_food ||
oldLostToCrime != m_data->m_food_lost_to_crime ||
oldproduced != m_data->m_net_food ||
oldconsumed != m_data->m_food_consumed_this_turn ||
oldaccum != m_data->m_accumulated_food) {
g_network.RequestResync(RESYNC_CITY_STATS);
}
}
Assert(pos == size);
}
//----------------------------------------------------------------------------
//
// Name : NetUnseenCell::Unpacketize
//
// Description: Retrieve the data from a received application data packet.
//
// Parameters : id : Sender identification?
// buf : Buffer with received message
// size : Length of received message (in bytes)
//
// Globals : -
//
// Returns : -
//
// Remark(s) : -
//
//----------------------------------------------------------------------------
void NetUnseenCell::Unpacketize(uint16 id, uint8 *buf, uint16 size)
{
uint16 pos = 0;
uint16 packid;
PULLID(packid);
Assert(packid == k_PACKET_UNSEEN_CELL_ID);
PULLBYTE(m_owner);
m_ucell = new UnseenCell;
PULLLONG(m_ucell->m_env);
PULLBYTETYPE(m_ucell->m_terrain_type, TERRAIN_TYPES);
PULLSHORT(m_ucell->m_point.x);
PULLSHORT(m_ucell->m_point.y);
PULLSHORT(m_ucell->m_move_cost);
PULLSHORT(m_ucell->m_flags);
uint8 citySize;
PULLBYTE(citySize);
if(citySize > 0) {
PULLBYTE(m_ucell->m_bioInfectedOwner);
PULLBYTE(m_ucell->m_nanoInfectedOwner);
PULLBYTE(m_ucell->m_convertedOwner);
PULLBYTE(m_ucell->m_franchiseOwner);
PULLBYTE(m_ucell->m_injoinedOwner);
PULLBYTE(m_ucell->m_happinessAttackOwner);
PULLSHORT(m_ucell->m_cityOwner);
PULLSHORT(m_ucell->m_citySpriteIndex);
PULLNEWSTRING(m_ucell->m_cityName);
SpriteState *ss = new SpriteState(0);
Unit unitID;
uint16 dbIndex;
PULLSHORT(dbIndex);
double visionRange = g_theUnitDB->Get(dbIndex, g_player[m_owner]->GetGovernmentType())->GetVisionRange();
m_ucell->m_actor = new UnitActor(ss,
unitID,
(sint32)dbIndex,
m_ucell->m_point,
m_ucell->m_cityOwner,
TRUE,
visionRange,
m_ucell->m_citySpriteIndex);
m_ucell->m_actor->SetUnitVisibility(1 << m_owner);
m_ucell->m_actor->SetSize(citySize);
m_ucell->m_actor->ChangeImage(ss, dbIndex, unitID);
}
m_ucell->m_citySize = citySize;
#ifdef BATTLE_FLAGS
PULLSHORT(m_ucell->m_battleFlags);
#endif
uint8 c, i;
PULLBYTE(c);
for(i = 0; i < c; i++) {
uint8 type;
uint8 percent;
PULLBYTE(type);
PULLBYTE(percent);
m_ucell->m_improvements->AddTail(
new UnseenImprovementInfo((TERRAIN_IMPROVEMENT)type,
(sint32)percent));
}
PULLBYTE(c);
for(i = 0; i < c; i++) {
uint8 type;
uint32 vis;
PULLBYTE(type);
PULLLONG(vis);
m_ucell->m_installations->AddTail(new UnseenInstallationInfo((sint32)type, vis));
}
m_ucell->m_tileInfo = new TileInfo;
PULLBYTE(m_ucell->m_tileInfo->m_riverPiece);
PULLBYTE(m_ucell->m_tileInfo->m_megaInfo);
uint16 terrain;
PULLSHORT(terrain);
m_ucell->m_tileInfo->m_terrainType = static_cast<uint8>(terrain);
PULLSHORT(m_ucell->m_tileInfo->m_tileNum);
for(c = 0; c < k_NUM_TRANSITIONS; c++) {
PULLBYTE(m_ucell->m_tileInfo->m_transitions[c]);
}
g_player[m_owner]->m_vision->AddUnseen(m_ucell);
}
