void HumanClientApp::HandleSaveGameDataRequest() {
if (INSTRUMENT_MESSAGE_HANDLING)
std::cerr << "HumanClientApp::HandleSaveGameDataRequest(" << Message::SAVE_GAME_DATA_REQUEST << ")\n";
SaveGameUIData ui_data;
m_ui->GetSaveGameUIData(ui_data);
m_networking.SendMessage(ClientSaveDataMessage(PlayerID(), Orders(), ui_data));
}
void ServerConnectDaemon::netPacketClientJoinRequest(const NetPacket* packet)
{
const ClientConnectJoinRequest* join_request_mesg
= (const ClientConnectJoinRequest *) packet->getNetMessage();
ClientConnectJoinRequestAck join_request_ack;
PlayerID new_player_id;
new_player_id = PlayerID(0, packet->fromID);
if(join_request_mesg->getProtocolVersion() == NETPANZER_PROTOCOL_VERSION) {
join_request_ack.setResultCode(_join_request_result_success);
} else {
join_request_ack.setResultCode(_join_request_result_invalid_protocol);
}
join_request_ack.setServerProtocolVersion(NETPANZER_PROTOCOL_VERSION);
if( join_request_ack.getResultCode() == _join_request_result_success ) {
ConnectQueueElement connect_request;
if ( !inConnectQueue( new_player_id) ) {
connect_request.new_player_id = new_player_id;
connect_request.connect_status = _connect_status_waiting;
if (connect_queue.size() > 25) {
join_request_ack.setResultCode(_join_request_result_server_busy);
} else {
connect_queue.push_back(connect_request);
}
}
}
SERVER->sendMessage(packet->fromID, &join_request_ack,
sizeof(ClientConnectJoinRequestAck));
}
void HumanClientApp::RequestSavePreviews(const std::string& directory, PreviewInformation& previews){
std::string generic_directory = fs::path(directory).generic_string();
if(!m_networking.Connected()){
DebugLogger() << "HumanClientApp::RequestSavePreviews: No game running. Start a server for savegame queries.";
StartServer();
DebugLogger() << "HumanClientApp::RequestSavePreviews Connecting to server";
unsigned int start_time = Ticks();
while (!m_networking.ConnectToLocalHostServer()) {
if (SERVER_CONNECT_TIMEOUT < Ticks() - start_time) {
ErrorLogger() << "HumanClientApp::LoadSinglePlayerGame() server connecting timed out";
ClientUI::MessageBox(UserString("ERR_CONNECT_TIMED_OUT"), true);
KillServer();
return;
}
}
m_connected = true;
}
DebugLogger() << "HumanClientApp::RequestSavePreviews Requesting previews for " << generic_directory;
Message response;
m_networking.SendSynchronousMessage(RequestSavePreviewsMessage(PlayerID(), generic_directory), response);
if (response.Type() == Message::DISPATCH_SAVE_PREVIEWS){
ExtractMessageData(response, previews);
DebugLogger() << "HumanClientApp::RequestSavePreviews Got " << previews.previews.size() << " previews.";
}else{
ErrorLogger() << "HumanClientApp::RequestSavePreviews: Wrong response type from server: " << EnumToString(response.Type());
}
}
bool HumanClientApp::CanSaveNow() const {
// only host can save in multiplayer
if (!SinglePlayerGame() && !Networking().PlayerIsHost(PlayerID()))
return false;
// can't save while AIs are playing their turns...
for (std::map<int, PlayerInfo>::const_iterator player_it = this->m_player_info.begin();
player_it != this->m_player_info.end(); ++player_it)
{
const PlayerInfo& info = player_it->second;
if (info.client_type != Networking::CLIENT_TYPE_AI_PLAYER)
continue; // only care about AIs
std::map<int, Message::PlayerStatus>::const_iterator
status_it = this->m_player_status.find(player_it->first);
if (status_it == this->m_player_status.end()) {
return false; // missing status for AI; can't assume it's ready
}
if (status_it->second != Message::WAITING) {
return false;
}
}
return true;
}
void
Connection::handleGreeting(DOPE_SMARTPTR<ClientGreeting> gPtr)
{
for (unsigned i=0;i<gPtr->m_userSetting.users.size();++i)
{
Team *t=server.getTeam(gPtr->m_userSetting.users[i].m_tname);
// todo: the problem is that we send back an array
// and the client doesn't know which players haven't been created
if (!t) continue;
// todo - find unused player before adding a new one
// check if team is full
if (t->playerIDs.size()>=t->textures.size())
continue;
// try to add player
DOPE_ASSERT(t->playerIDs.size()<t->dataURIs.size());
PlayerID id=server.addPlayer(gPtr->m_userSetting.users[i].m_uname,t->dataURIs[t->playerIDs.size()]);
if (id==PlayerID(~0U))
break;
playerIDs.push_back(id);
t->addPlayer(id);
}
ServerGreeting g;
g.m_players=playerIDs;
emit(g);
server.broadcastNewClient(this);
server.broadcastGame();
}
void PlayerInterface::initialize( unsigned short maxPlayers, unsigned char max_spawn_units )
{
char temp_str[64];
PlayerID player_id;
unsigned long player_index;
max_players = maxPlayers;
delete[] player_lists;
player_lists = new PlayerState[max_players];
for ( player_index = 0; player_index < max_players; player_index++ ) {
player_id.setIndex( player_index );
player_lists[player_index].setID( player_id );
player_lists[ player_index ].resetStats();
player_lists[ player_index ].setStatus( _player_state_free );
player_lists[ player_index ].setFlag( 0 );
player_lists[ player_index ].unit_config.initialize( max_spawn_units );
sprintf( temp_str, "Player %lu", player_index );
player_lists[ player_index ].setName( temp_str );
}
local_player_state.setID( PlayerID( 0xFFFF, 0xFFFFFFFF ) );
local_player_state.setStatus( _player_state_allocated );
delete[] alliance_matrix;
alliance_matrix = new bool [max_players * max_players];
resetAllianceMatrix();
}
void HumanClientApp::SaveGame(const std::string& filename) {
Message response_msg;
m_networking.SendSynchronousMessage(HostSaveGameMessage(PlayerID(), filename), response_msg);
if (response_msg.Type() != Message::SAVE_GAME) {
ErrorLogger() << "HumanClientApp::SaveGame sent synchronous HostSaveGameMessage, but received back message of wrong type: " << response_msg.Type();
throw std::runtime_error("HumanClientApp::SaveGame synchronous message received invalid response message type");
}
HandleSaveGameDataRequest();
}
void AIClientApp::HandlePythonAICrash() {
// Note: If python crashed during initialization then the AI has not
// been associated with a PlayerConnection so the server will not
// know the AI's PlayerName.
std::stringstream err_msg;
err_msg << "AIClientApp failed due to error in python AI code for " << PlayerName() << ". Exiting Soon.";
ErrorLogger() << err_msg.str() << " id = " << PlayerID();
Networking().SendMessage(
ErrorMessage(str(FlexibleFormat(UserString("ERROR_PYTHON_AI_CRASHED")) % PlayerName()) , true));
}
void NetworkServer::netMessageTransportClientAccept( NetMessage *message )
{
TransportClientAccept *client_accept_mesg;
ClientMesgConnectAck connect_ack_mesg;
PlayerID player_id;
client_accept_mesg = (TransportClientAccept *) message;
connect_ack_mesg.client_transport_id = client_accept_mesg->client_transport_id;
player_id = PlayerID( 0, connect_ack_mesg.client_transport_id );
sendMessage( player_id, &connect_ack_mesg, sizeof( ClientMesgConnectAck ), 0);
}
void ServerConnectDaemon::netMessageClientJoinRequest( NetMessage *message )
{
ClientConnectJoinRequest *join_request_mesg;
ClientConnectJoinRequestAck join_request_ack;
PlayerID new_player_id;
join_request_mesg = (ClientConnectJoinRequest *) message;
new_player_id = PlayerID(0, join_request_mesg->client_transport_id );
if( (strstr( join_request_mesg->code_word, _NETPANZER_CODEWORD) != 0) &&
(join_request_mesg->protocol_version == _NETPANZER_PROTOCOL_VERSION)
) {
join_request_ack.result_code = _join_request_result_success;
} else {
join_request_ack.result_code = _join_request_result_invalid_protocol;
}
join_request_ack.server_protocol_version = _NETPANZER_PROTOCOL_VERSION;
if( join_request_ack.result_code == _join_request_result_success ) {
ConnectQueueElement connect_request;
if ( !inConnectQueue( new_player_id) ) {
connect_request.new_player_id = new_player_id;
connect_request.connect_status = _connect_status_waiting;
if ( connect_queue.isFull() == true ) {
join_request_ack.result_code = _join_request_result_server_busy;
} else {
connect_queue.enqueue( connect_request );
}
}
}
SERVER->sendMessage( new_player_id, &join_request_ack,
sizeof(ClientConnectJoinRequestAck), 0);
}
void HumanClientApp::SaveGame(const std::string& filename) {
Message response_msg;
m_networking.SendMessage(HostSaveGameInitiateMessage(PlayerID(), filename));
DebugLogger() << "HumanClientApp::SaveGame sent save initiate message to server...";
}
void UDPClient::SendLoginFail()
{
LogMessage("login failed, go back to the login screen\n");
long player_id = PlayerID();
WaitForResponse(UDP_MASTER_SERVER_PORT, ENB_OPCODE_3006_PLAYER_LOGIN_FAILED, (unsigned char*)&player_id, sizeof(long));
g_ServerMgr->m_UDPClient->SendResponse(m_PlayerID, MVAS_LOGIN_PORT, ENB_OPCODE_1008_MVAS_LOGOFF_C_S, (unsigned char *) &m_PlayerID, sizeof(m_PlayerID));
//kill the TCP login connection
KillTCPConnection();
//now kill both links to the client
if (g_ServerMgr->m_SectorConnection)
{
g_ServerMgr->m_SectorConnection->TerminateConnection();
g_ServerMgr->m_ConnectionCount--;
g_ServerMgr->m_SectorConnection = 0;
}
//this should take us back to the login screen
//stimulate a re-login
//g_ServerMgr->m_SectorConnection->SendResponse(ENB_OPCODE_003A_SERVER_HANDOFF, (unsigned char *) &g_ServerMgr->m_UDPConnection->m_Server_handoff, sizeof(ServerHandoff));
//g_ServerMgr->m_MasterConnection->HandleMasterJoin();
//LogMessage("Forced client re-login\n");
//WaitForResponse(UDP_MASTER_SERVER_PORT, ENB_OPCODE_3006_PLAYER_LOGIN_FAILED, (unsigned char*)&player_id, sizeof(long));
/*if (!m_global_account_rcv)
{
LogMessage("Shutdown due to connection loss error.\n");
::MessageBox(NULL, "Sector login failure. Please re-start E&B via launcher", "Net7Proxy", MB_ICONERROR);
m_ServerTCP->SendResponseDirect(ENB_OPCODE_3004_PLAYER_SHIP_SENT, (unsigned char *) &player_id, sizeof(player_id));
SendResponse(m_PlayerID, MVAS_LOGIN_PORT, ENB_OPCODE_1008_MVAS_LOGOFF_C_S, (unsigned char *) &m_PlayerID, sizeof(m_PlayerID));
KillTCPConnection();
ShutdownClient();
//shutdown net7proxy
g_ServerShutdown = true;
}
else
{
LogMessage("Sector Re-login requested, server should initiate new login\n");
}*/
/*if (g_ServerMgr->m_SectorConnection && m_ServerTCP)
{
long player_id = PlayerID();
//display terminal connection loss error
LogMessage("Shutdown due to connection loss error.\n");
::MessageBox(NULL, "Sector login failure. Please re-start E&B via launcher", "Net7Proxy", MB_ICONERROR);
m_ServerTCP->SendResponseDirect(ENB_OPCODE_3004_PLAYER_SHIP_SENT, (unsigned char *) &player_id, sizeof(player_id));
SendResponse(m_PlayerID, MVAS_LOGIN_PORT, ENB_OPCODE_1008_MVAS_LOGOFF_C_S, (unsigned char *) &m_PlayerID, sizeof(m_PlayerID));
KillTCPConnection();
ShutdownClient();
//shutdown net7proxy
g_ServerShutdown = true;
}*/
//m_ServerTCP->SendResponse(ENB_OPCODE_3006_PLAYER_LOGIN_FAILED, (unsigned char*)&player_id, 4);
//WaitForResponse(m_ClientPort, ENB_OPCODE_3006_PLAYER_LOGIN_FAILED, (unsigned char*)&player_id, sizeof(long));
}
void SendPlayerChatMessage(int recipient_player_id, const std::string& message_text) {
if (recipient_player_id == -1)
AIClientApp::GetApp()->Networking().SendMessage(GlobalChatMessage(PlayerID(), message_text));
else
AIClientApp::GetApp()->Networking().SendMessage(SingleRecipientChatMessage(PlayerID(), recipient_player_id, message_text));
}
void AIClientApp::HandleMessage(const Message& msg) {
//DebugLogger() << "AIClientApp::HandleMessage " << msg.Type();
switch (msg.Type()) {
case Message::ERROR_MSG: {
ErrorLogger() << "AIClientApp::HandleMessage : Received ERROR message from server: " << msg.Text();
break;
}
case Message::HOST_ID: {
const std::string& text = msg.Text();
int host_id = Networking::INVALID_PLAYER_ID;
if (text.empty()) {
ErrorLogger() << "AIClientApp::HandleMessage for HOST_ID : Got empty message text?!";
} else {
try {
host_id = boost::lexical_cast<int>(text);
} catch(const boost::bad_lexical_cast& ex) {
ErrorLogger() << "AIClientApp::HandleMessage for HOST_ID : Couldn't parse message text \"" << text << "\": " << ex.what();
}
}
m_networking->SetHostPlayerID(host_id);
break;
}
case Message::JOIN_GAME: {
if (PlayerID() == Networking::INVALID_PLAYER_ID) {
DebugLogger() << "AIClientApp::HandleMessage : Received JOIN_GAME acknowledgement";
try {
int player_id;
boost::uuids::uuid cookie; // ignore
ExtractJoinAckMessageData(msg, player_id, cookie);
m_networking->SetPlayerID(player_id);
} catch(const boost::bad_lexical_cast& ex) {
ErrorLogger() << "AIClientApp::HandleMessage for JOIN_GAME : Couldn't parse message text \"" << msg.Text() << "\": " << ex.what();
}
} else {
ErrorLogger() << "AIClientApp::HandleMessage : Received erroneous JOIN_GAME acknowledgement when already in a game";
}
break;
}
case Message::GAME_START: {
DebugLogger() << "AIClientApp::HandleMessage : Received GAME_START message; starting AI turn...";
bool single_player_game; // ignored
bool loaded_game_data;
bool ui_data_available; // ignored
SaveGameUIData ui_data; // ignored
bool state_string_available; // ignored, as save_state_string is sent even if not set by ExtractMessageData
std::string save_state_string;
m_empire_status.clear();
ExtractGameStartMessageData(msg, single_player_game, m_empire_id,
m_current_turn, m_empires, m_universe,
GetSpeciesManager(), GetCombatLogManager(), GetSupplyManager(),
m_player_info, m_orders, loaded_game_data,
ui_data_available, ui_data, state_string_available,
save_state_string, m_galaxy_setup_data);
DebugLogger() << "Extracted GameStart message for turn: " << m_current_turn << " with empire: " << m_empire_id;
GetUniverse().InitializeSystemGraph(m_empire_id);
DebugLogger() << "Message::GAME_START loaded_game_data: " << loaded_game_data;
if (loaded_game_data) {
TraceLogger() << "Message::GAME_START save_state_string: " << save_state_string;
m_AI->ResumeLoadedGame(save_state_string);
Orders().ApplyOrders();
} else {
DebugLogger() << "Message::GAME_START Starting New Game!";
// % Distribution of aggression levels
// Aggression : 0 1 2 3 4 5 (0=Beginner, 5=Maniacal)
// __ __ __ __ __ __
//Max 0 :100 0 0 0 0 0
//Max 1 : 25 75 0 0 0 0
//Max 2 : 0 25 75 0 0 0
//Max 3 : 0 0 25 75 0 0
//Max 4 : 0 0 0 25 75 0
//Max 5 : 0 0 0 0 25 75
// Optional aggression table, possibly for 0.4.4+?
// Aggression : 0 1 2 3 4 5 (0=Beginner, 5=Maniacal)
// __ __ __ __ __ __
//Max 0 :100 0 0 0 0 0
//Max 1 : 25 75 0 0 0 0
//Max 2 : 8 17 75 0 0 0
//Max 3 : 0 8 17 75 0 0
//Max 4 : 0 0 8 17 75 0
//Max 5 : 0 0 0 8 17 75
const std::string g_seed = GetGalaxySetupData().m_seed;
const std::string emp_name = GetEmpire(m_empire_id)->Name();
unsigned int my_seed = 0;
try {
// generate consistent my_seed values from galaxy seed & empire name.
boost::hash<std::string> string_hash;
std::size_t h = string_hash(g_seed);
my_seed = 3 * static_cast<unsigned int>(h) * static_cast<unsigned int>(string_hash(emp_name));
DebugLogger() << "Message::GAME_START getting " << emp_name << " AI aggression, RNG Seed: " << my_seed;
} catch (...) {
DebugLogger() << "Message::GAME_START getting " << emp_name << " AI aggression, could not initialise RNG.";
}
int rand_num = 0;
int this_aggr = m_max_aggression;
if (this_aggr > 0 && my_seed > 0) {
Seed(my_seed);
rand_num = RandSmallInt(0, 99);
// if it's in the top 25% then decrease aggression.
if (rand_num > 74) this_aggr--;
// Leaving the following as commented out code for now. Possibly for 0.4.4+?
// in the top 8% ? decrease aggression again, unless it's already as low as it gets.
// if (rand_num > 91 && this_aggr > 0) this_aggr--;
}
DebugLogger() << "Message::GAME_START setting AI aggression as " << this_aggr << " (from rnd " << rand_num << "; max aggression " << m_max_aggression << ")";
m_AI->SetAggression(this_aggr);
m_AI->StartNewGame();
}
m_AI->GenerateOrders();
break;
}
case Message::SAVE_GAME_COMPLETE:
break;
case Message::TURN_UPDATE: {
//DebugLogger() << "AIClientApp::HandleMessage : extracting turn update message data";
ExtractTurnUpdateMessageData(msg, m_empire_id, m_current_turn,
m_empires, m_universe, GetSpeciesManager(),
GetCombatLogManager(), GetSupplyManager(), m_player_info);
//DebugLogger() << "AIClientApp::HandleMessage : generating orders";
GetUniverse().InitializeSystemGraph(m_empire_id);
m_AI->GenerateOrders();
//DebugLogger() << "AIClientApp::HandleMessage : done handling turn update message";
break;
}
case Message::TURN_PARTIAL_UPDATE:
ExtractTurnPartialUpdateMessageData(msg, m_empire_id, m_universe);
break;
case Message::TURN_PROGRESS: {
Message::TurnProgressPhase phase_id;
ExtractTurnProgressMessageData(msg, phase_id);
ClientApp::HandleTurnPhaseUpdate(phase_id);
break;
}
case Message::PLAYER_STATUS:
break;
case Message::END_GAME: {
DebugLogger() << "Message::END_GAME : Exiting";
DebugLogger() << "Acknowledge server shutdown message.";
Networking().SendMessage(AIEndGameAcknowledgeMessage());
ExitApp(0);
break;
}
case Message::PLAYER_CHAT: {
std::string data;
int player_id;
boost::posix_time::ptime timestamp;
ExtractServerPlayerChatMessageData(msg, player_id, timestamp, data);
m_AI->HandleChatMessage(player_id, data);
break;
}
case Message::DIPLOMACY: {
DiplomaticMessage diplo_message;
ExtractDiplomacyMessageData(msg, diplo_message);
m_AI->HandleDiplomaticMessage(diplo_message);
break;
}
case Message::DIPLOMATIC_STATUS: {
DiplomaticStatusUpdateInfo diplo_update;
ExtractDiplomaticStatusMessageData(msg, diplo_update);
m_AI->HandleDiplomaticStatusUpdate(diplo_update);
break;
}
case Message::LOGGER_CONFIG: {
std::set<std::tuple<std::string, std::string, LogLevel>> options;
ExtractLoggerConfigMessageData(msg, options);
SetLoggerThresholds(options);
break;
}
case Message::CHECKSUM: {
TraceLogger() << "(AIClientApp) CheckSum.";
VerifyCheckSum(msg);
break;
}
default: {
ErrorLogger() << "AIClientApp::HandleMessage : Received unknown Message type code " << msg.Type();
break;
}
}
//DebugLogger() << "AIClientApp::HandleMessage done";
}
