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 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 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();
	}

//--------------------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 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 MPLobby::react(const CancelMPGameClicked& a)
{
    TraceLogger(FSM) << "(HumanClientFSM) MPLobby.CancelMPGameClicked";

    // See reaction_transition_note.
    auto retval = discard_event();
    Client().ResetToIntro();
    return retval;
}