Index: ps/trunk/source/network/NetTurnManager.cpp
===================================================================
--- ps/trunk/source/network/NetTurnManager.cpp	(revision 18590)
+++ ps/trunk/source/network/NetTurnManager.cpp	(revision 18591)
@@ -1,722 +1,712 @@
 /* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "NetTurnManager.h"
 #include "NetMessage.h"
 
 #include "network/NetServer.h"
 #include "network/NetClient.h"
 #include "network/NetMessage.h"
 
 #include "gui/GUIManager.h"
 #include "maths/MathUtil.h"
 #include "ps/CLogger.h"
 #include "ps/Profile.h"
 #include "ps/Pyrogenesis.h"
 #include "ps/Replay.h"
 #include "ps/SavedGame.h"
+#include "ps/Util.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "simulation2/Simulation2.h"
 
-#include <sstream>
 #include <fstream>
-#include <iomanip>
 
 const u32 DEFAULT_TURN_LENGTH_MP = 500;
 const u32 DEFAULT_TURN_LENGTH_SP = 200;
 
 static const int COMMAND_DELAY = 2;
 
 #if 0
 #define NETTURN_LOG(args) debug_printf args
 #else
 #define NETTURN_LOG(args)
 #endif
 
-static std::string Hexify(const std::string& s)
-{
-	std::stringstream str;
-	str << std::hex;
-	for (size_t i = 0; i < s.size(); ++i)
-		str << std::setfill('0') << std::setw(2) << (int)(unsigned char)s[i];
-	return str.str();
-}
-
 CNetTurnManager::CNetTurnManager(CSimulation2& simulation, u32 defaultTurnLength, int clientId, IReplayLogger& replay) :
 	m_Simulation2(simulation), m_CurrentTurn(0), m_ReadyTurn(1), m_TurnLength(defaultTurnLength), m_DeltaSimTime(0),
 	m_PlayerId(-1), m_ClientId(clientId), m_HasSyncError(false), m_Replay(replay),
 	m_TimeWarpNumTurns(0), m_FinalTurn(std::numeric_limits<u32>::max())
 {
 	// When we are on turn n, we schedule new commands for n+2.
 	// We know that all other clients have finished scheduling commands for n (else we couldn't have got here).
 	// We know we have not yet finished scheduling commands for n+2.
 	// Hence other clients can be on turn n-1, n, n+1, and no other.
 	// So they can be sending us commands scheduled for n+1, n+2, n+3.
 	// So we need a 3-element buffer:
 	m_QueuedCommands.resize(COMMAND_DELAY + 1);
 }
 
 void CNetTurnManager::ResetState(u32 newCurrentTurn, u32 newReadyTurn)
 {
 	m_CurrentTurn = newCurrentTurn;
 	m_ReadyTurn = newReadyTurn;
 	m_DeltaSimTime = 0;
 	size_t queuedCommandsSize = m_QueuedCommands.size();
 	m_QueuedCommands.clear();
 	m_QueuedCommands.resize(queuedCommandsSize);
 }
 
 void CNetTurnManager::SetPlayerID(int playerId)
 {
 	m_PlayerId = playerId;
 }
 
 bool CNetTurnManager::WillUpdate(float simFrameLength)
 {
 	// Keep this in sync with the return value of Update()
 
 	if (m_CurrentTurn > m_FinalTurn)
 		return false;
 
 	if (m_DeltaSimTime + simFrameLength < 0)
 		return false;
 
 	if (m_ReadyTurn <= m_CurrentTurn)
 		return false;
 
 	return true;
 }
 
 bool CNetTurnManager::Update(float simFrameLength, size_t maxTurns)
 {
 	if (m_CurrentTurn > m_FinalTurn)
 		return false;
 
 	m_DeltaSimTime += simFrameLength;
 
 	// If the game becomes laggy, m_DeltaSimTime increases progressively.
 	// The engine will fast forward accordingly to catch up.
 	// To keep the game playable, stop fast forwarding after 2 turn lengths.
 	m_DeltaSimTime = std::min(m_DeltaSimTime, 2.0f * m_TurnLength / 1000.0f);
 
 	// If we haven't reached the next turn yet, do nothing
 	if (m_DeltaSimTime < 0)
 		return false;
 
 	NETTURN_LOG((L"Update current=%d ready=%d\n", m_CurrentTurn, m_ReadyTurn));
 
 	// Check that the next turn is ready for execution
 	if (m_ReadyTurn <= m_CurrentTurn)
 	{
 		// Oops, we wanted to start the next turn but it's not ready yet -
 		// there must be too much network lag.
 		// TODO: complain to the user.
 		// TODO: send feedback to the server to increase the turn length.
 
 		// Reset the next-turn timer to 0 so we try again next update but
 		// so we don't rush to catch up in subsequent turns.
 		// TODO: we should do clever rate adjustment instead of just pausing like this.
 		m_DeltaSimTime = 0;
 
 		return false;
 	}
 
 	maxTurns = std::max((size_t)1, maxTurns); // always do at least one turn
 
 	for (size_t i = 0; i < maxTurns; ++i)
 	{
 		// Check that we've reached the i'th next turn
 		if (m_DeltaSimTime < 0)
 			break;
 
 		// Check that the i'th next turn is still ready
 		if (m_ReadyTurn <= m_CurrentTurn)
 			break;
 
 		NotifyFinishedOwnCommands(m_CurrentTurn + COMMAND_DELAY);
 
 		// Increase now, so Update can send new commands for a subsequent turn
 		++m_CurrentTurn;
 
 		// Clean up any destroyed entities since the last turn (e.g. placement previews
 		// or rally point flags generated by the GUI). (Must do this before the time warp
 		// serialization.)
 		m_Simulation2.FlushDestroyedEntities();
 
 		// Save the current state for rewinding, if enabled
 		if (m_TimeWarpNumTurns && (m_CurrentTurn % m_TimeWarpNumTurns) == 0)
 		{
 			PROFILE3("time warp serialization");
 			std::stringstream stream;
 			m_Simulation2.SerializeState(stream);
 			m_TimeWarpStates.push_back(stream.str());
 		}
 
 		// Put all the client commands into a single list, in a globally consistent order
 		std::vector<SimulationCommand> commands;
 		for (std::pair<const u32, std::vector<SimulationCommand>>& p : m_QueuedCommands[0])
 			commands.insert(commands.end(), std::make_move_iterator(p.second.begin()), std::make_move_iterator(p.second.end()));
 
 		m_QueuedCommands.pop_front();
 		m_QueuedCommands.resize(m_QueuedCommands.size() + 1);
 
 		m_Replay.Turn(m_CurrentTurn-1, m_TurnLength, commands);
 
 		NETTURN_LOG((L"Running %d cmds\n", commands.size()));
 
 		m_Simulation2.Update(m_TurnLength, commands);
 
 		NotifyFinishedUpdate(m_CurrentTurn);
 
 		// Set the time for the next turn update
 		m_DeltaSimTime -= m_TurnLength / 1000.f;
 	}
 
 	return true;
 }
 
 bool CNetTurnManager::UpdateFastForward()
 {
 	m_DeltaSimTime = 0;
 
 	NETTURN_LOG((L"UpdateFastForward current=%d ready=%d\n", m_CurrentTurn, m_ReadyTurn));
 
 	// Check that the next turn is ready for execution
 	if (m_ReadyTurn <= m_CurrentTurn)
 		return false;
 
 	while (m_ReadyTurn > m_CurrentTurn)
 	{
 		// TODO: It would be nice to remove some of the duplication with Update()
 		// (This is similar but doesn't call any Notify functions or update DeltaTime,
 		// it just updates the simulation state)
 
 		++m_CurrentTurn;
 
 		m_Simulation2.FlushDestroyedEntities();
 
 		// Put all the client commands into a single list, in a globally consistent order
 		std::vector<SimulationCommand> commands;
 		for (std::pair<const u32, std::vector<SimulationCommand>>& p : m_QueuedCommands[0])
 			commands.insert(commands.end(), std::make_move_iterator(p.second.begin()), std::make_move_iterator(p.second.end()));
 
 		m_QueuedCommands.pop_front();
 		m_QueuedCommands.resize(m_QueuedCommands.size() + 1);
 
 		m_Replay.Turn(m_CurrentTurn-1, m_TurnLength, commands);
 
 		NETTURN_LOG((L"Running %d cmds\n", commands.size()));
 
 		m_Simulation2.Update(m_TurnLength, commands);
 	}
 
 	return true;
 }
 
 void CNetTurnManager::OnSyncError(u32 turn, const CStr& expectedHash, std::vector<CSyncErrorMessage::S_m_PlayerNames>& playerNames)
 {
 	NETTURN_LOG((L"OnSyncError(%d, %hs)\n", turn, Hexify(expectedHash).c_str()));
 
 	// Only complain the first time
 	if (m_HasSyncError)
 		return;
 
 	bool quick = !TurnNeedsFullHash(turn);
 	std::string hash;
 	ENSURE(m_Simulation2.ComputeStateHash(hash, quick));
 
 	OsPath path = psLogDir() / "oos_dump.txt";
 	std::ofstream file (OsString(path).c_str(), std::ofstream::out | std::ofstream::trunc);
 	m_Simulation2.DumpDebugState(file);
 	file.close();
 
 	hash = Hexify(hash);
 	const std::string& expectedHashHex = Hexify(expectedHash);
 
 	DisplayOOSError(turn, hash, expectedHashHex, false, &playerNames, &path);
 }
 
 void CNetTurnManager::DisplayOOSError(u32 turn, const CStr& hash, const CStr& expectedHash, bool isReplay, std::vector<CSyncErrorMessage::S_m_PlayerNames>* playerNames = NULL, OsPath* path = NULL)
 {
 	m_HasSyncError = true;
 
 	std::stringstream msg;
 	msg << "Out of sync on turn " << turn;
 
 	if (playerNames)
 		for (size_t i = 0; i < playerNames->size(); ++i)
 			msg << (i == 0 ? "\nPlayers: " : ", ") << utf8_from_wstring((*playerNames)[i].m_Name);
 
 	if (isReplay)
 		msg << "\n\n" << "The current game state is different from the original game state.";
 	else
 		msg << "\n\n" << "Your game state is " << (expectedHash == hash ? "identical to" : "different from") << " the hosts game state.";
 
 	if (path)
 		msg << "\n\n" << "Dumping current state to " << CStr(path->string8()).EscapeToPrintableASCII();
 
 	LOGERROR("%s", msg.str());
 
 	if (g_GUI)
 		g_GUI->DisplayMessageBox(600, 350, L"Sync error", wstring_from_utf8(msg.str()));
 }
 
 void CNetTurnManager::Interpolate(float simFrameLength, float realFrameLength)
 {
 	// TODO: using m_TurnLength might be a bit dodgy when length changes - maybe
 	// we need to save the previous turn length?
 
 	float offset = clamp(m_DeltaSimTime / (m_TurnLength / 1000.f) + 1.0, 0.0, 1.0);
 
 	// Stop animations while still updating the selection highlight
 	if (m_CurrentTurn > m_FinalTurn)
 		simFrameLength = 0;
 
 	m_Simulation2.Interpolate(simFrameLength, offset, realFrameLength);
 }
 
 void CNetTurnManager::AddCommand(int client, int player, JS::HandleValue data, u32 turn)
 {
 	NETTURN_LOG((L"AddCommand(client=%d player=%d turn=%d)\n", client, player, turn));
 
 	if (!(m_CurrentTurn < turn && turn <= m_CurrentTurn + COMMAND_DELAY + 1))
 	{
 		debug_warn(L"Received command for invalid turn");
 		return;
 	}
 
 	m_Simulation2.GetScriptInterface().FreezeObject(data, true);
 	m_QueuedCommands[turn - (m_CurrentTurn+1)][client].emplace_back(player, m_Simulation2.GetScriptInterface().GetContext(), data);
 }
 
 void CNetTurnManager::FinishedAllCommands(u32 turn, u32 turnLength)
 {
 	NETTURN_LOG((L"FinishedAllCommands(%d, %d)\n", turn, turnLength));
 
 	ENSURE(turn == m_ReadyTurn + 1);
 	m_ReadyTurn = turn;
 	m_TurnLength = turnLength;
 }
 
 bool CNetTurnManager::TurnNeedsFullHash(u32 turn)
 {
 	// Check immediately for errors caused by e.g. inconsistent game versions
 	// (The hash is computed after the first sim update, so we start at turn == 1)
 	if (turn == 1)
 		return true;
 
 	// Otherwise check the full state every ~10 seconds in multiplayer games
 	// (TODO: should probably remove this when we're reasonably sure the game
 	// isn't too buggy, since the full hash is still pretty slow)
 	if (turn % 20 == 0)
 		return true;
 
 	return false;
 }
 
 void CNetTurnManager::EnableTimeWarpRecording(size_t numTurns)
 {
 	m_TimeWarpStates.clear();
 	m_TimeWarpNumTurns = numTurns;
 }
 
 void CNetTurnManager::RewindTimeWarp()
 {
 	if (m_TimeWarpStates.empty())
 		return;
 
 	std::stringstream stream(m_TimeWarpStates.back());
 	m_Simulation2.DeserializeState(stream);
 	m_TimeWarpStates.pop_back();
 
 	// Reset the turn manager state, so we won't execute stray commands and
 	// won't do the next snapshot until the appropriate time.
 	// (Ideally we ought to serialise the turn manager state and restore it
 	// here, but this is simpler for now.)
 	ResetState(0, 1);
 }
 
 void CNetTurnManager::QuickSave()
 {
 	TIMER(L"QuickSave");
 
 	std::stringstream stream;
 	if (!m_Simulation2.SerializeState(stream))
 	{
 		LOGERROR("Failed to quicksave game");
 		return;
 	}
 
 	m_QuickSaveState = stream.str();
 	if (g_GUI)
 		m_QuickSaveMetadata = g_GUI->GetSavedGameData();
 	else
 		m_QuickSaveMetadata = std::string();
 
 	LOGMESSAGERENDER("Quicksaved game");
 
 }
 
 void CNetTurnManager::QuickLoad()
 {
 	TIMER(L"QuickLoad");
 
 	if (m_QuickSaveState.empty())
 	{
 		LOGERROR("Cannot quickload game - no game was quicksaved");
 		return;
 	}
 
 	std::stringstream stream(m_QuickSaveState);
 	if (!m_Simulation2.DeserializeState(stream))
 	{
 		LOGERROR("Failed to quickload game");
 		return;
 	}
 
 	if (g_GUI && !m_QuickSaveMetadata.empty())
 		g_GUI->RestoreSavedGameData(m_QuickSaveMetadata);
 
 	LOGMESSAGERENDER("Quickloaded game");
 
 	// See RewindTimeWarp
 	ResetState(0, 1);
 }
 
 
 CNetClientTurnManager::CNetClientTurnManager(CSimulation2& simulation, CNetClient& client, int clientId, IReplayLogger& replay) :
 	CNetTurnManager(simulation, DEFAULT_TURN_LENGTH_MP, clientId, replay), m_NetClient(client)
 {
 }
 
 void CNetClientTurnManager::PostCommand(JS::HandleValue data)
 {
 	NETTURN_LOG((L"PostCommand()\n"));
 
 	// Transmit command to server
 	CSimulationMessage msg(m_Simulation2.GetScriptInterface(), m_ClientId, m_PlayerId, m_CurrentTurn + COMMAND_DELAY, data);
 	m_NetClient.SendMessage(&msg);
 
 	// Add to our local queue
 	//AddCommand(m_ClientId, m_PlayerId, data, m_CurrentTurn + COMMAND_DELAY);
 	// TODO: we should do this when the server stops sending our commands back to us
 }
 
 void CNetClientTurnManager::NotifyFinishedOwnCommands(u32 turn)
 {
 	NETTURN_LOG((L"NotifyFinishedOwnCommands(%d)\n", turn));
 
 	CEndCommandBatchMessage msg;
 
 	msg.m_Turn = turn;
 
 	// The turn-length field of the CEndCommandBatchMessage is currently only relevant
 	// when sending it from the server to the clients.
 	// It could be used to verify that the client simulated the correct turn length.
 	msg.m_TurnLength = 0;
 
 	m_NetClient.SendMessage(&msg);
 }
 
 void CNetClientTurnManager::NotifyFinishedUpdate(u32 turn)
 {
 	bool quick = !TurnNeedsFullHash(turn);
 	std::string hash;
 	{
 		PROFILE3("state hash check");
 		ENSURE(m_Simulation2.ComputeStateHash(hash, quick));
 	}
 
 	NETTURN_LOG((L"NotifyFinishedUpdate(%d, %hs)\n", turn, Hexify(hash).c_str()));
 
 	m_Replay.Hash(hash, quick);
 
 	// Don't send the hash if OOS
 	if (m_HasSyncError)
 		return;
 
 	// Send message to the server
 	CSyncCheckMessage msg;
 	msg.m_Turn = turn;
 	msg.m_Hash = hash;
 	m_NetClient.SendMessage(&msg);
 }
 
 void CNetClientTurnManager::OnDestroyConnection()
 {
 	NotifyFinishedOwnCommands(m_CurrentTurn + COMMAND_DELAY);
 }
 
 void CNetClientTurnManager::OnSimulationMessage(CSimulationMessage* msg)
 {
 	// Command received from the server - store it for later execution
 	AddCommand(msg->m_Client, msg->m_Player, msg->m_Data, msg->m_Turn);
 }
 
 
 CNetLocalTurnManager::CNetLocalTurnManager(CSimulation2& simulation, IReplayLogger& replay) :
 	CNetTurnManager(simulation, DEFAULT_TURN_LENGTH_SP, 0, replay)
 {
 }
 
 void CNetLocalTurnManager::PostCommand(JS::HandleValue data)
 {
 	// Add directly to the next turn, ignoring COMMAND_DELAY,
 	// because we don't need to compensate for network latency
 	AddCommand(m_ClientId, m_PlayerId, data, m_CurrentTurn + 1);
 }
 
 void CNetLocalTurnManager::NotifyFinishedOwnCommands(u32 turn)
 {
 	FinishedAllCommands(turn, m_TurnLength);
 }
 
 void CNetLocalTurnManager::NotifyFinishedUpdate(u32 UNUSED(turn))
 {
 #if 0 // this hurts performance and is only useful for verifying log replays
 	std::string hash;
 	{
 		PROFILE3("state hash check");
 		ENSURE(m_Simulation2.ComputeStateHash(hash));
 	}
 	m_Replay.Hash(hash);
 #endif
 }
 
 void CNetLocalTurnManager::OnSimulationMessage(CSimulationMessage* UNUSED(msg))
 {
 	debug_warn(L"This should never be called");
 }
 
 CNetReplayTurnManager::CNetReplayTurnManager(CSimulation2& simulation, IReplayLogger& replay) :
 	CNetLocalTurnManager(simulation, replay)
 {
 }
 
 void CNetReplayTurnManager::StoreReplayCommand(u32 turn, int player, const std::string& command)
 {
 	// Using the pair we make sure that commands per turn will be processed in the correct order
 	m_ReplayCommands[turn].emplace_back(player, command);
 }
 
 void CNetReplayTurnManager::StoreReplayHash(u32 turn, const std::string& hash, bool quick)
 {
 	m_ReplayHash[turn] = std::make_pair(hash, quick);
 }
 
 void CNetReplayTurnManager::StoreReplayTurnLength(u32 turn, u32 turnLength)
 {
 	m_ReplayTurnLengths[turn] = turnLength;
 
 	// Initialize turn length
 	if (turn == 0)
 		m_TurnLength = m_ReplayTurnLengths[0];
 }
 
 void CNetReplayTurnManager::StoreFinalReplayTurn(u32 turn)
 {
 	m_FinalTurn = turn;
 }
 
 void CNetReplayTurnManager::NotifyFinishedUpdate(u32 turn)
 {
 	if (turn == 1 && m_FinalTurn == 0)
 		g_GUI->SendEventToAll("ReplayFinished");
 
 	if (turn > m_FinalTurn)
 		return;
 
 	DoTurn(turn);
 
 	// Compare hash if it exists in the replay and if we didn't have an OOS already
 	if (m_HasSyncError || m_ReplayHash.find(turn) == m_ReplayHash.end())
 		return;
 
 	std::string expectedHash = m_ReplayHash[turn].first;
 	bool quickHash = m_ReplayHash[turn].second;
 
 	// Compute hash
 	std::string hash;
 	ENSURE(m_Simulation2.ComputeStateHash(hash, quickHash));
 	hash = Hexify(hash);
 
 	if (hash != expectedHash)
 		DisplayOOSError(turn, hash, expectedHash, true);
 }
 
 void CNetReplayTurnManager::DoTurn(u32 turn)
 {
 	debug_printf("Executing turn %u of %u\n", turn, m_FinalTurn);
 
 	m_TurnLength = m_ReplayTurnLengths[turn];
 
 	// Simulate commands for that turn
 	for (const std::pair<player_id_t, std::string>& p : m_ReplayCommands[turn])
 	{
 		JS::RootedValue command(m_Simulation2.GetScriptInterface().GetContext());
 		m_Simulation2.GetScriptInterface().ParseJSON(p.second, &command);
 		AddCommand(m_ClientId, p.first, command, m_CurrentTurn + 1);
 	}
 
 	if (turn == m_FinalTurn)
 		g_GUI->SendEventToAll("ReplayFinished");
 }
 
 CNetServerTurnManager::CNetServerTurnManager(CNetServerWorker& server) :
 	m_NetServer(server), m_ReadyTurn(1), m_TurnLength(DEFAULT_TURN_LENGTH_MP), m_HasSyncError(false)
 {
 	// The first turn we will actually execute is number 2,
 	// so store dummy values into the saved lengths list
 	m_SavedTurnLengths.push_back(0);
 	m_SavedTurnLengths.push_back(0);
 }
 
 void CNetServerTurnManager::NotifyFinishedClientCommands(int client, u32 turn)
 {
 	NETTURN_LOG((L"NotifyFinishedClientCommands(client=%d, turn=%d)\n", client, turn));
 
 	// Must be a client we've already heard of
 	ENSURE(m_ClientsReady.find(client) != m_ClientsReady.end());
 
 	// Clients must advance one turn at a time
 	ENSURE(turn == m_ClientsReady[client] + 1);
 	m_ClientsReady[client] = turn;
 
 	// Check whether this was the final client to become ready
 	CheckClientsReady();
 }
 
 void CNetServerTurnManager::CheckClientsReady()
 {
 	// See if all clients (including self) are ready for a new turn
 	for (const std::pair<int, u32>& clientReady : m_ClientsReady)
 	{
 		NETTURN_LOG((L"  %d: %d <=? %d\n", clientReady.first, clientReady.second, m_ReadyTurn));
 		if (clientReady.second <= m_ReadyTurn)
 			return; // wasn't ready for m_ReadyTurn+1
 	}
 
 	++m_ReadyTurn;
 
 	NETTURN_LOG((L"CheckClientsReady: ready for turn %d\n", m_ReadyTurn));
 
 	// Tell all clients that the next turn is ready
 	CEndCommandBatchMessage msg;
 	msg.m_TurnLength = m_TurnLength;
 	msg.m_Turn = m_ReadyTurn;
 	m_NetServer.Broadcast(&msg);
 
 	ENSURE(m_SavedTurnLengths.size() == m_ReadyTurn);
 	m_SavedTurnLengths.push_back(m_TurnLength);
 }
 
 void CNetServerTurnManager::NotifyFinishedClientUpdate(int client, const CStrW& playername, u32 turn, const CStr& hash)
 {
 	// Clients must advance one turn at a time
 	ENSURE(turn == m_ClientsSimulated[client] + 1);
 	m_ClientsSimulated[client] = turn;
 
 	// Check for OOS only if in sync
 	if (m_HasSyncError)
 		return;
 
 	m_ClientPlayernames[client] = playername;
 	m_ClientStateHashes[turn][client] = hash;
 
 	// Find the newest turn which we know all clients have simulated
 	u32 newest = std::numeric_limits<u32>::max();
 	for (const std::pair<int, u32>& clientSimulated : m_ClientsSimulated)
 		if (clientSimulated.second < newest)
 			newest = clientSimulated.second;
 
 	// For every set of state hashes that all clients have simulated, check for OOS
 	for (const std::pair<u32, std::map<int, std::string>>& clientStateHash : m_ClientStateHashes)
 	{
 		if (clientStateHash.first > newest)
 			break;
 
 		// Assume the host is correct (maybe we should choose the most common instead to help debugging)
 		std::string expected = clientStateHash.second.begin()->second;
 
 		// Find all players that are OOS on that turn
 		std::vector<CStrW> OOSPlayerNames;
 		for (const std::pair<int, std::string>& hashPair : clientStateHash.second)
 		{
 			NETTURN_LOG((L"sync check %d: %d = %hs\n", it->first, cit->first, Hexify(cit->second).c_str()));
 			if (hashPair.second != expected)
 			{
 				// Oh no, out of sync
 				m_HasSyncError = true;
 				OOSPlayerNames.push_back(m_ClientPlayernames[hashPair.first]);
 			}
 		}
 
 		// Tell everyone about it
 		if (m_HasSyncError)
 		{
 			CSyncErrorMessage msg;
 			msg.m_Turn = clientStateHash.first;
 			msg.m_HashExpected = expected;
 			for (const CStrW& playername : OOSPlayerNames)
 			{
 				CSyncErrorMessage::S_m_PlayerNames h;
 				h.m_Name = playername;
 				msg.m_PlayerNames.push_back(h);
 			}
 			m_NetServer.Broadcast(&msg);
 			break;
 		}
 	}
 
 	// Delete the saved hashes for all turns that we've already verified
 	m_ClientStateHashes.erase(m_ClientStateHashes.begin(), m_ClientStateHashes.lower_bound(newest+1));
 }
 
 void CNetServerTurnManager::InitialiseClient(int client, u32 turn)
 {
 	NETTURN_LOG((L"InitialiseClient(client=%d, turn=%d)\n", client, turn));
 
 	ENSURE(m_ClientsReady.find(client) == m_ClientsReady.end());
 	m_ClientsReady[client] = turn + 1;
 	m_ClientsSimulated[client] = turn;
 }
 
 void CNetServerTurnManager::UninitialiseClient(int client)
 {
 	NETTURN_LOG((L"UninitialiseClient(client=%d)\n", client));
 
 	ENSURE(m_ClientsReady.find(client) != m_ClientsReady.end());
 	m_ClientsReady.erase(client);
 	m_ClientsSimulated.erase(client);
 
 	// Check whether we're ready for the next turn now that we're not
 	// waiting for this client any more
 	CheckClientsReady();
 }
 
 void CNetServerTurnManager::SetTurnLength(u32 msecs)
 {
 	m_TurnLength = msecs;
 }
 
 u32 CNetServerTurnManager::GetSavedTurnLength(u32 turn)
 {
 	ENSURE(turn <= m_ReadyTurn);
 	return m_SavedTurnLengths.at(turn);
 }
Index: ps/trunk/source/ps/Replay.cpp
===================================================================
--- ps/trunk/source/ps/Replay.cpp	(revision 18590)
+++ ps/trunk/source/ps/Replay.cpp	(revision 18591)
@@ -1,273 +1,262 @@
 /* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "Replay.h"
 
 #include "graphics/TerrainTextureManager.h"
 #include "lib/timer.h"
 #include "lib/file/file_system.h"
 #include "lib/res/h_mgr.h"
 #include "lib/tex/tex.h"
 #include "ps/Game.h"
 #include "ps/CLogger.h"
 #include "ps/Loader.h"
 #include "ps/Mod.h"
 #include "ps/Profile.h"
 #include "ps/ProfileViewer.h"
 #include "ps/Pyrogenesis.h"
 #include "ps/Util.h"
 #include "ps/VisualReplay.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "scriptinterface/ScriptStats.h"
 #include "simulation2/Simulation2.h"
 #include "simulation2/helpers/SimulationCommand.h"
 
 #include <ctime>
-#include <sstream>
 #include <fstream>
-#include <iomanip>
-
-static std::string Hexify(const std::string& s)
-{
-	std::stringstream str;
-	str << std::hex;
-	for (size_t i = 0; i < s.size(); ++i)
-		str << std::setfill('0') << std::setw(2) << (int)(unsigned char)s[i];
-	return str.str();
-}
 
 CReplayLogger::CReplayLogger(ScriptInterface& scriptInterface) :
 	m_ScriptInterface(scriptInterface), m_Stream(NULL)
 {
 }
 
 CReplayLogger::~CReplayLogger()
 {
 	delete m_Stream;
 }
 
 void CReplayLogger::StartGame(JS::MutableHandleValue attribs)
 {
 	// Add timestamp, since the file-modification-date can change
 	m_ScriptInterface.SetProperty(attribs, "timestamp", std::to_string(std::time(nullptr)));
 
 	// Add engine version and currently loaded mods for sanity checks when replaying
 	m_ScriptInterface.SetProperty(attribs, "engine_version", CStr(engine_version));
 	m_ScriptInterface.SetProperty(attribs, "mods", g_modsLoaded);
 
 	m_Directory = createDateIndexSubdirectory(VisualReplay::GetDirectoryName());
 	debug_printf("Writing replay to %s\n", m_Directory.string8().c_str());
 
 	m_Stream = new std::ofstream(OsString(m_Directory / L"commands.txt").c_str(), std::ofstream::out | std::ofstream::trunc);
 	*m_Stream << "start " << m_ScriptInterface.StringifyJSON(attribs, false) << "\n";
 }
 
 void CReplayLogger::Turn(u32 n, u32 turnLength, std::vector<SimulationCommand>& commands)
 {
 	JSContext* cx = m_ScriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 
 	*m_Stream << "turn " << n << " " << turnLength << "\n";
 	for (size_t i = 0; i < commands.size(); ++i)
 	{
 		*m_Stream << "cmd " << commands[i].player << " " << m_ScriptInterface.StringifyJSON(&commands[i].data, false) << "\n";
 	}
 	*m_Stream << "end\n";
 	m_Stream->flush();
 }
 
 void CReplayLogger::Hash(const std::string& hash, bool quick)
 {
 	if (quick)
 		*m_Stream << "hash-quick " << Hexify(hash) << "\n";
 	else
 		*m_Stream << "hash " << Hexify(hash) << "\n";
 }
 
 OsPath CReplayLogger::GetDirectory() const
 {
 	return m_Directory;
 }
 
 ////////////////////////////////////////////////////////////////
 
 CReplayPlayer::CReplayPlayer() :
 	m_Stream(NULL)
 {
 }
 
 CReplayPlayer::~CReplayPlayer()
 {
 	delete m_Stream;
 }
 
 void CReplayPlayer::Load(const std::string& path)
 {
 	ENSURE(!m_Stream);
 
 	m_Stream = new std::ifstream(path.c_str());
 	ENSURE(m_Stream->good());
 }
 
 void CReplayPlayer::Replay(bool serializationtest, bool ooslog)
 {
 	ENSURE(m_Stream);
 
 	new CProfileViewer;
 	new CProfileManager;
 	g_ScriptStatsTable = new CScriptStatsTable;
 	g_ProfileViewer.AddRootTable(g_ScriptStatsTable);
 
 	const int runtimeSize = 384 * 1024 * 1024;
 	const int heapGrowthBytesGCTrigger = 20 * 1024 * 1024;
 	g_ScriptRuntime = ScriptInterface::CreateRuntime(shared_ptr<ScriptRuntime>(), runtimeSize, heapGrowthBytesGCTrigger);
 
 	g_Game = new CGame(true, false);
 	if (serializationtest)
 		g_Game->GetSimulation2()->EnableSerializationTest();
 	if (ooslog)
 		g_Game->GetSimulation2()->EnableOOSLog();
 
 	// Need some stuff for terrain movement costs:
 	// (TODO: this ought to be independent of any graphics code)
 	new CTerrainTextureManager;
 	g_TexMan.LoadTerrainTextures();
 
 	// Initialise h_mgr so it doesn't crash when emitting sounds
 	h_mgr_init();
 
 	std::vector<SimulationCommand> commands;
 	u32 turn = 0;
 	u32 turnLength = 0;
 
 	{
 	JSContext* cx = g_Game->GetSimulation2()->GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 	std::string type;
 	while ((*m_Stream >> type).good())
 	{
 		if (type == "start")
 		{
 			std::string line;
 			std::getline(*m_Stream, line);
 			JS::RootedValue attribs(cx);
 			ENSURE(g_Game->GetSimulation2()->GetScriptInterface().ParseJSON(line, &attribs));
 
 			std::vector<CStr> replayModList;
 			g_Game->GetSimulation2()->GetScriptInterface().GetProperty(attribs, "mods", replayModList);
 
 			for (const CStr& mod : replayModList)
 				if (mod != "user" && std::find(g_modsLoaded.begin(), g_modsLoaded.end(), mod) == g_modsLoaded.end())
 					LOGWARNING("The mod '%s' is required by the replay file, but wasn't passed as an argument!", mod);
 
 			for (const CStr& mod : g_modsLoaded)
 				if (mod != "user" && std::find(replayModList.begin(), replayModList.end(), mod) == replayModList.end())
 					LOGWARNING("The mod '%s' wasn't used when creating this replay file, but was passed as an argument!", mod);
 
 			g_Game->StartGame(&attribs, "");
 
 			// TODO: Non progressive load can fail - need a decent way to handle this
 			LDR_NonprogressiveLoad();
 
 			PSRETURN ret = g_Game->ReallyStartGame();
 			ENSURE(ret == PSRETURN_OK);
 		}
 		else if (type == "turn")
 		{
 			*m_Stream >> turn >> turnLength;
 			debug_printf("Turn %u (%u)...\n", turn, turnLength);
 		}
 		else if (type == "cmd")
 		{
 			player_id_t player;
 			*m_Stream >> player;
 
 			std::string line;
 			std::getline(*m_Stream, line);
 			JS::RootedValue data(cx);
 			g_Game->GetSimulation2()->GetScriptInterface().ParseJSON(line, &data);
 			g_Game->GetSimulation2()->GetScriptInterface().FreezeObject(data, true);
 			commands.emplace_back(SimulationCommand(player, cx, data));
 		}
 		else if (type == "hash" || type == "hash-quick")
 		{
 			std::string replayHash;
 			*m_Stream >> replayHash;
 
 			bool quick = (type == "hash-quick");
 
 			if (turn % 100 == 0)
 			{
 				std::string hash;
 				bool ok = g_Game->GetSimulation2()->ComputeStateHash(hash, quick);
 				ENSURE(ok);
 				std::string hexHash = Hexify(hash);
 				if (hexHash == replayHash)
 					debug_printf("hash ok (%s)\n", hexHash.c_str());
 				else
 					debug_printf("HASH MISMATCH (%s != %s)\n", hexHash.c_str(), replayHash.c_str());
 			}
 		}
 		else if (type == "end")
 		{
 			{
 				g_Profiler2.RecordFrameStart();
 				PROFILE2("frame");
 				g_Profiler2.IncrementFrameNumber();
 				PROFILE2_ATTR("%d", g_Profiler2.GetFrameNumber());
 
 				g_Game->GetSimulation2()->Update(turnLength, commands);
 				commands.clear();
 			}
 
 			g_Profiler.Frame();
 
 			if (turn % 20 == 0)
 				g_ProfileViewer.SaveToFile();
 		}
 		else
 		{
 			debug_printf("Unrecognised replay token %s\n", type.c_str());
 		}
 	}
 	}
 
 	SAFE_DELETE(m_Stream);
 
 	g_Profiler2.SaveToFile();
 
 	std::string hash;
 	bool ok = g_Game->GetSimulation2()->ComputeStateHash(hash, false);
 	ENSURE(ok);
 	debug_printf("# Final state: %s\n", Hexify(hash).c_str());
 	timer_DisplayClientTotals();
 
 	SAFE_DELETE(g_Game);
 
 	// Must be explicitly destructed here to avoid callbacks from the JSAPI trying to use g_Profiler2 when
 	// it's already destructed.
 	g_ScriptRuntime.reset();
 
 	// Clean up
 	delete &g_TexMan;
 
 	delete &g_Profiler;
 	delete &g_ProfileViewer;
 	SAFE_DELETE(g_ScriptStatsTable);
 }
Index: ps/trunk/source/ps/Util.cpp
===================================================================
--- ps/trunk/source/ps/Util.cpp	(revision 18590)
+++ ps/trunk/source/ps/Util.cpp	(revision 18591)
@@ -1,424 +1,433 @@
 /* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "ps/Util.h"
 
 #include "lib/posix/posix_utsname.h"
 #include "lib/ogl.h"
 #include "lib/timer.h"
 #include "lib/bits.h"	// round_up
 #include "lib/allocators/shared_ptr.h"
 #include "lib/sysdep/sysdep.h"	// sys_OpenFile
 #include "lib/sysdep/gfx.h"
 #include "lib/sysdep/snd.h"
 #include "lib/sysdep/cpu.h"
 #include "lib/sysdep/os_cpu.h"
 #if ARCH_X86_X64
 #include "lib/sysdep/arch/x86_x64/topology.h"
 #endif
 #include "lib/sysdep/smbios.h"
 #include "lib/tex/tex.h"
 
 #include "i18n/L10n.h"
 #include "lib/utf8.h"
 
 #include "ps/GameSetup/Config.h"
 #include "ps/GameSetup/GameSetup.h"
 #include "ps/Game.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "ps/VideoMode.h"
 #include "renderer/Renderer.h"
 #include "maths/MathUtil.h"
 #include "graphics/GameView.h"
 
 extern CStrW g_CursorName;
 
 static std::string SplitExts(const char *exts)
 {
 	std::string str = exts;
 	std::string ret = "";
 	size_t idx = str.find_first_of(" ");
 	while(idx != std::string::npos)
 	{
 		if(idx >= str.length() - 1)
 		{
 			ret += str;
 			break;
 		}
 
 		ret += str.substr(0, idx);
 		ret += "\n";
 		str = str.substr(idx + 1);
 		idx = str.find_first_of(" ");
 	}
 
 	return ret;
 }
 
 
 void WriteSystemInfo()
 {
 	TIMER(L"write_sys_info");
 
 	// get_cpu_info and gfx_detect already called during init - see call site
 	snd_detect();
 
 	struct utsname un;
 	uname(&un);
 
 	OsPath pathname = psLogDir()/"system_info.txt";
 	FILE* f = sys_OpenFile(pathname, "w");
 	if(!f)
 		return;
 
 	// current timestamp (redundant WRT OS timestamp, but that is not
 	// visible when people are posting this file's contents online)
 	{
 	wchar_t timestampBuf[100] = {'\0'};
 	time_t seconds;
 	time(&seconds);
 	struct tm* t = gmtime(&seconds);
 	const size_t charsWritten = wcsftime(timestampBuf, ARRAY_SIZE(timestampBuf), L"(generated %Y-%m-%d %H:%M:%S UTC)", t);
 	ENSURE(charsWritten != 0);
 	fprintf(f, "%ls\n\n", timestampBuf);
 	}
 
 	// OS
 	fprintf(f, "OS             : %s %s (%s)\n", un.sysname, un.release, un.version);
 
 	// CPU
 	fprintf(f, "CPU            : %s, %s", un.machine, cpu_IdentifierString());
 #if ARCH_X86_X64
 	fprintf(f, " (%dx%dx%d)", (int)topology::NumPackages(), (int)topology::CoresPerPackage(), (int)topology::LogicalPerCore());
 #endif
 	double cpuClock = os_cpu_ClockFrequency();	// query OS (may fail)
 #if ARCH_X86_X64
 	if(cpuClock <= 0.0)
 		cpuClock = x86_x64::ClockFrequency();	// measure (takes a few ms)
 #endif
 	if(cpuClock > 0.0)
 	{
 		if(cpuClock < 1e9)
 			fprintf(f, ", %.2f MHz\n", cpuClock*1e-6);
 		else
 			fprintf(f, ", %.2f GHz\n", cpuClock*1e-9);
 	}
 	else
 		fprintf(f, "\n");
 
 	// memory
 	fprintf(f, "Memory         : %u MiB; %u MiB free\n", (unsigned)os_cpu_MemorySize(), (unsigned)os_cpu_MemoryAvailable());
 
 	// graphics
 	const std::wstring cardName = gfx::CardName();
 	const std::wstring driverInfo = gfx::DriverInfo();
 	fprintf(f, "Graphics Card  : %ls\n", cardName.c_str());
 	fprintf(f, "OpenGL Drivers : %s; %ls\n", glGetString(GL_VERSION), driverInfo.c_str());
 	fprintf(f, "Video Mode     : %dx%d:%d\n", g_VideoMode.GetXRes(), g_VideoMode.GetYRes(), g_VideoMode.GetBPP());
 
 	// sound
 	fprintf(f, "Sound Card     : %ls\n", snd_card);
 	fprintf(f, "Sound Drivers  : %ls\n", snd_drv_ver);
 
 	// OpenGL extensions (write them last, since it's a lot of text)
 	const char* exts = ogl_ExtensionString();
 	if (!exts) exts = "{unknown}";
 	fprintf(f, "\nOpenGL Extensions: \n%s\n", SplitExts(exts).c_str());
 
 	// System Management BIOS (even more text than OpenGL extensions)
 	std::string smbios = SMBIOS::StringizeStructures(SMBIOS::GetStructures());
 	fprintf(f, "\nSMBIOS: \n%s\n", smbios.c_str());
 
 	fclose(f);
 	f = 0;
 }
 
 
 // not thread-safe!
 static const wchar_t* HardcodedErrorString(int err)
 {
 	static wchar_t description[200];
 	StatusDescription((Status)err, description, ARRAY_SIZE(description));
 	return description;
 }
 
 // not thread-safe!
 const wchar_t* ErrorString(int err)
 {
 	// language file not available (yet)
 	return HardcodedErrorString(err);
 
 	// TODO: load from language file
 }
 
 
 
 // write the specified texture to disk.
 // note: <t> cannot be made const because the image may have to be
 // transformed to write it out in the format determined by <fn>'s extension.
 Status tex_write(Tex* t, const VfsPath& filename)
 {
 	DynArray da;
 	RETURN_STATUS_IF_ERR(t->encode(filename.Extension(), &da));
 
 	// write to disk
 	Status ret = INFO::OK;
 	{
 		shared_ptr<u8> file = DummySharedPtr(da.base);
 		const ssize_t bytes_written = g_VFS->CreateFile(filename, file, da.pos);
 		if(bytes_written > 0)
 			ENSURE(bytes_written == (ssize_t)da.pos);
 		else
 			ret = (Status)bytes_written;
 	}
 
 	(void)da_free(&da);
 	return ret;
 }
 
 /**
  * Return an unused directory, based on date and index (for example 2016-02-09_0001)
  */
 OsPath createDateIndexSubdirectory(const OsPath& parentDir)
 {
     const std::time_t timestamp = std::time(nullptr);
     const struct std::tm* now = std::localtime(&timestamp);
 
 	// Two processes executing this simultaneously might attempt to create the same directory.
 	int tries = 0;
 	const int maxTries = 10;
 
 	int i = 0;
 	OsPath path;
 	char directory[256];
 
 	do
 	{
 		sprintf(directory, "%04d-%02d-%02d_%04d", now->tm_year+1900, now->tm_mon+1, now->tm_mday, ++i);
 		path = parentDir / CStr(directory);
 
 		if (DirectoryExists(path) || FileExists(path))
 			continue;
 
 		if (CreateDirectories(path, 0700, ++tries > maxTries) == INFO::OK)
 			break;
 
 	} while(tries <= maxTries);
 
 	return path;
 }
 
 static size_t s_nextScreenshotNumber;
 
 // <extension> identifies the file format that is to be written
 // (case-insensitive). examples: "bmp", "png", "jpg".
 // BMP is good for quick output at the expense of large files.
 void WriteScreenshot(const VfsPath& extension)
 {
 	// get next available numbered filename
 	// note: %04d -> always 4 digits, so sorting by filename works correctly.
 	const VfsPath basenameFormat(L"screenshots/screenshot%04d");
 	const VfsPath filenameFormat = basenameFormat.ChangeExtension(extension);
 	VfsPath filename;
 	vfs::NextNumberedFilename(g_VFS, filenameFormat, s_nextScreenshotNumber, filename);
 
 	const size_t w = (size_t)g_xres, h = (size_t)g_yres;
 	const size_t bpp = 24;
 	GLenum fmt = GL_RGB;
 	int flags = TEX_BOTTOM_UP;
 	// we want writing BMP to be as fast as possible,
 	// so read data from OpenGL in BMP format to obviate conversion.
 	if(extension == L".bmp")
 	{
 #if !CONFIG2_GLES // GLES doesn't support BGR
 		fmt = GL_BGR;
 		flags |= TEX_BGR;
 #endif
 	}
 
 	// Hide log messages and re-render
 	RenderLogger(false);
 	Render();
 	RenderLogger(true);
 
 	const size_t img_size = w * h * bpp/8;
 	const size_t hdr_size = tex_hdr_size(filename);
 	shared_ptr<u8> buf;
 	AllocateAligned(buf, hdr_size+img_size, maxSectorSize);
 	GLvoid* img = buf.get() + hdr_size;
 	Tex t;
 	if(t.wrap(w, h, bpp, flags, buf, hdr_size) < 0)
 		return;
 	glReadPixels(0, 0, (GLsizei)w, (GLsizei)h, fmt, GL_UNSIGNED_BYTE, img);
 
 	if (tex_write(&t, filename) == INFO::OK)
 	{
 		OsPath realPath;
 		g_VFS->GetRealPath(filename, realPath);
 
 		LOGMESSAGERENDER(g_L10n.Translate("Screenshot written to '%s'"), realPath.string8());
 
 		debug_printf(
 			CStr(g_L10n.Translate("Screenshot written to '%s'") + "\n").c_str(),
 			realPath.string8().c_str());
 	}
 	else
 		LOGERROR("Error writing screenshot to '%s'", filename.string8());
 }
 
 
 
 // Similar to WriteScreenshot, but generates an image of size 640*tiles x 480*tiles.
 void WriteBigScreenshot(const VfsPath& extension, int tiles)
 {
 	// If the game hasn't started yet then use WriteScreenshot to generate the image.
 	if(g_Game == NULL){ WriteScreenshot(L".bmp"); return; }
 
 	// get next available numbered filename
 	// note: %04d -> always 4 digits, so sorting by filename works correctly.
 	const VfsPath basenameFormat(L"screenshots/screenshot%04d");
 	const VfsPath filenameFormat = basenameFormat.ChangeExtension(extension);
 	VfsPath filename;
 	vfs::NextNumberedFilename(g_VFS, filenameFormat, s_nextScreenshotNumber, filename);
 
 	// Slightly ugly and inflexible: Always draw 640*480 tiles onto the screen, and
 	// hope the screen is actually large enough for that.
 	const int tile_w = 640, tile_h = 480;
 	ENSURE(g_xres >= tile_w && g_yres >= tile_h);
 
 	const int img_w = tile_w*tiles, img_h = tile_h*tiles;
 	const int bpp = 24;
 	GLenum fmt = GL_RGB;
 	int flags = TEX_BOTTOM_UP;
 	// we want writing BMP to be as fast as possible,
 	// so read data from OpenGL in BMP format to obviate conversion.
 	if(extension == L".bmp")
 	{
 #if !CONFIG2_GLES // GLES doesn't support BGR
 		fmt = GL_BGR;
 		flags |= TEX_BGR;
 #endif
 	}
 
 	const size_t img_size = img_w * img_h * bpp/8;
 	const size_t tile_size = tile_w * tile_h * bpp/8;
 	const size_t hdr_size = tex_hdr_size(filename);
 	void* tile_data = malloc(tile_size);
 	if(!tile_data)
 	{
 		WARN_IF_ERR(ERR::NO_MEM);
 		return;
 	}
 	shared_ptr<u8> img_buf;
 	AllocateAligned(img_buf, hdr_size+img_size, maxSectorSize);
 
 	Tex t;
 	GLvoid* img = img_buf.get() + hdr_size;
 	if(t.wrap(img_w, img_h, bpp, flags, img_buf, hdr_size) < 0)
 	{
 		free(tile_data);
 		return;
 	}
 
 	ogl_WarnIfError();
 
 	// Resize various things so that the sizes and aspect ratios are correct
 	{
 		g_Renderer.Resize(tile_w, tile_h);
 		SViewPort vp = { 0, 0, tile_w, tile_h };
 		g_Game->GetView()->GetCamera()->SetViewPort(vp);
 		g_Game->GetView()->SetCameraProjection();
 	}
 
 #if !CONFIG2_GLES
 	// Temporarily move everything onto the front buffer, so the user can
 	// see the exciting progress as it renders (and can tell when it's finished).
 	// (It doesn't just use SwapBuffers, because it doesn't know whether to
 	// call the SDL version or the Atlas version.)
 	GLint oldReadBuffer, oldDrawBuffer;
 	glGetIntegerv(GL_READ_BUFFER, &oldReadBuffer);
 	glGetIntegerv(GL_DRAW_BUFFER, &oldDrawBuffer);
 	glDrawBuffer(GL_FRONT);
 	glReadBuffer(GL_FRONT);
 #endif
 
 	// Hide the cursor
 	CStrW oldCursor = g_CursorName;
 	g_CursorName = L"";
 
 	// Render each tile
 	for (int tile_y = 0; tile_y < tiles; ++tile_y)
 	{
 		for (int tile_x = 0; tile_x < tiles; ++tile_x)
 		{
 			// Adjust the camera to render the appropriate region
 			g_Game->GetView()->GetCamera()->SetProjectionTile(tiles, tile_x, tile_y);
 
 			RenderLogger(false);
 			RenderGui(false);
 			Render();
 			RenderGui(true);
 			RenderLogger(true);
 
 			// Copy the tile pixels into the main image
 			glReadPixels(0, 0, tile_w, tile_h, fmt, GL_UNSIGNED_BYTE, tile_data);
 			for (int y = 0; y < tile_h; ++y)
 			{
 				void* dest = (char*)img + ((tile_y*tile_h + y) * img_w + (tile_x*tile_w)) * bpp/8;
 				void* src = (char*)tile_data + y * tile_w * bpp/8;
 				memcpy(dest, src, tile_w * bpp/8);
 			}
 		}
 	}
 
 	// Restore the old cursor
 	g_CursorName = oldCursor;
 
 #if !CONFIG2_GLES
 	// Restore the buffer settings
 	glDrawBuffer(oldDrawBuffer);
 	glReadBuffer(oldReadBuffer);
 #endif
 
 	// Restore the viewport settings
 	{
 		g_Renderer.Resize(g_xres, g_yres);
 		SViewPort vp = { 0, 0, g_xres, g_yres };
 		g_Game->GetView()->GetCamera()->SetViewPort(vp);
 		g_Game->GetView()->SetCameraProjection();
 		g_Game->GetView()->GetCamera()->SetProjectionTile(1, 0, 0);
 	}
 
 	if (tex_write(&t, filename) == INFO::OK)
 	{
 		OsPath realPath;
 		g_VFS->GetRealPath(filename, realPath);
 
 		LOGMESSAGERENDER(g_L10n.Translate("Screenshot written to '%s'"), realPath.string8());
 
 		debug_printf(
 			CStr(g_L10n.Translate("Screenshot written to '%s'") + "\n").c_str(),
 			realPath.string8().c_str());
 	}
 	else
 		LOGERROR("Error writing screenshot to '%s'", filename.string8());
 
 	free(tile_data);
 }
