// send complete game info set! void sendOptions() { bool dummy = true; unsigned int i; if (!NetPlay.isHost || !bHosted) // Only host should act, and only if the game hasn't started yet. { ASSERT(false, "Host only routine detected for client or not hosting yet!"); return; } NETbeginEncode(NETbroadcastQueue(), NET_OPTIONS); // First send information about the game NETuint8_t(&game.type); NETstring(game.map, 128); NETuint8_t(&game.maxPlayers); NETstring(game.name, 128); NETbool(&dummy); NETuint32_t(&game.power); NETuint8_t(&game.base); NETuint8_t(&game.alliance); NETbool(&game.scavengers); for (i = 0; i < MAX_PLAYERS; i++) { NETuint8_t(&game.skDiff[i]); } // Send the list of who is still joining for (i = 0; i < MAX_PLAYERS; i++) { NETbool(&ingame.JoiningInProgress[i]); } // Same goes for the alliances for (i = 0; i < MAX_PLAYERS; i++) { unsigned int j; for (j = 0; j < MAX_PLAYERS; j++) { NETuint8_t(&alliances[i][j]); } } // Send the number of structure limits to expect NETuint32_t(&ingame.numStructureLimits); debug(LOG_NET, "(Host) Structure limits to process on client is %u", ingame.numStructureLimits); // Send the structures changed for (i = 0; i < ingame.numStructureLimits; i++) { NETuint32_t(&ingame.pStructureLimits[i].id); NETuint32_t(&ingame.pStructureLimits[i].limit); } updateLimitFlags(); NETuint8_t(&ingame.flags); NETend(); }
// accept and process incoming ping messages. bool recvPing(NETQUEUE queue) { bool isNew = false; uint8_t sender, us = selectedPlayer; uint8_t challenge[sizeof(pingChallenge)]; EcKey::Sig challengeResponse; NETbeginDecode(queue, NET_PING); NETuint8_t(&sender); NETbool(&isNew); if (isNew) { NETbin(challenge, sizeof(pingChallenge)); } else { NETbytes(&challengeResponse); } NETend(); if (sender >= MAX_PLAYERS) { debug(LOG_ERROR, "Bad NET_PING packet, sender is %d", (int)sender); return false; } // If this is a new ping, respond to it if (isNew) { challengeResponse = getMultiStats(us).identity.sign(&challenge, sizeof(pingChallenge)); NETbeginEncode(NETnetQueue(sender), NET_PING); // We are responding to a new ping isNew = false; NETuint8_t(&us); NETbool(&isNew); NETbytes(&challengeResponse); NETend(); } // They are responding to one of our pings else { if (!getMultiStats(sender).identity.empty() && !getMultiStats(sender).identity.verify(challengeResponse, pingChallenge, sizeof(pingChallenge))) { // Either bad signature, or we sent more than one ping packet and this response is to an older one than the latest. debug(LOG_NEVER, "Bad and/or old NET_PING packet, alleged sender is %d", (int)sender); return false; } // Work out how long it took them to respond ingame.PingTimes[sender] = (realTime - PingSend[sender]) / 2; // Note that we have received it PingSend[sender] = 0; } return true; }
// send complete game info set! void sendOptions() { unsigned int i; NETbeginEncode(NETbroadcastQueue(), NET_OPTIONS); // First send information about the game NETuint8_t(&game.type); NETstring(game.map, 128); NETuint8_t(&game.maxPlayers); NETstring(game.name, 128); NETbool(&game.fog); NETuint32_t(&game.power); NETuint8_t(&game.base); NETuint8_t(&game.alliance); NETbool(&game.scavengers); for (i = 0; i < MAX_PLAYERS; i++) { NETuint8_t(&game.skDiff[i]); } // Send the list of who is still joining for (i = 0; i < MAX_PLAYERS; i++) { NETbool(&ingame.JoiningInProgress[i]); } // Same goes for the alliances for (i = 0; i < MAX_PLAYERS; i++) { unsigned int j; for (j = 0; j < MAX_PLAYERS; j++) { NETuint8_t(&alliances[i][j]); } } // Send the number of structure limits to expect NETuint32_t(&ingame.numStructureLimits); debug(LOG_NET, "(Host) Structure limits to process on client is %u", ingame.numStructureLimits); // Send the structures changed for (i = 0; i < ingame.numStructureLimits; i++) { NETuint32_t(&ingame.pStructureLimits[i].id); NETuint32_t(&ingame.pStructureLimits[i].limit); } updateLimitFlags(); NETuint8_t(&ingame.flags); NETend(); }
// //////////////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////////////// // New research stuff, so you can see what others are up to! // inform others that I'm researching this. bool sendResearchStatus(STRUCTURE *psBuilding, uint32_t index, uint8_t player, bool bStart) { if (!myResponsibility(player) || gameTime < 5) { return true; } NETbeginEncode(NETgameQueue(selectedPlayer), GAME_RESEARCHSTATUS); NETuint8_t(&player); NETbool(&bStart); // If we know the building researching it then send its ID if (psBuilding) { NETuint32_t(&psBuilding->id); } else { uint32_t zero = 0; NETuint32_t(&zero); } // Finally the topic in question NETuint32_t(&index); NETend(); // Tell UI to remove from the list of available research. MakeResearchStartedPending(&asPlayerResList[player][index]); return true; }
void recvProcessDebugMappings(NETQUEUE queue) { bool val = false; NETbeginDecode(queue, GAME_DEBUG_MODE); NETbool(&val); NETend(); bool oldDebugMode = getDebugMappingStatus(); processDebugMappings(queue.index, val); bool newDebugMode = getDebugMappingStatus(); char const *cmsg; if (val) { sasprintf((char**)&cmsg, _("%s wants to enable debug mode. Enabled: %s, Disabled: %s."), getPlayerName(queue.index), getWantedDebugMappingStatuses(true).c_str(), getWantedDebugMappingStatuses(false).c_str()); } else { sasprintf((char**)&cmsg, _("%s wants to disable debug mode. Enabled: %s, Disabled: %s."), getPlayerName(queue.index), getWantedDebugMappingStatuses(true).c_str(), getWantedDebugMappingStatuses(false).c_str()); } addConsoleMessage(cmsg, DEFAULT_JUSTIFY, SYSTEM_MESSAGE); if (!oldDebugMode && newDebugMode) { addConsoleMessage(_("Debug mode now enabled!"), DEFAULT_JUSTIFY, SYSTEM_MESSAGE); } else if (oldDebugMode && !newDebugMode) { addConsoleMessage(_("Debug mode now disabled!"), DEFAULT_JUSTIFY, SYSTEM_MESSAGE); } }
static void NETcoder(PACKETDIR dir) { static const char original[] = "THIS IS A TEST STRING"; char str[sizeof(original)]; BOOL b = true; uint32_t u32 = 32; uint16_t u16 = 16; uint8_t u8 = 8; int32_t i32 = -32; int16_t i16 = -16; int8_t i8 = -8; test_enum te = test_b; sstrcpy(str, original); if (dir == PACKET_ENCODE) NETbeginEncode(0, 0); else NETbeginDecode(0); NETbool(&b); assert(b == true); NETuint32_t(&u32); assert(u32 == 32); NETuint16_t(&u16); assert(u16 == 16); NETuint8_t(&u8); assert(u8 == 8); NETint32_t(&i32); assert(i32 == -32); NETint16_t(&i16); assert(i16 == -16); NETint8_t(&i8); assert(i8 == -8); NETstring(str, sizeof(str)); assert(strncmp(str, original, sizeof(str) - 1) == 0); NETenum(&te); assert(te == test_b); }
/// Does not read/write info->droidId! static void NETQueuedDroidInfo(QueuedDroidInfo *info) { NETuint8_t(&info->player); NETenum(&info->order); NETbool(&info->subType); if (info->subType) { NETuint32_t(&info->destId); NETenum(&info->destType); } else { NETuint32_t(&info->x); NETuint32_t(&info->y); } if (info->order == DORDER_BUILD || info->order == DORDER_LINEBUILD) { NETuint32_t(&info->structRef); NETuint16_t(&info->direction); } if (info->order == DORDER_LINEBUILD) { NETuint32_t(&info->x2); NETuint32_t(&info->y2); } }
// //////////////////////////////////////////////////////////////////////////// // Send a new Droid to the other players bool SendDroid(DROID_TEMPLATE *pTemplate, uint32_t x, uint32_t y, uint8_t player, uint32_t id, const INITIAL_DROID_ORDERS *initialOrdersP) { if (!bMultiMessages) { return true; } ASSERT_OR_RETURN(false, x != 0 && y != 0, "SendDroid: Invalid droid coordinates"); ASSERT_OR_RETURN(false, player < MAX_PLAYERS, "invalid player %u", player); // Dont send other droids during campaign setup if (ingame.localJoiningInProgress) { return true; } // Only send the droid if we are responsible if (!myResponsibility(player)) { // Don't build if we are not responsible return false; } debug(LOG_SYNC, "Droid sent with id of %u", id); NETbeginEncode(NETgameQueue(selectedPlayer), GAME_DEBUG_ADD_DROID); { Position pos(x, y, 0); bool haveInitialOrders = initialOrdersP != NULL; int32_t droidType = pTemplate->droidType; NETuint8_t(&player); NETuint32_t(&id); NETPosition(&pos); NETqstring(pTemplate->name); NETint32_t(&droidType); NETuint8_t(&pTemplate->asParts[COMP_BODY]); NETuint8_t(&pTemplate->asParts[COMP_BRAIN]); NETuint8_t(&pTemplate->asParts[COMP_PROPULSION]); NETuint8_t(&pTemplate->asParts[COMP_REPAIRUNIT]); NETuint8_t(&pTemplate->asParts[COMP_ECM]); NETuint8_t(&pTemplate->asParts[COMP_SENSOR]); NETuint8_t(&pTemplate->asParts[COMP_CONSTRUCT]); NETint8_t(&pTemplate->numWeaps); for (int i = 0; i < pTemplate->numWeaps; i++) { NETuint8_t(&pTemplate->asWeaps[i]); } NETbool(&haveInitialOrders); if (haveInitialOrders) { INITIAL_DROID_ORDERS initialOrders = *initialOrdersP; NETuint32_t(&initialOrders.secondaryOrder); NETint32_t(&initialOrders.moveToX); NETint32_t(&initialOrders.moveToY); NETuint32_t(&initialOrders.factoryId); // For making scripts happy. } } debug(LOG_LIFE, "===> sending Droid from %u id of %u ", player, id); return NETend(); }
// accept and process incoming ping messages. BOOL recvPing(NETQUEUE queue) { BOOL isNew; uint8_t sender, us = selectedPlayer; NETbeginDecode(queue, NET_PING); NETuint8_t(&sender); NETbool(&isNew); NETend(); if (sender >= MAX_PLAYERS) { debug(LOG_ERROR, "Bad NET_PING packet, sender is %d", (int)sender); return false; } // If this is a new ping, respond to it if (isNew) { NETbeginEncode(NETnetQueue(sender), NET_PING); // We are responding to a new ping isNew = false; NETuint8_t(&us); NETbool(&isNew); NETend(); } // They are responding to one of our pings else { // Work out how long it took them to respond ingame.PingTimes[sender] = (gameTime2 - PingSend[sender]) / 2; // Note that we have received it PingSend[sender] = 0; } return true; }
// //////////////////////////////////////////////////////////////////////////// // Tell the host we are leaving the game 'nicely', (we wanted to) and not // because we have some kind of error. (dropped or disconnected) bool sendLeavingMsg(void) { debug(LOG_NET, "We are leaving 'nicely'"); NETbeginEncode(NETnetQueue(NET_HOST_ONLY), NET_PLAYER_LEAVING); { bool host = NetPlay.isHost; uint32_t id = selectedPlayer; NETuint32_t(&id); NETbool(&host); } NETend(); return true; }
// //////////////////////////////////////////////////////////////////////////// // Send a new Droid to the other players BOOL SendDroid(const DROID_TEMPLATE* pTemplate, uint32_t x, uint32_t y, uint8_t player, uint32_t id, const INITIAL_DROID_ORDERS *initialOrdersP) { if (!bMultiMessages) return true; ASSERT(x != 0 && y != 0, "SendDroid: Invalid droid coordinates"); ASSERT( player < MAX_PLAYERS, "invalid player %u", player); // Dont send other droids during campaign setup if (ingame.localJoiningInProgress) { return true; } // Only send the droid if we are responsible if (!myResponsibility(player)) { // Don't build if we are not responsible return false; } debug(LOG_SYNC, "Droid sent with id of %u", id); NETbeginEncode(NETgameQueue(selectedPlayer), GAME_DROID); { Position pos = { x, y, 0 }; uint32_t templateID = pTemplate->multiPlayerID; BOOL haveInitialOrders = initialOrdersP != NULL; NETuint8_t(&player); NETuint32_t(&id); NETPosition(&pos); NETuint32_t(&templateID); NETbool(&haveInitialOrders); if (haveInitialOrders) { INITIAL_DROID_ORDERS initialOrders = *initialOrdersP; NETuint32_t(&initialOrders.secondaryOrder); NETint32_t(&initialOrders.moveToX); NETint32_t(&initialOrders.moveToY); NETuint32_t(&initialOrders.factoryId); // For making scripts happy. } } debug(LOG_LIFE, "===> sending Droid from %u id of %u ",player,id); return NETend(); }
/// Does not read/write info->droidId! static void NETQueuedDroidInfo(QueuedDroidInfo *info) { NETuint8_t(&info->player); NETenum(&info->subType); switch (info->subType) { case ObjOrder: case LocOrder: NETenum(&info->order); if (info->subType == ObjOrder) { NETuint32_t(&info->destId); NETenum(&info->destType); } else { NETauto(&info->pos); } if (info->order == DORDER_BUILD || info->order == DORDER_LINEBUILD) { NETuint32_t(&info->structRef); NETuint16_t(&info->direction); } if (info->order == DORDER_LINEBUILD) { NETauto(&info->pos2); } if (info->order == DORDER_BUILDMODULE) { NETauto(&info->index); } NETbool(&info->add); break; case SecondaryOrder: NETenum(&info->secOrder); NETenum(&info->secState); break; } }
static void NETtemplate(DROID_TEMPLATE *pTempl) { NETstring(pTempl->aName, sizeof(pTempl->aName)); for (unsigned i = 0; i < ARRAY_SIZE(pTempl->asParts); ++i) { // signed, but sent as a bunch of bits... NETint32_t(&pTempl->asParts[i]); } NETuint32_t(&pTempl->buildPoints); NETuint32_t(&pTempl->powerPoints); NETuint32_t(&pTempl->storeCount); NETuint32_t(&pTempl->numWeaps); NETbool(&pTempl->stored); // other players don't need to know, but we need to keep the knowledge in the loop somehow... for (int i = 0; i < DROID_MAXWEAPS; ++i) { NETuint32_t(&pTempl->asWeaps[i]); } NETenum(&pTempl->droidType); NETuint32_t(&pTempl->multiPlayerID); }
// //////////////////////////////////////////////////////////////////////////// // options for a game. (usually recvd in frontend) void recvOptions(NETQUEUE queue) { unsigned int i; debug(LOG_NET, "Receiving options from host"); NETbeginDecode(queue, NET_OPTIONS); // Get general information about the game NETuint8_t(&game.type); NETstring(game.map, 128); NETbin(game.hash.bytes, game.hash.Bytes); uint32_t modHashesSize; NETuint32_t(&modHashesSize); ASSERT_OR_RETURN(, modHashesSize < 1000000, "Way too many mods %u", modHashesSize); game.modHashes.resize(modHashesSize); for (auto &hash : game.modHashes) { NETbin(hash.bytes, hash.Bytes); } NETuint8_t(&game.maxPlayers); NETstring(game.name, 128); NETuint32_t(&game.power); NETuint8_t(&game.base); NETuint8_t(&game.alliance); NETbool(&game.scavengers); NETbool(&game.isMapMod); for (i = 0; i < MAX_PLAYERS; i++) { NETuint8_t(&game.skDiff[i]); } // Send the list of who is still joining for (i = 0; i < MAX_PLAYERS; i++) { NETbool(&ingame.JoiningInProgress[i]); } // Alliances for (i = 0; i < MAX_PLAYERS; i++) { unsigned int j; for (j = 0; j < MAX_PLAYERS; j++) { NETuint8_t(&alliances[i][j]); } } netPlayersUpdated = true; // Free any structure limits we may have in-place if (ingame.numStructureLimits) { ingame.numStructureLimits = 0; free(ingame.pStructureLimits); ingame.pStructureLimits = NULL; } // Get the number of structure limits to expect NETuint32_t(&ingame.numStructureLimits); debug(LOG_NET, "Host is sending us %u structure limits", ingame.numStructureLimits); // If there were any changes allocate memory for them if (ingame.numStructureLimits) { ingame.pStructureLimits = (MULTISTRUCTLIMITS *)malloc(ingame.numStructureLimits * sizeof(MULTISTRUCTLIMITS)); } for (i = 0; i < ingame.numStructureLimits; i++) { NETuint32_t(&ingame.pStructureLimits[i].id); NETuint32_t(&ingame.pStructureLimits[i].limit); } NETuint8_t(&ingame.flags); NETend(); // Do the skirmish slider settings if they are up for (i = 0; i < MAX_PLAYERS; i++) { if (widgGetFromID(psWScreen, MULTIOP_SKSLIDE + i)) { widgSetSliderPos(psWScreen, MULTIOP_SKSLIDE + i, game.skDiff[i]); } } debug(LOG_INFO, "Rebuilding map list"); // clear out the old level list. levShutDown(); levInitialise(); rebuildSearchPath(mod_multiplay, true); // MUST rebuild search path for the new maps we just got! buildMapList(); bool haveData = true; auto requestFile = [&haveData](Sha256 &hash, char const *filename) { if (std::any_of(NetPlay.wzFiles.begin(), NetPlay.wzFiles.end(), [&hash](WZFile const &file) { return file.hash == hash; })) { debug(LOG_INFO, "Already requested file, continue waiting."); haveData = false; return false; // Downloading the file already } if (!PHYSFS_exists(filename)) { debug(LOG_INFO, "Creating new file %s", filename); } else if (findHashOfFile(filename) != hash) { debug(LOG_INFO, "Overwriting old incomplete or corrupt file %s", filename); } else { return false; // Have the file already. } NetPlay.wzFiles.emplace_back(PHYSFS_openWrite(filename), hash); // Request the map/mod from the host NETbeginEncode(NETnetQueue(NET_HOST_ONLY), NET_FILE_REQUESTED); NETbin(hash.bytes, hash.Bytes); NETend(); haveData = false; return true; // Starting download now. }; LEVEL_DATASET *mapData = levFindDataSet(game.map, &game.hash); // See if we have the map or not if (mapData == nullptr) { char mapName[256]; sstrcpy(mapName, game.map); removeWildcards(mapName); if (strlen(mapName) >= 3 && mapName[strlen(mapName) - 3] == '-' && mapName[strlen(mapName) - 2] == 'T' && unsigned(mapName[strlen(mapName) - 1] - '1') < 3) { mapName[strlen(mapName) - 3] = '\0'; // Cut off "-T1", "-T2" or "-T3". } char filename[256]; ssprintf(filename, "maps/%dc-%s-%s.wz", game.maxPlayers, mapName, game.hash.toString().c_str()); // Wonder whether game.maxPlayers is initialised already? if (requestFile(game.hash, filename)) { debug(LOG_INFO, "Map was not found, requesting map %s from host, type %d", game.map, game.isMapMod); addConsoleMessage("MAP REQUESTED!", DEFAULT_JUSTIFY, SYSTEM_MESSAGE); } else { debug(LOG_FATAL, "Can't load map %s, even though we downloaded %s", game.map, filename); abort(); } } for (Sha256 &hash : game.modHashes) { char filename[256]; ssprintf(filename, "mods/downloads/%s", hash.toString().c_str()); if (requestFile(hash, filename)) { debug(LOG_INFO, "Mod was not found, requesting mod %s from host", hash.toString().c_str()); addConsoleMessage("MOD REQUESTED!", DEFAULT_JUSTIFY, SYSTEM_MESSAGE); } } if (mapData && CheckForMod(mapData->realFileName)) { char const *str = game.isMapMod ? _("Warning, this is a map-mod, it could alter normal gameplay.") : _("Warning, HOST has altered the game code, and can't be trusted!"); addConsoleMessage(str, DEFAULT_JUSTIFY, NOTIFY_MESSAGE); game.isMapMod = true; } if (mapData) { loadMapPreview(false); } }
void sendProcessDebugMappings(bool val) { NETbeginEncode(NETgameQueue(selectedPlayer), GAME_DEBUG_MODE); NETbool(&val); NETend(); }
// //////////////////////////////////////////////////////////////////////////// // options for a game. (usually recvd in frontend) void recvOptions(NETQUEUE queue) { unsigned int i; debug(LOG_NET, "Receiving options from host"); NETbeginDecode(queue, NET_OPTIONS); // Get general information about the game NETuint8_t(&game.type); NETstring(game.map, 128); NETbin(game.hash.bytes, game.hash.Bytes); NETuint8_t(&game.maxPlayers); NETstring(game.name, 128); NETuint32_t(&game.power); NETuint8_t(&game.base); NETuint8_t(&game.alliance); NETbool(&game.scavengers); for (i = 0; i < MAX_PLAYERS; i++) { NETuint8_t(&game.skDiff[i]); } // Send the list of who is still joining for (i = 0; i < MAX_PLAYERS; i++) { NETbool(&ingame.JoiningInProgress[i]); } // Alliances for (i = 0; i < MAX_PLAYERS; i++) { unsigned int j; for (j = 0; j < MAX_PLAYERS; j++) { NETuint8_t(&alliances[i][j]); } } netPlayersUpdated = true; // Free any structure limits we may have in-place if (ingame.numStructureLimits) { ingame.numStructureLimits = 0; free(ingame.pStructureLimits); ingame.pStructureLimits = NULL; } // Get the number of structure limits to expect NETuint32_t(&ingame.numStructureLimits); debug(LOG_NET, "Host is sending us %u structure limits", ingame.numStructureLimits); // If there were any changes allocate memory for them if (ingame.numStructureLimits) { ingame.pStructureLimits = (MULTISTRUCTLIMITS *)malloc(ingame.numStructureLimits * sizeof(MULTISTRUCTLIMITS)); } for (i = 0; i < ingame.numStructureLimits; i++) { NETuint32_t(&ingame.pStructureLimits[i].id); NETuint32_t(&ingame.pStructureLimits[i].limit); } NETuint8_t(&ingame.flags); NETend(); // Do the skirmish slider settings if they are up for (i = 0; i < MAX_PLAYERS; i++) { if (widgGetFromID(psWScreen, MULTIOP_SKSLIDE + i)) { widgSetSliderPos(psWScreen, MULTIOP_SKSLIDE + i, game.skDiff[i]); } } debug(LOG_INFO, "Rebuilding map list"); // clear out the old level list. levShutDown(); levInitialise(); setCurrentMap(NULL, 42); rebuildSearchPath(mod_multiplay, true); // MUST rebuild search path for the new maps we just got! buildMapList(); // See if we have the map or not if (levFindDataSet(game.map, &game.hash) == NULL) { uint32_t player = selectedPlayer; debug(LOG_INFO, "Map was not found, requesting map %s from host.", game.map); // Request the map from the host NETbeginEncode(NETnetQueue(NET_HOST_ONLY), NET_FILE_REQUESTED); NETuint32_t(&player); NETend(); addConsoleMessage("MAP REQUESTED!", DEFAULT_JUSTIFY, SYSTEM_MESSAGE); } else { loadMapPreview(false); } }
bool sendPing(void) { bool isNew = true; uint8_t player = selectedPlayer; int i; static UDWORD lastPing = 0; // Last time we sent a ping static UDWORD lastav = 0; // Last time we updated average // Only ping every so often if (lastPing > realTime) { lastPing = 0; } if (realTime - lastPing < PING_FREQUENCY) { return true; } lastPing = realTime; // If host, also update the average ping stat for joiners if (NetPlay.isHost) { if (lastav > realTime) { lastav = 0; } if (realTime - lastav > AV_PING_FREQUENCY) { NETsetGameFlags(2, averagePing()); lastav = realTime; } } /* * Before we send the ping, if any player failed to respond to the last one * we should re-enumerate the players. */ for (i = 0; i < MAX_PLAYERS; i++) { if (isHumanPlayer(i) && PingSend[i] && ingame.PingTimes[i] && i != selectedPlayer) { ingame.PingTimes[i] = PING_LIMIT; } else if (!isHumanPlayer(i) && PingSend[i] && ingame.PingTimes[i] && i != selectedPlayer) { ingame.PingTimes[i] = 0; } } uint64_t pingChallengei = (uint64_t)rand() << 32 | rand(); memcpy(pingChallenge, &pingChallengei, sizeof(pingChallenge)); NETbeginEncode(NETbroadcastQueue(), NET_PING); NETuint8_t(&player); NETbool(&isNew); NETbin(pingChallenge, sizeof(pingChallenge)); NETend(); // Note when we sent the ping for (i = 0; i < MAX_PLAYERS; i++) { PingSend[i] = realTime; } return true; }
bool recvResearchStatus(NETQUEUE queue) { STRUCTURE *psBuilding; PLAYER_RESEARCH *pPlayerRes; RESEARCH_FACILITY *psResFacilty; RESEARCH *pResearch; uint8_t player; bool bStart; uint32_t index, structRef; NETbeginDecode(queue, GAME_RESEARCHSTATUS); NETuint8_t(&player); NETbool(&bStart); NETuint32_t(&structRef); NETuint32_t(&index); NETend(); syncDebug("player%d, bStart%d, structRef%u, index%u", player, bStart, structRef, index); if (player >= MAX_PLAYERS || index >= asResearch.size()) { debug(LOG_ERROR, "Bad GAME_RESEARCHSTATUS received, player is %d, index is %u", (int)player, index); return false; } if (!canGiveOrdersFor(queue.index, player)) { debug(LOG_WARNING, "Droid order for wrong player."); syncDebug("Wrong player."); return false; } int prevResearchState = 0; if (aiCheckAlliances(selectedPlayer, player)) { prevResearchState = intGetResearchState(); } pPlayerRes = &asPlayerResList[player][index]; // psBuilding may be null if finishing if (bStart) // Starting research { psBuilding = IdToStruct(structRef, player); // Set that facility to research if (psBuilding && psBuilding->pFunctionality) { psResFacilty = (RESEARCH_FACILITY *) psBuilding->pFunctionality; popStatusPending(*psResFacilty); // Research is no longer pending, as it's actually starting now. if (psResFacilty->psSubject) { cancelResearch(psBuilding, ModeImmediate); } // Set the subject up pResearch = &asResearch[index]; psResFacilty->psSubject = pResearch; // Start the research MakeResearchStarted(pPlayerRes); psResFacilty->timeStartHold = 0; } } // Finished/cancelled research else { // If they completed the research, we're done if (IsResearchCompleted(pPlayerRes)) { return true; } // If they did not say what facility it was, look it up orselves if (!structRef) { // Go through the structs to find the one doing this topic for (psBuilding = apsStructLists[player]; psBuilding; psBuilding = psBuilding->psNext) { if (psBuilding->pStructureType->type == REF_RESEARCH && psBuilding->status == SS_BUILT && ((RESEARCH_FACILITY *) psBuilding->pFunctionality)->psSubject && ((RESEARCH_FACILITY *) psBuilding->pFunctionality)->psSubject->ref - REF_RESEARCH_START == index) { break; } } } else { psBuilding = IdToStruct(structRef, player); } // Stop the facility doing any research if (psBuilding) { cancelResearch(psBuilding, ModeImmediate); popStatusPending(*(RESEARCH_FACILITY *)psBuilding->pFunctionality); // Research cancellation is no longer pending, as it's actually cancelling now. } } if (aiCheckAlliances(selectedPlayer, player)) { intAlliedResearchChanged(); intNotifyResearchButton(prevResearchState); } return true; }
// //////////////////////////////////////////////////////////////////////////// // receive droid creation information from other players BOOL recvDroid(NETQUEUE queue) { DROID_TEMPLATE* pT; DROID* psDroid; uint8_t player; uint32_t id; Position pos; uint32_t templateID; BOOL haveInitialOrders; INITIAL_DROID_ORDERS initialOrders; NETbeginDecode(queue, GAME_DROID); { NETuint8_t(&player); NETuint32_t(&id); NETPosition(&pos); NETuint32_t(&templateID); NETbool(&haveInitialOrders); if (haveInitialOrders) { NETuint32_t(&initialOrders.secondaryOrder); NETint32_t(&initialOrders.moveToX); NETint32_t(&initialOrders.moveToY); NETuint32_t(&initialOrders.factoryId); // For making scripts happy. } pT = IdToTemplate(templateID, player); } NETend(); ASSERT( player < MAX_PLAYERS, "invalid player %u", player); debug(LOG_LIFE, "<=== getting Droid from %u id of %u ",player,id); if ((pos.x == 0 && pos.y == 0) || pos.x > world_coord(mapWidth) || pos.y > world_coord(mapHeight)) { debug(LOG_ERROR, "Received bad droid position (%d, %d) from %d about p%d (%s)", (int)pos.x, (int)pos.y, queue.index, player, isHumanPlayer(player) ? "Human" : "AI"); return false; } // If we can not find the template ask for the entire droid instead if (!pT) { debug(LOG_ERROR, "Packet from %d refers to non-existent template %u, [%s : p%d]", queue.index, templateID, isHumanPlayer(player) ? "Human" : "AI", player); return false; } // Create that droid on this machine. psDroid = reallyBuildDroid(pT, pos.x, pos.y, player, false); // If we were able to build the droid set it up if (psDroid) { psDroid->id = id; addDroid(psDroid, apsDroidLists); if (haveInitialOrders) { psDroid->secondaryOrder = initialOrders.secondaryOrder; orderDroidLoc(psDroid, DORDER_MOVE, initialOrders.moveToX, initialOrders.moveToY, ModeImmediate); cbNewDroid(IdToStruct(initialOrders.factoryId, ANYPLAYER), psDroid); } } else { debug(LOG_ERROR, "Packet from %d cannot create droid for p%d (%s)!", queue.index, player, isHumanPlayer(player) ? "Human" : "AI"); #ifdef DEBUG CONPRINTF(ConsoleString, (ConsoleString, "MULTIPLAYER: Couldn't build a remote droid, relying on checking to resync")); #endif return false; } return true; }
// //////////////////////////////////////////////////////////////////////////// // receive droid creation information from other players bool recvDroid(NETQUEUE queue) { DROID_TEMPLATE t, *pT = &t; DROID *psDroid; uint8_t player; uint32_t id; Position pos; bool haveInitialOrders; INITIAL_DROID_ORDERS initialOrders; NETbeginDecode(queue, GAME_DEBUG_ADD_DROID); { int32_t droidType; NETuint8_t(&player); NETuint32_t(&id); NETPosition(&pos); NETqstring(pT->name); pT->id = pT->name; NETint32_t(&droidType); NETuint8_t(&pT->asParts[COMP_BODY]); NETuint8_t(&pT->asParts[COMP_BRAIN]); NETuint8_t(&pT->asParts[COMP_PROPULSION]); NETuint8_t(&pT->asParts[COMP_REPAIRUNIT]); NETuint8_t(&pT->asParts[COMP_ECM]); NETuint8_t(&pT->asParts[COMP_SENSOR]); NETuint8_t(&pT->asParts[COMP_CONSTRUCT]); NETint8_t(&pT->numWeaps); for (int i = 0; i < pT->numWeaps; i++) { NETuint8_t(&pT->asWeaps[i]); } NETbool(&haveInitialOrders); if (haveInitialOrders) { NETuint32_t(&initialOrders.secondaryOrder); NETint32_t(&initialOrders.moveToX); NETint32_t(&initialOrders.moveToY); NETuint32_t(&initialOrders.factoryId); // For making scripts happy. } pT->droidType = (DROID_TYPE)droidType; } NETend(); if (!getDebugMappingStatus() && bMultiPlayer) { debug(LOG_WARNING, "Failed to add droid for player %u.", NetPlay.players[queue.index].position); return false; } ASSERT_OR_RETURN(false, player < MAX_PLAYERS, "invalid player %u", player); debug(LOG_LIFE, "<=== getting Droid from %u id of %u ", player, id); if ((pos.x == 0 && pos.y == 0) || pos.x > world_coord(mapWidth) || pos.y > world_coord(mapHeight)) { debug(LOG_ERROR, "Received bad droid position (%d, %d) from %d about p%d (%s)", (int)pos.x, (int)pos.y, queue.index, player, isHumanPlayer(player) ? "Human" : "AI"); return false; } // Create that droid on this machine. psDroid = reallyBuildDroid(pT, pos, player, false); // If we were able to build the droid set it up if (psDroid) { psDroid->id = id; addDroid(psDroid, apsDroidLists); if (haveInitialOrders) { psDroid->secondaryOrder = initialOrders.secondaryOrder; psDroid->secondaryOrderPending = psDroid->secondaryOrder; orderDroidLoc(psDroid, DORDER_MOVE, initialOrders.moveToX, initialOrders.moveToY, ModeImmediate); cbNewDroid(IdToStruct(initialOrders.factoryId, ANYPLAYER), psDroid); } syncDebugDroid(psDroid, '+'); } else { debug(LOG_ERROR, "Packet from %d cannot create droid for p%d (%s)!", queue.index, player, isHumanPlayer(player) ? "Human" : "AI"); #ifdef DEBUG CONPRINTF(ConsoleString, (ConsoleString, "MULTIPLAYER: Couldn't build a remote droid, relying on checking to resync")); #endif return false; } return true; }