boost::statechart::result QuittingGame::react(const ShutdownServer& u) {
TraceLogger(FSM) << "(HumanClientFSM) QuittingGame.ShutdownServer";
if (!m_server_process) {
ErrorLogger(FSM) << "m_server_process is nullptr";
post_event(TerminateServer());
return discard_event();
}
if (m_server_process->Empty()) {
if (Client().Networking().IsTxConnected()) {
WarnLogger(FSM) << "Disconnecting from server that is already killed.";
Client().Networking().DisconnectFromServer();
}
post_event(TerminateServer());
return discard_event();
}
if (Client().Networking().IsTxConnected()) {
DebugLogger(FSM) << "Sending server shutdown message.";
Client().Networking().SendMessage(ShutdownServerMessage());
post_event(WaitForDisconnect());
} else {
post_event(TerminateServer());
}
return discard_event();
}
boost::statechart::result WaitingForTurnData::react(const CombatStart& msg) {
// HACK! I get some long and inscrutable error message if
// WaitingForTurnData doesn't have a CombatStart handler, even though
// WaitingForTurnDataImpl actually handles this message.
assert(!"Function WaitingForTurnData.CombatStart should never be called!");
return discard_event();
}
sc::result GettingFeedback::react(const EvMotionCompleted&)
{
// Since the build head is now in the physical home position,
// (even though we're not yet in the Home state), disengage the motors.
PRINTENGINE->DisableMotors();
return discard_event();
}
boost::statechart::result PlayingTurn::react(const SaveGameDataRequest& msg) {
TraceLogger(FSM) << "(HumanClientFSM) PlayingTurn.SaveGameDataRequest";
DebugLogger(FSM) << "Sending Save Game Data to Server";
Client().GetClientUI().GetMessageWnd()->HandleGameStatusUpdate(UserString("SERVER_SAVE_INITIATE_ACK") + "\n");
Client().HandleSaveGameDataRequest();
return discard_event();
}
boost::statechart::result MPLobby::react(const LobbyUpdate& msg) {
if (TRACE_EXECUTION) Logger().debugStream() << "(HumanClientFSM) MPLobby.LobbyUpdate";
MultiplayerLobbyData lobby_data;
ExtractMessageData(msg.m_message, lobby_data);
Client().m_ui->GetMultiPlayerLobbyWnd()->LobbyUpdate(lobby_data);
return discard_event();
}
boost::statechart::result WaitingForTurnData::react(const TurnUpdate& msg) {
TraceLogger(FSM) << "(HumanClientFSM) PlayingGame.TurnUpdate";
int current_turn = INVALID_GAME_TURN;
try {
ExtractTurnUpdateMessageData(msg.m_message, Client().EmpireID(), current_turn,
Empires(), GetUniverse(), GetSpeciesManager(),
GetCombatLogManager(), GetSupplyManager(), Client().Players());
} catch (...) {
Client().GetClientUI().GetMessageWnd()->HandleLogMessage(UserString("ERROR_PROCESSING_SERVER_MESSAGE") + "\n");
return discard_event();
}
DebugLogger(FSM) << "Extracted TurnUpdate message for turn: " << current_turn;
Client().SetCurrentTurn(current_turn);
// if I am the host, do autosave
if (Client().Networking().PlayerIsHost(Client().PlayerID()))
Client().Autosave();
Client().HandleTurnUpdate();
return transit<PlayingTurn>();
}
boost::statechart::result WaitingForTurnData::react(const SaveGameDataRequest& msg) {
if (TRACE_EXECUTION) DebugLogger() << "(HumanClientFSM) WaitingForTurnData.SaveGameDataRequest";
DebugLogger() << "Sending Save Game Data to Server";
Client().GetClientUI()->GetMessageWnd()->HandleGameStatusUpdate(UserString("SERVER_SAVE_INITIATE_ACK") + "\n");
Client().HandleSaveGameDataRequest();
return discard_event();
}
boost::statechart::result
insula::states::finished::react(
events::render const &r)
{
context<game_outer>().react(
r);
context<game_inner>().react(
r);
fcppt::string const s =
context<game_outer>().players_left()
?
FCPPT_TEXT("Press enter for next player")
:
FCPPT_TEXT("Press enter for the score board");
sge::font::draw_text(
context<game_outer>().large_font(),
context<game_outer>().font_drawer(),
FCPPT_TEXT("Great job!\n")+s,
sge::font::pos::null(),
fcppt::math::dim::structure_cast<sge::font::dim>(
context<machine>().systems().renderer()->screen_size()),
sge::font::align_h::center,
sge::font::align_v::center,
sge::font::flags::none);
return discard_event();
}
boost::statechart::result react( common::CTransactionAckEvent const & _transactionAckEvent )
{
if ( _transactionAckEvent.m_status == common::TransactionsStatus::Invalid )
{
context< CEnterNetworkAction >().setExit();
}
else
{
common::CAdmitProof admitProof;
admitProof.m_proofTransactionHash = _transactionAckEvent.m_transactionSend.GetHash();
context< CEnterNetworkAction >().addRequest(
new common::CSendMessageRequest(
common::CPayloadKind::AdmitProof
, admitProof
, context< CEnterNetworkAction >().getActionKey()
, new CByKeyMediumFilter( context< CEnterNetworkAction >().getPartnerKey() ) ) );
context< CEnterNetworkAction >().addRequest(
new common::CTimeEventRequest(
WaitTime
, new CMediumClassFilter( common::CMediumKinds::Time ) ) );
}
return discard_event();
}
boost::statechart::result react( common::CMessageResult const & _messageResult )
{
common::CMessage orginalMessage;
if ( !common::CommunicationProtocol::unwindMessage( _messageResult.m_message, orginalMessage, GetTime(), _messageResult.m_pubKey ) )
assert( !"service it somehow" );
common::CResult result;
common::convertPayload( orginalMessage, result );
assert( result.m_result );// for debug only, do something here
context< CEnterNetworkAction >().addRequest(
new common::CSendMessageRequest(
common::CPayloadKind::Ack
, common::CAck()
, context< CEnterNetworkAction >().getActionKey()
, _messageResult.m_message.m_header.m_id
, new CByKeyMediumFilter( _messageResult.m_pubKey ) ) );
if ( result.m_result )
return transit< CSynchronization >();
return discard_event();
}
boost::statechart::result react( common::CMessageResult const & _messageResult )
{
common::CMessage orginalMessage;
if ( !common::CommunicationProtocol::unwindMessage( _messageResult.m_message, orginalMessage, GetTime(), _messageResult.m_pubKey ) )
assert( !"service it somehow" );
if ( _messageResult.m_message.m_header.m_payloadKind == common::CPayloadKind::Result )
{
common::CResult result;
common::convertPayload( orginalMessage, result );
context< CEnterNetworkAction >().addRequest(
new common::CAckRequest(
context< CEnterNetworkAction >().getActionKey()
, _messageResult.m_message.m_header.m_id
, new CByKeyMediumFilter( _messageResult.m_pubKey ) ) );
if ( result.m_result )
{
monitorKey = _messageResult.m_pubKey;
return price ? transit< CNetworkAlive >() : transit< CSynchronization >();
}
else
{
assert(!"don't want cooperate");
}
}
return discard_event();
}
boost::statechart::result react( common::CTimeEvent const & _timeEvent )
{
CTransaction transaction;
if ( CChargeRegister::getInstance()->isTransactionPresent( m_proofHash ) )
{
context< CEnterNetworkAction >().addRequest(
new common::CSendMessageRequest(
common::CPayloadKind::Result
, common::CResult( 1 )
, context< CEnterNetworkAction >().getActionKey()
, m_messageId
, new CByKeyMediumFilter( m_pubKey ) ) );
common::CAllyMonitorData monitorData( context< CEnterNetworkAction >().getPartnerKey(), m_address );
CReputationTracker::getInstance()->addAllyMonitor( monitorData );
CReputationTracker::getInstance()->addNodeToSynch( context< CEnterNetworkAction >().getPartnerKey().GetID() );
}
else
{
context< CEnterNetworkAction >().forgetRequests();
context< CEnterNetworkAction >().addRequest(
new common::CTimeEventRequest(
m_checkPeriod
, new CMediumClassFilter( common::CMediumKinds::Time ) ) );
}
return discard_event();
}
boost::statechart::result MPLobby::react(const LobbyUpdate& msg) {
TraceLogger(FSM) << "(HumanClientFSM) MPLobby.LobbyUpdate";
MultiplayerLobbyData lobby_data;
ExtractLobbyUpdateMessageData(msg.m_message, lobby_data);
Client().GetClientUI().GetMultiPlayerLobbyWnd()->LobbyUpdate(lobby_data);
return discard_event();
}
boost::statechart::result WaitingForMPJoinAck::react(const CancelMPGameClicked& a) {
TraceLogger(FSM) << "(HumanClientFSM) WaitingForMPJoinAck.CancelMPGameClicked";
// See reaction_transition_note.
auto retval = discard_event();
Client().ResetToIntro(true);
return retval;
}
//--------------------FIRST RESPONDER------------------------------
sc::result Running::react( const EvCheckCellData & ){
post_event(EvCellStateChart_CellCycleUpdate());
post_event(EvCellStateChart_GLD1Update());
post_event(EvCellStateChart_LAG1Update());
post_event(EvCellStateChart_GLP1Update());
post_event(EvCellStateChart_LifeUpdate());
return discard_event();
};
sc::result react( const EvCheckCtorArgs & ev )
{
BOOST_REQUIRE( ev.expectedArgs_ == outermost_context().CtorArgs() );
outermost_context_type & machine = outermost_context();
machine.my_scheduler().queue_event(
machine.my_handle(), MakeEvent( new EvTerminate() ) );
return discard_event();
}
boost::statechart::result WaitingForTurnData::react(const TurnPartialUpdate& msg) {
if (TRACE_EXECUTION) Logger().debugStream() << "(HumanClientFSM) WaitingForTurnData.TurnPartialUpdate";
ExtractMessageData(msg.m_message, Client().EmpireID(), GetUniverse());
Client().m_ui->GetMapWnd()->MidTurnUpdate();
return discard_event();
}
boost::statechart::result QuittingGame::react(const StartQuittingGame& u) {
TraceLogger(FSM) << "(HumanClientFSM) QuittingGame";
m_server_process = &u.m_server;
m_after_server_shutdown_action = u.m_after_server_shutdown_action;
post_event(ShutdownServer());
return discard_event();
}
boost::statechart::result WaitingForTurnData::react(const TurnProgress& msg) {
if (TRACE_EXECUTION) Logger().debugStream() << "(HumanClientFSM) WaitingForTurnData.TurnProgress";
Message::TurnProgressPhase phase_id;
ExtractMessageData(msg.m_message, phase_id);
Client().m_ui->GetMessageWnd()->HandleTurnPhaseUpdate(phase_id);
return discard_event();
}
boost::statechart::result PlayingGame::react(const TurnProgress& msg) {
if (TRACE_EXECUTION) DebugLogger() << "(HumanClientFSM) PlayingGame.TurnProgress";
Message::TurnProgressPhase phase_id;
ExtractMessageData(msg.m_message, phase_id);
Client().GetClientUI()->GetMessageWnd()->HandleTurnPhaseUpdate(phase_id);
return discard_event();
}
boost::statechart::result PlayingGame::react(const Diplomacy& d) {
if (TRACE_EXECUTION) DebugLogger() << "(HumanClientFSM) PlayingGame.Diplomacy";
DiplomaticMessage diplo_message;
ExtractMessageData(d.m_message, diplo_message);
Empires().SetDiplomaticMessage(diplo_message);
return discard_event();
}
boost::statechart::result MPLobby::react(const CancelMPGameClicked& a)
{
TraceLogger(FSM) << "(HumanClientFSM) MPLobby.CancelMPGameClicked";
// See reaction_transition_note.
auto retval = discard_event();
Client().ResetToIntro();
return retval;
}
boost::statechart::result QuittingGame::react(const StartQuittingGame& u) {
TraceLogger(FSM) << "(HumanClientFSM) QuittingGame reset to intro is " << u.m_reset_to_intro;
m_reset_to_intro = u.m_reset_to_intro;
m_server_process = &u.m_server;
post_event(ShutdownServer());
return discard_event();
}
boost::statechart::result PlayingGame::react(const TurnPartialUpdate& msg) {
TraceLogger(FSM) << "(HumanClientFSM) PlayingGame.TurnPartialUpdate";
ExtractTurnPartialUpdateMessageData(msg.m_message, Client().EmpireID(), GetUniverse());
Client().GetClientUI().GetMapWnd()->MidTurnUpdate();
return discard_event();
}
boost::statechart::result PlayingGame::react(const TurnProgress& msg) {
TraceLogger(FSM) << "(HumanClientFSM) PlayingGame.TurnProgress";
Message::TurnProgressPhase phase_id;
ExtractTurnProgressMessageData(msg.m_message, phase_id);
Client().HandleTurnPhaseUpdate(phase_id);
return discard_event();
}
boost::statechart::result PlayingGame::react(const DiplomaticStatusUpdate& u) {
TraceLogger(FSM) << "(HumanClientFSM) PlayingGame.DiplomaticStatusUpdate";
DiplomaticStatusUpdateInfo diplo_update;
ExtractDiplomaticStatusMessageData(u.m_message, diplo_update);
Empires().SetDiplomaticStatus(diplo_update.empire1_id, diplo_update.empire2_id, diplo_update.diplo_status);
return discard_event();
}
boost::statechart::result PlayingGame::react(const Diplomacy& d) {
TraceLogger(FSM) << "(HumanClientFSM) PlayingGame.Diplomacy";
DiplomaticMessage diplo_message;
ExtractDiplomacyMessageData(d.m_message, diplo_message);
Empires().SetDiplomaticMessage(diplo_message);
return discard_event();
}
boost::statechart::result PlayingGame::react(const Disconnection& d) {
TraceLogger(FSM) << "(HumanClientFSM) PlayingGame.Disconnection";
// See reaction_transition_note.
auto retval = discard_event();
Client().ResetToIntro(true);
ClientUI::MessageBox(UserString("SERVER_LOST"), true);
return retval;
}
boost::statechart::result PlayingGame::react(const PlayerChat& msg) {
TraceLogger(FSM) << "(HumanClientFSM) PlayingGame.PlayerChat: " << msg.m_message.Text();
std::string text;
int sending_player_id;
ExtractPlayerChatMessageData(msg.m_message, sending_player_id, text);
Client().GetClientUI().GetMessageWnd()->HandlePlayerChatMessage(text, sending_player_id, Client().PlayerID());
return discard_event();
}
boost::statechart::result MPLobby::react(const StartMPGameClicked& a) {
TraceLogger(FSM) << "(HumanClientFSM) MPLobby.StartMPGameClicked";
if (Client().Networking().PlayerIsHost(Client().Networking().PlayerID()))
Client().Networking().SendMessage(StartMPGameMessage());
else
ErrorLogger(FSM) << "MPLobby::react received start MP game event but this client is not the host. Ignoring";
return discard_event(); // wait for server response GameStart message to leave this state...
}