+
+std::string Hexify(const std::string& s)
+{
+	std::stringstream str;
+	str << std::hex;
+	for (const char& c : s)
+		str << std::setfill('0') << std::setw(2) << (int)(unsigned char)c;
+	return str.str();
+}
Index: ps/trunk/source/ps/Util.h
===================================================================
--- ps/trunk/source/ps/Util.h	(revision 18590)
+++ ps/trunk/source/ps/Util.h	(revision 18591)
@@ -1,36 +1,38 @@
 /* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef PS_UTIL_H
 #define PS_UTIL_H
 
 #include "lib/file/vfs/vfs_path.h"
 
 struct Tex;
 
-extern void WriteSystemInfo();
+void WriteSystemInfo();
 
-extern const wchar_t* ErrorString(int err);
+const wchar_t* ErrorString(int err);
 
-extern OsPath createDateIndexSubdirectory(const OsPath& parentDir);
+OsPath createDateIndexSubdirectory(const OsPath& parentDir);
 
-extern void WriteScreenshot(const VfsPath& extension);
-extern void WriteBigScreenshot(const VfsPath& extension, int tiles);
+void WriteScreenshot(const VfsPath& extension);
+void WriteBigScreenshot(const VfsPath& extension, int tiles);
 
-extern Status tex_write(Tex* t, const VfsPath& filename);
+Status tex_write(Tex* t, const VfsPath& filename);
+
+std::string Hexify(const std::string& s);
 
 #endif // PS_UTIL_H
Index: ps/trunk/source/simulation2/Simulation2.cpp
===================================================================
--- ps/trunk/source/simulation2/Simulation2.cpp	(revision 18590)
+++ ps/trunk/source/simulation2/Simulation2.cpp	(revision 18591)
@@ -1,925 +1,916 @@
 /* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "Simulation2.h"
 
 #include "scriptinterface/ScriptInterface.h"
 #include "scriptinterface/ScriptRuntime.h"
 
 #include "simulation2/MessageTypes.h"
 #include "simulation2/system/ComponentManager.h"
 #include "simulation2/system/ParamNode.h"
 #include "simulation2/system/SimContext.h"
 #include "simulation2/components/ICmpAIManager.h"
 #include "simulation2/components/ICmpCommandQueue.h"
 #include "simulation2/components/ICmpTemplateManager.h"
 
 #include "graphics/MapReader.h"
 #include "graphics/Terrain.h"
 #include "lib/timer.h"
 #include "lib/file/vfs/vfs_util.h"
 #include "maths/MathUtil.h"
 #include "ps/CLogger.h"
 #include "ps/ConfigDB.h"
 #include "ps/Filesystem.h"
 #include "ps/Loader.h"
 #include "ps/Profile.h"
 #include "ps/Pyrogenesis.h"
 #include "ps/Util.h"
 #include "ps/XML/Xeromyces.h"
 
 #include <iomanip>
 
-static std::string Hexify(const std::string& s) // TODO: shouldn't duplicate this function in so many places
-{
-	std::stringstream str;
-	str << std::hex;
-	for (size_t i = 0; i < s.size(); ++i)
-		str << std::setfill('0') << std::setw(2) << (int)(unsigned char)s[i];
-	return str.str();
-}
-
 class CSimulation2Impl
 {
 public:
 	CSimulation2Impl(CUnitManager* unitManager, shared_ptr<ScriptRuntime> rt, CTerrain* terrain) :
 		m_SimContext(), m_ComponentManager(m_SimContext, rt),
 		m_EnableOOSLog(false), m_EnableSerializationTest(false),
 		m_MapSettings(rt->m_rt), m_InitAttributes(rt->m_rt)
 	{
 		m_SimContext.m_UnitManager = unitManager;
 		m_SimContext.m_Terrain = terrain;
 		m_ComponentManager.LoadComponentTypes();
 
 		RegisterFileReloadFunc(ReloadChangedFileCB, this);
 
 		// Tests won't have config initialised
 		if (CConfigDB::IsInitialised())
 		{
 			CFG_GET_VAL("ooslog", m_EnableOOSLog);
 			CFG_GET_VAL("serializationtest", m_EnableSerializationTest);
 		}
 
 		if (m_EnableOOSLog)
 		{
 			m_OOSLogPath = createDateIndexSubdirectory(psLogDir() / "oos_logs");
 			debug_printf("Writing ooslogs to %s\n", m_OOSLogPath.string8().c_str());
 		}
 	}
 
 	~CSimulation2Impl()
 	{
 		UnregisterFileReloadFunc(ReloadChangedFileCB, this);
 	}
 
 	void ResetState(bool skipScriptedComponents, bool skipAI)
 	{
 		m_DeltaTime = 0.0;
 		m_LastFrameOffset = 0.0f;
 		m_TurnNumber = 0;
 		ResetComponentState(m_ComponentManager, skipScriptedComponents, skipAI);
 	}
 
 	static void ResetComponentState(CComponentManager& componentManager, bool skipScriptedComponents, bool skipAI)
 	{
 		componentManager.ResetState();
 		componentManager.InitSystemEntity();
 		componentManager.AddSystemComponents(skipScriptedComponents, skipAI);
 	}
 
 	static bool LoadDefaultScripts(CComponentManager& componentManager, std::set<VfsPath>* loadedScripts);
 	static bool LoadScripts(CComponentManager& componentManager, std::set<VfsPath>* loadedScripts, const VfsPath& path);
 	static bool LoadTriggerScripts(CComponentManager& componentManager, JS::HandleValue mapSettings, std::set<VfsPath>* loadedScripts);
 	Status ReloadChangedFile(const VfsPath& path);
 
 	static Status ReloadChangedFileCB(void* param, const VfsPath& path)
 	{
 		return static_cast<CSimulation2Impl*>(param)->ReloadChangedFile(path);
 	}
 
 	int ProgressiveLoad();
 	void Update(int turnLength, const std::vector<SimulationCommand>& commands);
 	static void UpdateComponents(CSimContext& simContext, fixed turnLengthFixed, const std::vector<SimulationCommand>& commands);
 	void Interpolate(float simFrameLength, float frameOffset, float realFrameLength);
 
 	void DumpState();
 
 	CSimContext m_SimContext;
 	CComponentManager m_ComponentManager;
 	double m_DeltaTime;
 	float m_LastFrameOffset;
 
 	std::string m_StartupScript;
 	JS::PersistentRootedValue m_InitAttributes;
 	JS::PersistentRootedValue m_MapSettings;
 
 	std::set<VfsPath> m_LoadedScripts;
 
 	uint32_t m_TurnNumber;
 
 	bool m_EnableOOSLog;
 	OsPath m_OOSLogPath;
 
 	// Functions and data for the serialization test mode: (see Update() for relevant comments)
 
 	bool m_EnableSerializationTest;
 
 	struct SerializationTestState
 	{
 		std::stringstream state;
 		std::stringstream debug;
 		std::string hash;
 	};
 
 	void DumpSerializationTestState(SerializationTestState& state, const OsPath& path, const OsPath::String& suffix);
 
 	void ReportSerializationFailure(
 		SerializationTestState* primaryStateBefore, SerializationTestState* primaryStateAfter,
 		SerializationTestState* secondaryStateBefore, SerializationTestState* secondaryStateAfter);
 
 	static std::vector<SimulationCommand> CloneCommandsFromOtherContext(ScriptInterface& oldScript, ScriptInterface& newScript,
 		const std::vector<SimulationCommand>& commands)
 	{
 		JSContext* cxOld = oldScript.GetContext();
 		JSAutoRequest rqOld(cxOld);
 
 		std::vector<SimulationCommand> newCommands;
 		newCommands.reserve(commands.size());
 		for (const SimulationCommand& command : commands)
 		{
 			JSContext* cxNew = newScript.GetContext();
 			JSAutoRequest rqNew(cxNew);
 			JS::RootedValue tmpCommand(cxNew, newScript.CloneValueFromOtherContext(oldScript, command.data));
 			newScript.FreezeObject(tmpCommand, true);
 			SimulationCommand cmd(command.player, cxNew, tmpCommand);
 			newCommands.emplace_back(std::move(cmd));
 		}
 		return newCommands;
 	}
 };
 
 bool CSimulation2Impl::LoadDefaultScripts(CComponentManager& componentManager, std::set<VfsPath>* loadedScripts)
 {
 	return (
 		LoadScripts(componentManager, loadedScripts, L"simulation/components/interfaces/") &&
 		LoadScripts(componentManager, loadedScripts, L"simulation/helpers/") &&
 		LoadScripts(componentManager, loadedScripts, L"simulation/components/")
 	);
 }
 
 bool CSimulation2Impl::LoadScripts(CComponentManager& componentManager, std::set<VfsPath>* loadedScripts, const VfsPath& path)
 {
 	VfsPaths pathnames;
 	if (vfs::GetPathnames(g_VFS, path, L"*.js", pathnames) < 0)
 		return false;
 
 	bool ok = true;
 	for (const VfsPath& path : pathnames)
 	{
 		if (loadedScripts)
 			loadedScripts->insert(path);
 		LOGMESSAGE("Loading simulation script '%s'", path.string8());
 		if (!componentManager.LoadScript(path))
 			ok = false;
 	}
 	return ok;
 }
 
 bool CSimulation2Impl::LoadTriggerScripts(CComponentManager& componentManager, JS::HandleValue mapSettings, std::set<VfsPath>* loadedScripts)
 {
 	bool ok = true;
 	if (componentManager.GetScriptInterface().HasProperty(mapSettings, "TriggerScripts"))
 	{
 		std::vector<std::string> scriptNames;
 		componentManager.GetScriptInterface().GetProperty(mapSettings, "TriggerScripts", scriptNames);
 		for (const std::string& triggerScript : scriptNames)
 		{
 			std::string scriptName = "maps/" + triggerScript;
 			if (loadedScripts)
 			{
 				if (loadedScripts->find(scriptName) != loadedScripts->end())
 					continue;
 				loadedScripts->insert(scriptName);
 			}
 			LOGMESSAGE("Loading trigger script '%s'", scriptName.c_str());
 			if (!componentManager.LoadScript(scriptName.data()))
 				ok = false;
 		}
 	}
 	return ok;
 }
 
 Status CSimulation2Impl::ReloadChangedFile(const VfsPath& path)
 {
 	// Ignore if this file wasn't loaded as a script
 	// (TODO: Maybe we ought to load in any new .js files that are created in the right directories)
 	if (m_LoadedScripts.find(path) == m_LoadedScripts.end())
 		return INFO::OK;
 
 	// If the file doesn't exist (e.g. it was deleted), don't bother loading it since that'll give an error message.
 	// (Also don't bother trying to 'unload' it from the component manager, because that's not possible)
 	if (!VfsFileExists(path))
 		return INFO::OK;
 
 	LOGMESSAGE("Reloading simulation script '%s'", path.string8());
 	if (!m_ComponentManager.LoadScript(path, true))
 		return ERR::FAIL;
 
 	return INFO::OK;
 }
 
 int CSimulation2Impl::ProgressiveLoad()
 {
 	// yield after this time is reached. balances increased progress bar
 	// smoothness vs. slowing down loading.
 	const double end_time = timer_Time() + 200e-3;
 
 	int ret;
 
 	do
 	{
 		bool progressed = false;
 		int total = 0;
 		int progress = 0;
 
 		CMessageProgressiveLoad msg(&progressed, &total, &progress);
 
 		m_ComponentManager.BroadcastMessage(msg);
 
 		if (!progressed || total == 0)
 			return 0; // we have nothing left to load
 
 		ret = Clamp(100*progress / total, 1, 100);
 	}
 	while (timer_Time() < end_time);
 
 	return ret;
 }
 
 void CSimulation2Impl::DumpSerializationTestState(SerializationTestState& state, const OsPath& path, const OsPath::String& suffix)
 {
 	if (!state.hash.empty())
 	{
 		std::ofstream file (OsString(path / (L"hash." + suffix)).c_str(), std::ofstream::out | std::ofstream::trunc);
 		file << Hexify(state.hash);
 	}
 
 	if (!state.debug.str().empty())
 	{
 		std::ofstream file (OsString(path / (L"debug." + suffix)).c_str(), std::ofstream::out | std::ofstream::trunc);
 		file << state.debug.str();
 	}
 
 	if (!state.state.str().empty())
 	{
 		std::ofstream file (OsString(path / (L"state." + suffix)).c_str(), std::ofstream::out | std::ofstream::trunc | std::ofstream::binary);
 		file << state.state.str();
 	}
 }
 
 void CSimulation2Impl::ReportSerializationFailure(
 	SerializationTestState* primaryStateBefore, SerializationTestState* primaryStateAfter,
 	SerializationTestState* secondaryStateBefore, SerializationTestState* secondaryStateAfter)
 {
 	const OsPath path = createDateIndexSubdirectory(psLogDir() / "serializationtest");
 	debug_printf("Writing serializationtest-data to %s\n", path.string8().c_str());
 
 	// Clean up obsolete files from previous runs
 	wunlink(path / "hash.before.a");
 	wunlink(path / "hash.before.b");
 	wunlink(path / "debug.before.a");
 	wunlink(path / "debug.before.b");
 	wunlink(path / "state.before.a");
 	wunlink(path / "state.before.b");
 	wunlink(path / "hash.after.a");
 	wunlink(path / "hash.after.b");
 	wunlink(path / "debug.after.a");
 	wunlink(path / "debug.after.b");
 	wunlink(path / "state.after.a");
 	wunlink(path / "state.after.b");
 
 	if (primaryStateBefore)
 		DumpSerializationTestState(*primaryStateBefore, path, L"before.a");
 	if (primaryStateAfter)
 		DumpSerializationTestState(*primaryStateAfter, path, L"after.a");
 	if (secondaryStateBefore)
 		DumpSerializationTestState(*secondaryStateBefore, path, L"before.b");
 	if (secondaryStateAfter)
 		DumpSerializationTestState(*secondaryStateAfter, path, L"after.b");
 
 	debug_warn(L"Serialization test failure");
 }
 
 void CSimulation2Impl::Update(int turnLength, const std::vector<SimulationCommand>& commands)
 {
 	PROFILE3("sim update");
 	PROFILE2_ATTR("turn %d", (int)m_TurnNumber);
 
 	fixed turnLengthFixed = fixed::FromInt(turnLength) / 1000;
 
 	/*
 	 * In serialization test mode, we save the original (primary) simulation state before each turn update.
 	 * We run the update, then load the saved state into a secondary context.
 	 * We serialize that again and compare to the original serialization (to check that
 	 * serialize->deserialize->serialize is equivalent to serialize).
 	 * Then we run the update on the secondary context, and check that its new serialized
 	 * state matches the primary context after the update (to check that the simulation doesn't depend
 	 * on anything that's not serialized).
 	 */
 
 	const bool serializationTestDebugDump = false; // set true to save human-readable state dumps before an error is detected, for debugging (but slow)
 	const bool serializationTestHash = true; // set true to save and compare hash of state
 
 	SerializationTestState primaryStateBefore;
 	ScriptInterface& scriptInterface = m_ComponentManager.GetScriptInterface();
 
 	if (m_EnableSerializationTest)
 	{
 		ENSURE(m_ComponentManager.SerializeState(primaryStateBefore.state));
 		if (serializationTestDebugDump)
 			ENSURE(m_ComponentManager.DumpDebugState(primaryStateBefore.debug, false));
 		if (serializationTestHash)
 			ENSURE(m_ComponentManager.ComputeStateHash(primaryStateBefore.hash, false));
 	}
 
 	UpdateComponents(m_SimContext, turnLengthFixed, commands);
 
 
 	if (m_EnableSerializationTest)
 	{
 		// Initialise the secondary simulation
 		CTerrain secondaryTerrain;
 		CSimContext secondaryContext;
 		secondaryContext.m_Terrain = &secondaryTerrain;
 		CComponentManager secondaryComponentManager(secondaryContext, scriptInterface.GetRuntime());
 		secondaryComponentManager.LoadComponentTypes();
 		std::set<VfsPath> secondaryLoadedScripts;
 		ENSURE(LoadDefaultScripts(secondaryComponentManager, &secondaryLoadedScripts));
 		ResetComponentState(secondaryComponentManager, false, false);
 
 		// Load the trigger scripts after we have loaded the simulation.
 		{
 			JSContext* cx2 = secondaryComponentManager.GetScriptInterface().GetContext();
 			JSAutoRequest rq2(cx2);
 			JS::RootedValue mapSettingsCloned(cx2,
 				secondaryComponentManager.GetScriptInterface().CloneValueFromOtherContext(
 					scriptInterface, m_MapSettings));
 			ENSURE(LoadTriggerScripts(secondaryComponentManager, mapSettingsCloned, &secondaryLoadedScripts));
 		}
 
 		// Load the map into the secondary simulation
 
 		LDR_BeginRegistering();
 		CMapReader* mapReader = new CMapReader; // automatically deletes itself
 
 		std::string mapType;
 		scriptInterface.GetProperty(m_InitAttributes, "mapType", mapType);
 		if (mapType == "random")
 		{
 			// TODO: support random map scripts
 			debug_warn(L"Serialization test mode does not support random maps");
 		}
 		else
 		{
 			std::wstring mapFile;
 			scriptInterface.GetProperty(m_InitAttributes, "map", mapFile);
 
 			VfsPath mapfilename = VfsPath(mapFile).ChangeExtension(L".pmp");
 			mapReader->LoadMap(mapfilename, scriptInterface.GetJSRuntime(), JS::UndefinedHandleValue,
 				&secondaryTerrain, NULL, NULL, NULL, NULL, NULL, NULL,
 				NULL, NULL, &secondaryContext, INVALID_PLAYER, true); // throws exception on failure
 		}
 
 		LDR_EndRegistering();
 		ENSURE(LDR_NonprogressiveLoad() == INFO::OK);
 
 		ENSURE(secondaryComponentManager.DeserializeState(primaryStateBefore.state));
 
 		SerializationTestState secondaryStateBefore;
 		ENSURE(secondaryComponentManager.SerializeState(secondaryStateBefore.state));
 		if (serializationTestDebugDump)
 			ENSURE(secondaryComponentManager.DumpDebugState(secondaryStateBefore.debug, false));
 		if (serializationTestHash)
 			ENSURE(secondaryComponentManager.ComputeStateHash(secondaryStateBefore.hash, false));
 
 		if (primaryStateBefore.state.str() != secondaryStateBefore.state.str() ||
 			primaryStateBefore.hash != secondaryStateBefore.hash)
 		{
 			ReportSerializationFailure(&primaryStateBefore, NULL, &secondaryStateBefore, NULL);
 		}
 
 		SerializationTestState primaryStateAfter;
 		ENSURE(m_ComponentManager.SerializeState(primaryStateAfter.state));
 		if (serializationTestHash)
 			ENSURE(m_ComponentManager.ComputeStateHash(primaryStateAfter.hash, false));
 
 		UpdateComponents(secondaryContext, turnLengthFixed,
 			CloneCommandsFromOtherContext(scriptInterface, secondaryComponentManager.GetScriptInterface(), commands));
 		SerializationTestState secondaryStateAfter;
 		ENSURE(secondaryComponentManager.SerializeState(secondaryStateAfter.state));
 		if (serializationTestHash)
 			ENSURE(secondaryComponentManager.ComputeStateHash(secondaryStateAfter.hash, false));
 
 		if (primaryStateAfter.state.str() != secondaryStateAfter.state.str() ||
 			primaryStateAfter.hash != secondaryStateAfter.hash)
 		{
 			// Only do the (slow) dumping now we know we're going to need to report it
 			ENSURE(m_ComponentManager.DumpDebugState(primaryStateAfter.debug, false));
 			ENSURE(secondaryComponentManager.DumpDebugState(secondaryStateAfter.debug, false));
 
 			ReportSerializationFailure(&primaryStateBefore, &primaryStateAfter, &secondaryStateBefore, &secondaryStateAfter);
 		}
 	}
 
 	// Run the GC occasionally
 	// No delay because a lot of garbage accumulates in one turn and in non-visual replays there are
 	// much more turns in the same time than in normal games.
 	// Every 500 turns we run a shrinking GC, which decommits unused memory and frees all JIT code.
 	// Based on testing, this seems to be a good compromise between memory usage and performance.
 	// Also check the comment about gcPreserveCode in the ScriptInterface code and this forum topic:
 	// http://www.wildfiregames.com/forum/index.php?showtopic=18466&p=300323
 	//
 	// (TODO: we ought to schedule this for a frame where we're not
 	// running the sim update, to spread the load)
 	if (m_TurnNumber % 500 == 0)
 		scriptInterface.GetRuntime()->ShrinkingGC();
 	else
 		scriptInterface.GetRuntime()->MaybeIncrementalGC(0.0f);
 
 	if (m_EnableOOSLog)
 		DumpState();
 
 	// Start computing AI for the next turn
 	CmpPtr<ICmpAIManager> cmpAIManager(m_SimContext, SYSTEM_ENTITY);
 	if (cmpAIManager)
 		cmpAIManager->StartComputation();
 
 	++m_TurnNumber;
 }
 
 void CSimulation2Impl::UpdateComponents(CSimContext& simContext, fixed turnLengthFixed, const std::vector<SimulationCommand>& commands)
 {
 	// TODO: the update process is pretty ugly, with lots of messages and dependencies
 	// between different components. Ought to work out a nicer way to do this.
 
 	CComponentManager& componentManager = simContext.GetComponentManager();
 
 	{
 		PROFILE2("Sim - Update Start");
 		CMessageTurnStart msgTurnStart;
 		componentManager.BroadcastMessage(msgTurnStart);
 	}
 
 	CmpPtr<ICmpPathfinder> cmpPathfinder(simContext, SYSTEM_ENTITY);
 	if (cmpPathfinder)
 	{
 		cmpPathfinder->UpdateGrid();
 		cmpPathfinder->FinishAsyncRequests();
 	}
 
 	// Push AI commands onto the queue before we use them
 	CmpPtr<ICmpAIManager> cmpAIManager(simContext, SYSTEM_ENTITY);
 	if (cmpAIManager)
 		cmpAIManager->PushCommands();
 
 	CmpPtr<ICmpCommandQueue> cmpCommandQueue(simContext, SYSTEM_ENTITY);
 	if (cmpCommandQueue)
 		cmpCommandQueue->FlushTurn(commands);
 
 	// Process newly generated move commands so the UI feels snappy
 	if (cmpPathfinder)
 		cmpPathfinder->ProcessSameTurnMoves();
 
 	// Send all the update phases
 	{
 		PROFILE2("Sim - Update");
 		CMessageUpdate msgUpdate(turnLengthFixed);
 		componentManager.BroadcastMessage(msgUpdate);
 	}
 	{
 		CMessageUpdate_MotionFormation msgUpdate(turnLengthFixed);
 		componentManager.BroadcastMessage(msgUpdate);
 	}
 
 	// Process move commands for formations (group proxy)
 	if (cmpPathfinder)
 		cmpPathfinder->ProcessSameTurnMoves();
 
 	{
 		PROFILE2("Sim - Motion Unit");
 		CMessageUpdate_MotionUnit msgUpdate(turnLengthFixed);
 		componentManager.BroadcastMessage(msgUpdate);
 	}
 	{
 		PROFILE2("Sim - Update Final");
 		CMessageUpdate_Final msgUpdate(turnLengthFixed);
 		componentManager.BroadcastMessage(msgUpdate);
 	}
 
 	// Process moves resulting from group proxy movement (unit needs to catch up or realign) and any others
 	if (cmpPathfinder)
 		cmpPathfinder->ProcessSameTurnMoves();
 
 	// Clean up any entities destroyed during the simulation update
 	componentManager.FlushDestroyedComponents();
 }
 
 void CSimulation2Impl::Interpolate(float simFrameLength, float frameOffset, float realFrameLength)
 {
 	PROFILE3("sim interpolate");
 
 	m_LastFrameOffset = frameOffset;
 
 	CMessageInterpolate msg(simFrameLength, frameOffset, realFrameLength);
 	m_ComponentManager.BroadcastMessage(msg);
 
 	// Clean up any entities destroyed during interpolate (e.g. local corpses)
 	m_ComponentManager.FlushDestroyedComponents();
 }
 
 void CSimulation2Impl::DumpState()
 {
 	PROFILE("DumpState");
 
 	std::stringstream name;\
 	name << std::setw(5) << std::setfill('0') << m_TurnNumber << ".txt";
 	const OsPath path = m_OOSLogPath / name.str();
 	std::ofstream file (OsString(path).c_str(), std::ofstream::out | std::ofstream::trunc);
 
 	if (!DirectoryExists(m_OOSLogPath))
 	{
 		LOGWARNING("OOS-log directory %s was deleted, creating it again.", m_OOSLogPath.string8().c_str());
 		CreateDirectories(m_OOSLogPath, 0700);
 	}
 
 	file << "State hash: " << std::hex;
 	std::string hashRaw;
 	m_ComponentManager.ComputeStateHash(hashRaw, false);
 	for (size_t i = 0; i < hashRaw.size(); ++i)
 		file << std::setfill('0') << std::setw(2) << (int)(unsigned char)hashRaw[i];
 	file << std::dec << "\n";
 
 	file << "\n";
 
 	m_ComponentManager.DumpDebugState(file, true);
 
 	std::ofstream binfile (OsString(path.ChangeExtension(L".dat")).c_str(), std::ofstream::out | std::ofstream::trunc | std::ofstream::binary);
 	m_ComponentManager.SerializeState(binfile);
 }
 
 ////////////////////////////////////////////////////////////////
 
 CSimulation2::CSimulation2(CUnitManager* unitManager, shared_ptr<ScriptRuntime> rt, CTerrain* terrain) :
 	m(new CSimulation2Impl(unitManager, rt, terrain))
 {
 }
 
 CSimulation2::~CSimulation2()
 {
 	delete m;
 }
 
 // Forward all method calls to the appropriate CSimulation2Impl/CComponentManager methods:
 
 void CSimulation2::EnableOOSLog()
 {
 	if (m->m_EnableOOSLog)
 		return;
 
 	m->m_EnableOOSLog = true;
 	m->m_OOSLogPath = createDateIndexSubdirectory(psLogDir() / "oos_logs");
 
 	debug_printf("Writing ooslogs to %s\n", m->m_OOSLogPath.string8().c_str());
 }
 
 void CSimulation2::EnableSerializationTest()
 {
 	m->m_EnableSerializationTest = true;
 }
 
 entity_id_t CSimulation2::AddEntity(const std::wstring& templateName)
 {
 	return m->m_ComponentManager.AddEntity(templateName, m->m_ComponentManager.AllocateNewEntity());
 }
 
 entity_id_t CSimulation2::AddEntity(const std::wstring& templateName, entity_id_t preferredId)
 {
 	return m->m_ComponentManager.AddEntity(templateName, m->m_ComponentManager.AllocateNewEntity(preferredId));
 }
 
 entity_id_t CSimulation2::AddLocalEntity(const std::wstring& templateName)
 {
 	return m->m_ComponentManager.AddEntity(templateName, m->m_ComponentManager.AllocateNewLocalEntity());
 }
 
 void CSimulation2::DestroyEntity(entity_id_t ent)
 {
 	m->m_ComponentManager.DestroyComponentsSoon(ent);
 }
 
 void CSimulation2::FlushDestroyedEntities()
 {
 	m->m_ComponentManager.FlushDestroyedComponents();
 }
 
 IComponent* CSimulation2::QueryInterface(entity_id_t ent, int iid) const
 {
 	return m->m_ComponentManager.QueryInterface(ent, iid);
 }
 
 void CSimulation2::PostMessage(entity_id_t ent, const CMessage& msg) const
 {
 	m->m_ComponentManager.PostMessage(ent, msg);
 }
 
 void CSimulation2::BroadcastMessage(const CMessage& msg) const
 {
 	m->m_ComponentManager.BroadcastMessage(msg);
 }
 
 CSimulation2::InterfaceList CSimulation2::GetEntitiesWithInterface(int iid)
 {
 	return m->m_ComponentManager.GetEntitiesWithInterface(iid);
 }
 
 const CSimulation2::InterfaceListUnordered& CSimulation2::GetEntitiesWithInterfaceUnordered(int iid)
 {
 	return m->m_ComponentManager.GetEntitiesWithInterfaceUnordered(iid);
 }
 
 const CSimContext& CSimulation2::GetSimContext() const
 {
 	return m->m_SimContext;
 }
 
 ScriptInterface& CSimulation2::GetScriptInterface() const
 {
 	return m->m_ComponentManager.GetScriptInterface();
 }
 
 void CSimulation2::PreInitGame()
 {
 	JSContext* cx = GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue global(cx, GetScriptInterface().GetGlobalObject());
 	GetScriptInterface().CallFunctionVoid(global, "PreInitGame");
 }
 
 void CSimulation2::InitGame(JS::HandleValue data)
 {
 	JSContext* cx = GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue global(cx, GetScriptInterface().GetGlobalObject());
 	GetScriptInterface().CallFunctionVoid(global, "InitGame", data);
 }
 
 void CSimulation2::Update(int turnLength)
 {
 	std::vector<SimulationCommand> commands;
 	m->Update(turnLength, commands);
 }
 
 void CSimulation2::Update(int turnLength, const std::vector<SimulationCommand>& commands)
 {
 	m->Update(turnLength, commands);
 }
 
 void CSimulation2::Interpolate(float simFrameLength, float frameOffset, float realFrameLength)
 {
 	m->Interpolate(simFrameLength, frameOffset, realFrameLength);
 }
 
 void CSimulation2::RenderSubmit(SceneCollector& collector, const CFrustum& frustum, bool culling)
 {
 	PROFILE3("sim submit");
 
 	CMessageRenderSubmit msg(collector, frustum, culling);
 	m->m_ComponentManager.BroadcastMessage(msg);
 }
 
 float CSimulation2::GetLastFrameOffset() const
 {
 	return m->m_LastFrameOffset;
 }
 
 bool CSimulation2::LoadScripts(const VfsPath& path)
 {
 	return m->LoadScripts(m->m_ComponentManager, &m->m_LoadedScripts, path);
 }
 
 bool CSimulation2::LoadDefaultScripts()
 {
 	return m->LoadDefaultScripts(m->m_ComponentManager, &m->m_LoadedScripts);
 }
 
 void CSimulation2::SetStartupScript(const std::string& code)
 {
 	m->m_StartupScript = code;
 }
 
 const std::string& CSimulation2::GetStartupScript()
 {
 	return m->m_StartupScript;
 }
 
 void CSimulation2::SetInitAttributes(JS::HandleValue attribs)
 {
 	m->m_InitAttributes = attribs;
 }
 
 JS::Value CSimulation2::GetInitAttributes()
 {
 	return m->m_InitAttributes.get();
 }
 
 void CSimulation2::GetInitAttributes(JS::MutableHandleValue ret)
 {
 	ret.set(m->m_InitAttributes);
 }
 
 void CSimulation2::SetMapSettings(const std::string& settings)
 {
 	m->m_ComponentManager.GetScriptInterface().ParseJSON(settings, &m->m_MapSettings);
 }
 
 void CSimulation2::SetMapSettings(JS::HandleValue settings)
 {
 	m->m_MapSettings = settings;
 }
 
 std::string CSimulation2::GetMapSettingsString()
 {
 	return m->m_ComponentManager.GetScriptInterface().StringifyJSON(&m->m_MapSettings);
 }
 
 void CSimulation2::GetMapSettings(JS::MutableHandleValue ret)
 {
 	ret.set(m->m_MapSettings);
 }
 
 void CSimulation2::LoadPlayerSettings(bool newPlayers)
 {
 	JSContext* cx = GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue global(cx, GetScriptInterface().GetGlobalObject());
 	GetScriptInterface().CallFunctionVoid(global, "LoadPlayerSettings", m->m_MapSettings, newPlayers);
 }
 
 void CSimulation2::LoadMapSettings()
 {
 	JSContext* cx = GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue global(cx, GetScriptInterface().GetGlobalObject());
 
 	// Initialize here instead of in Update()
 	GetScriptInterface().CallFunctionVoid(global, "LoadMapSettings", m->m_MapSettings);
 
 	if (!m->m_StartupScript.empty())
 		GetScriptInterface().LoadScript(L"map startup script", m->m_StartupScript);
 
 	// Load the trigger scripts after we have loaded the simulation and the map.
 	m->LoadTriggerScripts(m->m_ComponentManager, m->m_MapSettings, &m->m_LoadedScripts);
 }
 
 int CSimulation2::ProgressiveLoad()
 {
 	return m->ProgressiveLoad();
 }
 
 Status CSimulation2::ReloadChangedFile(const VfsPath& path)
 {
 	return m->ReloadChangedFile(path);
 }
 
 void CSimulation2::ResetState(bool skipScriptedComponents, bool skipAI)
 {
 	m->ResetState(skipScriptedComponents, skipAI);
 }
 
 bool CSimulation2::ComputeStateHash(std::string& outHash, bool quick)
 {
 	return m->m_ComponentManager.ComputeStateHash(outHash, quick);
 }
 
 bool CSimulation2::DumpDebugState(std::ostream& stream)
 {
 	return m->m_ComponentManager.DumpDebugState(stream, true);
 }
 
 bool CSimulation2::SerializeState(std::ostream& stream)
 {
 	return m->m_ComponentManager.SerializeState(stream);
 }
 
 bool CSimulation2::DeserializeState(std::istream& stream)
 {
 	// TODO: need to make sure the required SYSTEM_ENTITY components get constructed
 	return m->m_ComponentManager.DeserializeState(stream);
 }
 
 std::string CSimulation2::GenerateSchema()
 {
 	return m->m_ComponentManager.GenerateSchema();
 }
 
 static std::vector<std::string> GetJSONData(const VfsPath& path)
 {
 	VfsPaths pathnames;
 	Status ret = vfs::GetPathnames(g_VFS, path, L"*.json", pathnames);
 	if (ret != INFO::OK)
 	{
 		// Some error reading directory
 		wchar_t error[200];
 		LOGERROR("Error reading directory '%s': %s", path.string8(), utf8_from_wstring(StatusDescription(ret, error, ARRAY_SIZE(error))));
 		return std::vector<std::string>();
 	}
 
 	std::vector<std::string> data;
 	for (const VfsPath& p : pathnames)
 	{
 		// Load JSON file
 		CVFSFile file;
 		PSRETURN ret = file.Load(g_VFS, p);
 		if (ret != PSRETURN_OK)
 		{
 			LOGERROR("GetJSONData: Failed to load file '%s': %s", p.string8(), GetErrorString(ret));
 			continue;
 		}
 
 		data.push_back(file.DecodeUTF8()); // assume it's UTF-8
 	}
 
 	return data;
 }
 
 std::vector<std::string> CSimulation2::GetRMSData()
 {
 	return GetJSONData(L"maps/random/");
 }
 
 std::vector<std::string> CSimulation2::GetCivData()
 {
 	return GetJSONData(L"simulation/data/civs/");
 }
 
 static std::string ReadJSON(const VfsPath& path)
 {
 	if (!VfsFileExists(path))
 	{
 		LOGERROR("File '%s' does not exist", path.string8());
 		return std::string();
 	}
 
 	// Load JSON file
 	CVFSFile file;
 	PSRETURN ret = file.Load(g_VFS, path);
 	if (ret != PSRETURN_OK)
 	{
 		LOGERROR("Failed to load file '%s': %s", path.string8(), GetErrorString(ret));
 		return std::string();
 	}
 
 	return file.DecodeUTF8(); // assume it's UTF-8
 }
 
 std::string CSimulation2::GetPlayerDefaults()
 {
 	return ReadJSON(L"simulation/data/settings/player_defaults.json");
 }
 
 std::string CSimulation2::GetMapSizes()
 {
 	return ReadJSON(L"simulation/data/settings/map_sizes.json");
 }
 
 std::string CSimulation2::GetAIData()
 {
 	ScriptInterface& scriptInterface = GetScriptInterface();
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue aiData(cx, ICmpAIManager::GetAIs(scriptInterface));
 
 	// Build single JSON string with array of AI data
 	JS::RootedValue ais(cx);
 	if (!scriptInterface.Eval("({})", &ais) || !scriptInterface.SetProperty(ais, "AIData", aiData))
 		return std::string();
 
 	return scriptInterface.StringifyJSON(&ais);
 }