const std::shared_ptr<const ClientSetup> newClientSetup,

const std::shared_ptr<const GameData> newGameData,

const std::shared_ptr<const CGameSetup> newGameSetup

)

: serverFrameNum(-1)

, serverStartTime(spring_gettime())

, readyTime(spring_notime)

, gameEndTime(spring_notime)

, lastPlayerInfo(serverStartTime)

, lastUpdate(serverStartTime)

, modGameTime(0.0f)

, gameTime(0.0f)

, startTime(0.0f)

, frameTimeLeft(0.0f)

, isPaused(false)

, gamePausable(true)

, userSpeedFactor(1.0f)

, internalSpeed(1.0f)

, medianCpu(0.0f)

, medianPing(0)

, cheating(false)

, noHelperAIs(false)

, canReconnect(false)

, allowSpecDraw(true)

, syncErrorFrame(0)

, syncWarningFrame(0)

, localClientNumber(-1u)

, gameHasStarted(false)

, generatedGameID(false)

, reloadingServer(false)

, quitServer(false)

{

myClientSetup = newClientSetup;

myGameData = newGameData;

myGameSetup = newGameSetup;

Initialize();

{

// configs

curSpeedCtrl = configHandler->GetInt("SpeedControl");

allowSpecJoin = configHandler->GetBool("AllowSpectatorJoin") || myGameSetup->onlyLocal; ///!!! mantis #4418

whiteListAdditionalPlayers = configHandler->GetBool("WhiteListAdditionalPlayers");

logInfoMessages = configHandler->GetBool("ServerLogInfoMessages");

logDebugMessages = configHandler->GetBool("ServerLogDebugMessages");

rng.Seed((myGameData->GetSetupText()).length());

// start network

if (!myGameSetup->onlyLocal)

UDPNet.reset(new netcode::UDPListener(myClientSetup->hostPort, myClientSetup->hostIP));

AddAutohostInterface(StringToLower(configHandler->GetString("AutohostIP")), configHandler->GetInt("AutohostPort"));

Message(spring::format(ServerStart, myClientSetup->hostPort), false);

// start script

maxUserSpeed = myGameSetup->maxSpeed;

minUserSpeed = myGameSetup->minSpeed;

noHelperAIs = myGameSetup->noHelperAIs;

StripGameSetupText(myGameData.get());

// load demo (if there is one)

if (myGameSetup->hostDemo) {

Message(spring::format(PlayingDemo, myGameSetup->demoName.c_str()));

demoReader.reset(new CDemoReader(myGameSetup->demoName, modGameTime + 0.1f));

}

// initialize players, teams & ais

{

pingTimeFilter.fill(spring_notime);

clientDrawFilter.fill({spring_notime, 0});

clientMuteFilter.fill({false, false});

const std::vector<PlayerBase>& playerStartData = myGameSetup->GetPlayerStartingDataCont();

const std::vector<TeamBase>& teamStartData = myGameSetup->GetTeamStartingDataCont();

const std::vector<SkirmishAIData>& aiStartData = myGameSetup->GetAIStartingDataCont();

players.reserve(MAX_PLAYERS); // no reallocation please

teams.resize(teamStartData.size());

players.resize(playerStartData.size());

if (demoReader != nullptr) {

const size_t demoPlayers = demoReader->GetFileHeader().numPlayers;

players.resize(std::max(demoPlayers, playerStartData.size()));

if (players.size() >= MAX_PLAYERS) {

Message(spring::format("Too many Players (%d) in the demo", players.size()));

}

}

std::copy(playerStartData.begin(), playerStartData.end(), players.begin());

std::copy(teamStartData.begin(), teamStartData.end(), teams.begin());

//FIXME move playerID to PlayerBase, so it gets copied from playerStartData

for (size_t n = 0; n < players.size(); n++)

players[n].id = n;

skirmishAIs.clear();

skirmishAIs.resize(MAX_AIS, {false, {}});

freeSkirmishAIs.clear();

freeSkirmishAIs.resize(MAX_AIS, 0);

std::for_each(freeSkirmishAIs.begin(), freeSkirmishAIs.end(), [&](const uint8_t& id) { freeSkirmishAIs[&id - &freeSkirmishAIs[0]] = &id - &freeSkirmishAIs[0]; });

std::reverse(freeSkirmishAIs.begin(), freeSkirmishAIs.end());

for (const SkirmishAIData& skd: aiStartData) {

const uint8_t skirmishAIId = ReserveSkirmishAIId();

if (skirmishAIId == MAX_AIS) {

Message(spring::format("Too many AIs (%d) specified in game-setup script", aiStartData.size()));

break;

}

players[skd.hostPlayer].aiClientLinks[skirmishAIId] = {};

skirmishAIs[skirmishAIId] = std::make_pair(true, skd);

teams[skd.team].SetActive(true);

if (!teams[skd.team].HasLeader())

teams[skd.team].SetLeader(skd.hostPlayer);

}

}

{

// std::copy(SERVER_COMMANDS.begin(), SERVER_COMMANDS.end(), commandBlacklist.begin());

std::sort(commandBlacklist.begin(), commandBlacklist.end());

}

if (configHandler->GetBool("ServerRecordDemos")) {

demoRecorder.reset(new CDemoRecorder(myGameSetup->mapName, myGameSetup->modName, true));

demoRecorder->WriteSetupText(myGameData->GetSetupText());

const netcode::RawPacket* ret = myGameData->Pack();

demoRecorder->SaveToDemo(ret->data, ret->length, GetDemoTime());

delete ret;

}

loopSleepTime = configHandler->GetInt("ServerSleepTime");

lastNewFrameTick = spring_gettime();

linkMinPacketSize = globalConfig.linkIncomingMaxPacketRate > 0 ? (globalConfig.linkIncomingSustainedBandwidth / globalConfig.linkIncomingMaxPacketRate) : 1;

lastBandwidthUpdate = spring_gettime();

thread = std::move(spring::thread(std::bind(&CGameServer::UpdateLoop, this)));

// Something in CGameServer::CGameServer borks the FPU control word

// maybe the threading, or something in CNet::InitServer() ??

// Set single precision floating point math.

streflop::streflop_init<streflop::Simple>();

if (!demoReader) {

GenerateAndSendGameID();

rng.Seed(gameID.intArray[0] ^ gameID.intArray[1] ^ gameID.intArray[2] ^ gameID.intArray[3]);

Broadcast(CBaseNetProtocol::Get().SendRandSeed(rng()));

}

{

std::lock_guard<spring::recursive_mutex> scoped_lock(gameServerMutex);

serverFrameNum = newServerFrameNum;

gameHasStarted = !PreSimFrame();

// for all GameParticipant's

for (GameParticipant& p: players) {

p.lastFrameResponse = newServerFrameNum;

}

{

const std::shared_ptr<const ClientSetup> clientSetup = gameServer->GetClientSetup();

const std::shared_ptr<const GameData> gameData = gameServer->GetGameData();

delete gameServer;

// transfer ownership to new instance (assume only GameSetup changes)

gameServer = new CGameServer(clientSetup, gameData, newGameSetup);

{

if (demoRecorder == nullptr)

return;

// there is always at least one non-Gaia team (numTeams > 0)

// the Gaia team itself does not count toward the statistics

demoRecorder->SetTime(serverFrameNum / GAME_SPEED, spring_tomsecs(spring_gettime() - serverStartTime) / 1000);

demoRecorder->InitializeStats(players.size(), int((myGameSetup->GetTeamStartingDataCont()).size()) - myGameSetup->useLuaGaia);

// Pass the winners to the CDemoRecorder.

demoRecorder->SetWinningAllyTeams(winningAllyTeams);

for (GameParticipant& p: players) {

demoRecorder->SetPlayerStats(p.id, p.lastStats);

}

/*

{

// modify and save GameSetup text (remove passwords)

TdfParser parser((newGameData->GetSetupText()).c_str(), (newGameData->GetSetupText()).length());

TdfParser::TdfSection* rootSec = parser.GetRootSection()->sections["game"];

for (const auto& item: rootSec->sections) {

const std::string& sectionKey = StringToLower(item.first);

if (!StringStartsWith(sectionKey, "player"))

continue;

TdfParser::TdfSection* playerSec = item.second;

playerSec->remove("password", false);

}

std::ostringstream strbuf;

parser.print(strbuf);

GameData* modGameData = new GameData(*newGameData);

modGameData->SetSetupText(strbuf.str());

myGameData.reset(modGameData);

{

std::lock_guard<spring::recursive_mutex> scoped_lock(gameServerMutex);

assert(!HasLocalClient());

localClientNumber = BindConnection(std::shared_ptr<netcode::CConnection>(new netcode::CLocalConnection()), myName, "", myVersion, myPlatform, true);

{

if (autohostPort <= 0)

return;

if (autohostIP == "localhost") {

LOG_L(L_ERROR, "Autohost IP address not in x.y.z.w format!");

return;

}

#ifndef DEDICATED

// disallow luasockets access to autohost interface

luaSocketRestrictions->addRule(CLuaSocketRestrictions::UDP_CONNECT, autohostIP, autohostPort, false);

#endif

if (!hostif) {

hostif.reset(new AutohostInterface(autohostIP, autohostPort));

if (hostif->IsInitialized()) {

hostif->SendStart();

Message(spring::format(ConnectAutohost, autohostPort), false);

} else {

// Quit if we are instructed to communicate with an auto-host,

// but are unable to do so: we do not want an auto-host running

// a spring game that it has no control over. If we get here,

// it suggests a configuration problem in the auto-host.

hostif.reset();

Message(spring::format(ConnectAutohostFailed, autohostIP.c_str(), autohostPort), false);

quitServer = true;

}

}

{

const bool wasPaused = isPaused;

if (!gameHasStarted) { return; }

if (serverFrameNum >= targetFrameNum) { return; }

if (demoReader == nullptr) { return; }

CommandMessage startMsg(spring::format("skip start %d", targetFrameNum), SERVER_PLAYER);

CommandMessage endMsg("skip end", SERVER_PLAYER);

Broadcast(std::shared_ptr<const netcode::RawPacket>(startMsg.Pack()));

// fast-read and send demo data

//

// note that we must maintain <modGameTime> ourselves

// since we do we NOT go through ::Update when skipping

while (SendDemoData(targetFrameNum)) {

gameTime = GetDemoTime();

modGameTime = demoReader->GetModGameTime() + 0.001f;

if (UDPNet == nullptr) { continue; }

if ((serverFrameNum % 20) != 0) { continue; }

// send data every few frames, as otherwise packets would grow too big

UDPNet->Update();

}

Broadcast(std::shared_ptr<const netcode::RawPacket>(endMsg.Pack()));

if (UDPNet) {

UDPNet->Update();

}

lastUpdate = spring_gettime();

isPaused = wasPaused;

{

std::string playerstring;

for (int id: indices) {

if (!playerstring.empty())

playerstring += ", ";

playerstring += players[id].name;

}

return playerstring;

{

bool ret = false;

netcode::RawPacket* buf = nullptr;

// if we reached EOS before, demoReader has become NULL

if (demoReader == nullptr)

return ret;

// get all packets from the stream up to <modGameTime>

while ((buf = demoReader->GetData(modGameTime))) {

std::shared_ptr<const RawPacket> rpkt(buf);

if (buf->length <= 0) {

Message("Warning: Discarding zero size packet in demo");

continue;

}

const unsigned msgCode = buf->data[0];

switch (msgCode) {

case NETMSG_NEWFRAME:

case NETMSG_KEYFRAME: {

// we can't use CreateNewFrame() here

lastNewFrameTick = spring_gettime();

serverFrameNum++;

#ifdef SYNCCHECK

if (targetFrameNum == -1) {

// not skipping

outstandingSyncFrames.insert(serverFrameNum);

}

CheckSync();

#endif

Broadcast(rpkt);

break;

}

case NETMSG_CREATE_NEWPLAYER: {

try {

netcode::UnpackPacket pckt(rpkt, 3);

unsigned char spectator, team, playerNum;

std::string name;

pckt >> playerNum;

pckt >> spectator;

pckt >> team;

pckt >> name;

AddAdditionalUser(name, "", true, (bool)spectator, (int)team, playerNum); // even though this is a demo, keep the players vector properly updated

} catch (const netcode::UnpackPacketException& ex) {

Message(spring::format("Warning: Discarding invalid new player packet in demo: %s", ex.what()));

continue;

}

Broadcast(rpkt);

break;

}

case NETMSG_GAMEDATA:

case NETMSG_SETPLAYERNUM:

case NETMSG_USER_SPEED:

case NETMSG_INTERNAL_SPEED: {

// never send these from demos

break;

}

case NETMSG_CCOMMAND: {

try {

CommandMessage msg(rpkt);

const Action& action = msg.GetAction();

if (msg.GetPlayerID() == SERVER_PLAYER && action.command == "cheat")

InverseOrSetBool(cheating, action.extra);

} catch (const netcode::UnpackPacketException& ex) {

Message(spring::format("Warning: Discarding invalid command message packet in demo: %s", ex.what()));

continue;

}

Broadcast(rpkt);

break;

}

default: {

Broadcast(rpkt);

break;

}

}

}

if (targetFrameNum > 0) {

// skipping

ret = (serverFrameNum < targetFrameNum);

}

if (demoReader->ReachedEnd()) {

demoReader.reset();

Message(DemoEnd);

gameEndTime = spring_gettime();

ret = false;

}

return ret;

{

for (GameParticipant& p: players) {

p.SendData(packet);

}

if (canReconnect || allowSpecJoin || !gameHasStarted)

packetCache.push_back(packet);

if (demoRecorder != nullptr)

demoRecorder->SaveToDemo(packet->data, packet->length, GetDemoTime());

{

if (!internal) {

if (broadcast) {

Broadcast(CBaseNetProtocol::Get().SendSystemMessage(SERVER_PLAYER, message));

}

else if (HasLocalClient()) {

// host should see

players[localClientNumber].SendData(CBaseNetProtocol::Get().SendSystemMessage(SERVER_PLAYER, message));

}

if (hostif != nullptr)

hostif->Message(message);

}

#ifdef DEDICATED

LOG("%s", message.c_str());

#endif

{

#ifdef SYNCCHECK

std::vector< std::pair<unsigned, unsigned> > checksums; // <response checkum, #clients matching checksum>

std::vector<int> noSyncResponsePlayers;

std::map<unsigned, std::vector<int> > desyncGroups; // <desync-checksum, [desynced players]>

std::map<int, unsigned> desyncSpecs; // <playerNum, desync-checksum>

auto outstandingSyncFrameIt = outstandingSyncFrames.begin();

while (outstandingSyncFrameIt != outstandingSyncFrames.end()) {

const unsigned outstandingSyncFrame = *outstandingSyncFrameIt;

unsigned correctChecksum = 0;

// maximum number of matched checksums

unsigned maxChecksumCount = 0;

bool haveCorrectChecksum = false;

bool completeResponseSet = true;

if (HasLocalClient()) {

// dictatorship; all player checksums must match the local client's for this frame

const auto it = players[localClientNumber].syncResponse.find(outstandingSyncFrame);

if (it != players[localClientNumber].syncResponse.end()) {

correctChecksum = it->second;

haveCorrectChecksum = true;

}

} else {

// democracy; use the checksum that most players agree on as baseline

checksums.clear();

checksums.reserve(players.size());

for (const GameParticipant& p: players) {

if (p.clientLink == nullptr)

continue;

const auto pChecksumIt = p.syncResponse.find(outstandingSyncFrame);

if (pChecksumIt == p.syncResponse.end())

continue;

const unsigned pChecksum = pChecksumIt->second;

// const unsigned cChecksum = checksums[0].first;

bool checksumFound = false;

// compare player <p>'s sync-response checksum for the

// outstanding frame to all others we have seen so far

for (auto& checksumPair: checksums) {

const unsigned cChecksum = checksumPair.first;

unsigned& cChecksumCount = checksumPair.second;

if (cChecksum != pChecksum)

continue;

checksumFound = true;

if (maxChecksumCount < (++cChecksumCount)) {

maxChecksumCount = cChecksumCount;

correctChecksum = cChecksum;

}

}

if (checksumFound)

continue;

// first time we have seen this checksum

checksums.emplace_back(pChecksum, 1);

if (maxChecksumCount == 0) {

maxChecksumCount = 1;

correctChecksum = pChecksum;

}

}

haveCorrectChecksum = (maxChecksumCount > 0);

}

noSyncResponsePlayers.clear();

noSyncResponsePlayers.reserve(players.size());

desyncGroups.clear();

desyncSpecs.clear();

for (GameParticipant& p: players) {

if (p.clientLink == nullptr)

continue;

const auto pChecksumIt = p.syncResponse.find(outstandingSyncFrame);

if (pChecksumIt == p.syncResponse.end()) {

if (outstandingSyncFrame >= (serverFrameNum - static_cast<int>(SYNCCHECK_TIMEOUT)))

completeResponseSet = false;

else if (outstandingSyncFrame < p.lastFrameResponse)

noSyncResponsePlayers.push_back(p.id);

continue;

}

const unsigned pChecksum = pChecksumIt->second;

if ((p.desynced = (haveCorrectChecksum && pChecksum != correctChecksum))) {

if (demoReader || !p.spectator) {

desyncGroups[pChecksum].push_back(p.id);

} else {

desyncSpecs[p.id] = pChecksum;

}

}

}

// warn about clients that failed to provide a sync-response checksum in time

if (!noSyncResponsePlayers.empty()) {

if (!syncWarningFrame || ((outstandingSyncFrame - syncWarningFrame) > static_cast<int>(SYNCCHECK_MSG_TIMEOUT))) {

syncWarningFrame = outstandingSyncFrame;

const std::string& playerNames = GetPlayerNames(noSyncResponsePlayers);

Message(spring::format(NoSyncResponse, playerNames.c_str(), outstandingSyncFrame));

}

}

// If anything's in it, we have a desync.

// TODO take care of !completeResponseSet case?

// Should we start resync then immediately or wait for the missing packets (while paused)?

if (/*completeResponseSet && */ (!desyncGroups.empty() || !desyncSpecs.empty())) {

if (syncErrorFrame == 0 || (outstandingSyncFrame - syncErrorFrame > static_cast<int>(SYNCCHECK_MSG_TIMEOUT))) {

syncErrorFrame = outstandingSyncFrame;

#ifdef SYNCDEBUG

CSyncDebugger::GetInstance()->ServerTriggerSyncErrorHandling(serverFrameNum);

if (demoReader) // pause is a synced message, thus demo spectators may not pause for real

Message(spring::format("%s paused the demo", players[gu->myPlayerNum].name.c_str()));

else

Broadcast(CBaseNetProtocol::Get().SendPause(gu->myPlayerNum, true));

isPaused = true;

Broadcast(CBaseNetProtocol::Get().SendSdCheckrequest(serverFrameNum));

#endif

#ifndef DEDICATED

// DS exit-codes are not used

spring::exitCode = spring::EXIT_CODE_DESYNC;

#endif

// For each group, output a message with list of player names in it.

// TODO this should be linked to the resync system so it can roundrobin

// the resync checksum request packets to multiple clients in the same group.

for (const auto& desyncGroup: desyncGroups) {

const std::string& playerNames = GetPlayerNames(desyncGroup.second);

Message(spring::format(SyncError, playerNames.c_str(), outstandingSyncFrame, desyncGroup.first, correctChecksum));

}

// send spectator desyncs as private messages to reduce spam

for (const auto& p: desyncSpecs) {

LOG_L(L_ERROR, "%s", spring::format(SyncError, players[p.first].name.c_str(), outstandingSyncFrame, p.second, correctChecksum).c_str());

Message(spring::format(SyncError, players[p.first].name.c_str(), outstandingSyncFrame, p.second, correctChecksum));

PrivateMessage(p.first, spring::format(SyncError, players[p.first].name.c_str(), outstandingSyncFrame, p.second, correctChecksum));

}

}

}

// Remove complete sets (for which all player's checksums have been received).

if (completeResponseSet) {

for (GameParticipant& p: players) {

if (p.myState < GameParticipant::DISCONNECTED)

p.syncResponse.erase(outstandingSyncFrame);

}

outstandingSyncFrameIt = outstandingSyncFrames.erase(outstandingSyncFrameIt);

continue;

}

++outstandingSyncFrameIt;

}

#else

// Make it clear this build isn't suitable for release.

if (!syncErrorFrame || (serverFrameNum - syncErrorFrame > SYNCCHECK_MSG_TIMEOUT)) {

syncErrorFrame = serverFrameNum;

Message(NoSyncCheck);

}

#endif

{

const float tdif = spring_tomsecs(spring_gettime() - lastUpdate) * 0.001f;

gameTime += tdif;

lastUpdate = spring_gettime();

if (!isPaused && gameHasStarted) {

// if we are not playing a demo, or have no local client, or the

// local client is less than <GAME_SPEED> frames behind, advance

// <modGameTime>

if (demoReader == nullptr || !HasLocalClient() || (serverFrameNum - players[localClientNumber].lastFrameResponse) < GAME_SPEED)

modGameTime += (tdif * internalSpeed);

}

if (lastPlayerInfo < (spring_gettime() - playerInfoTime)) {

lastPlayerInfo = spring_gettime();

if (!PreSimFrame()) {

LagProtection();

} else {

for (GameParticipant& p: players) {

if (p.isFromDemo)

continue;

switch (p.myState) {

case GameParticipant::CONNECTED: {

// send pathing status

if (p.cpuUsage > 0)

Broadcast(CBaseNetProtocol::Get().SendPlayerInfo(p.id, p.cpuUsage, PATHING_FLAG));

} break;

case GameParticipant::INGAME:

case GameParticipant::DISCONNECTED: {

Broadcast(CBaseNetProtocol::Get().SendPlayerInfo(p.id, 0, 0)); // reset status

} break;

case GameParticipant::UNCONNECTED:

default: break;

}

}

}

}

if (!gameHasStarted)

CheckForGameStart();

else if (!PreSimFrame() || demoReader != nullptr)

CreateNewFrame(true, false);

if (hostif != nullptr) {

const std::string msg = hostif->GetChatMessage();

if (!msg.empty()) {

if (msg.at(0) != '/') { // normal chat message

GotChatMessage(ChatMessage(SERVER_PLAYER, ChatMessage::TO_EVERYONE, msg));

}

else if (msg.at(0) == '/' && msg.size() > 1 && msg.at(1) == '/') { // chatmessage with prefixed '/'

GotChatMessage(ChatMessage(SERVER_PLAYER, ChatMessage::TO_EVERYONE, msg.substr(1)));

}

else if (msg.size() > 1) { // command

PushAction(Action(msg.substr(1)), true);

}

}

}

const bool pregameTimeoutReached = (spring_gettime() > (serverStartTime + spring_secs(globalConfig.initialNetworkTimeout)));

const bool canCheckForPlayers = (pregameTimeoutReached || gameHasStarted);

if (canCheckForPlayers) {

bool hasPlayers = false;

for (const GameParticipant& p: players) {

if ((hasPlayers |= (p.clientLink != nullptr)))

break;

}

if ((quitServer = (quitServer || !hasPlayers)))

Message(NoClientsExit);

}

{

std::vector<float> cpu;

std::vector<int> ping;

cpu.reserve(players.size());

ping.reserve(players.size());

// detect reference cpu usage ( highest )

float refCpuUsage = 0.0f;

for (GameParticipant& player: players) {

if (player.myState == GameParticipant::INGAME) {

// send info about the players

const int curPing = ((serverFrameNum - player.lastFrameResponse) * 1000) / (GAME_SPEED * internalSpeed);

Broadcast(CBaseNetProtocol::Get().SendPlayerInfo(player.id, player.cpuUsage, curPing));

const float playerCpuUsage = player.cpuUsage;

const float correctedCpu = Clamp(playerCpuUsage, 0.0f, 1.0f);

if (player.isReconn && curPing < 2 * GAME_SPEED)

player.isReconn = false;

if ((player.isLocal) || (demoReader ? !player.isFromDemo : !player.spectator)) {

if (!player.isReconn && correctedCpu > refCpuUsage)

refCpuUsage = correctedCpu;

cpu.push_back(correctedCpu);

ping.push_back(curPing);

}

}

}

// calculate median values

medianCpu = 0.0f;

medianPing = 0;

if (curSpeedCtrl == 1 && !cpu.empty()) {

std::sort(cpu.begin(), cpu.end());

std::sort(ping.begin(), ping.end());

int midpos = cpu.size() / 2;

medianCpu = cpu[midpos];

medianPing = ping[midpos];

if (midpos * 2 == cpu.size()) {

medianCpu = (medianCpu + cpu[midpos - 1]) / 2.0f;

medianPing = (medianPing + ping[midpos - 1]) / 2;

}

refCpuUsage = medianCpu;

}

// adjust game speed

if (refCpuUsage > 0.0f && !isPaused) {

//userSpeedFactor holds the wanted speed adjusted manually by user ( normally 1)

//internalSpeed holds the current speed the sim is running

//refCpuUsage holds the highest cpu if curSpeedCtrl == 0 or median if curSpeedCtrl == 1

// aim for 60% cpu usage if median is used as reference and 75% cpu usage if max is the reference

float wantedCpuUsage = (curSpeedCtrl == 1) ? 0.60f : 0.75f;

//the following line can actually make it go faster than wanted normal speed ( userSpeedFactor )

//if the current cpu of the target is smaller than the aimed cpu target but the clamp will cap it

// the clamp will throttle it to the wanted one, otherwise it's a simple linear proportion aiming

// to keep cpu load constant

float newSpeed = internalSpeed / refCpuUsage * wantedCpuUsage;

newSpeed = Clamp(newSpeed, 0.1f, userSpeedFactor);

//average to smooth the speed change over time to reduce the impact of cpu spikes in the players

newSpeed = (newSpeed + internalSpeed) * 0.5f;

#ifndef DEDICATED

// in non-dedicated hosting, we'll add an additional safeguard to make sure the host can keep up with the game's speed

// adjust game speed to localclient's (:= host) maximum SimFrame rate

const float invSimDrawFract = 1.0f - CGlobalUnsynced::reconnectSimDrawBalance;

const float maxSimFrameRate = (1000.0f / gu->avgSimFrameTime) * invSimDrawFract;

newSpeed = Clamp(newSpeed, 0.1f, ((maxSimFrameRate / GAME_SPEED) + internalSpeed) * 0.5f);

#endif

if (newSpeed != internalSpeed)

InternalSpeedChange(newSpeed);

}

{

std::vector<int> playersInTeam;

for (const GameParticipant& p: players) {

// do not count spectators, or demos will desync

if (!p.spectator && (p.team == teamId))

playersInTeam.push_back(p.id);

}

return playersInTeam;