#include "StdAfx.h"
#include "SignalControl_NetClient.h"
#include "SignalControl_Network.h"
#include "IOCPNetwork/NetClient.h"
#include "SignalControlProcessor.h"

using namespace CHSignalControls_Network;

CSignalControl_NetClient::CSignalControl_NetClient(int nIndex, ISignalControl_NetClient2Parent* pISCNC2P) : m_nIndex(nIndex), m_pISCNC2P(pISCNC2P)
{
	m_pMessageProcessor = new CMessageProcessor(static_cast<IMessageProcessor2Parent*>(this));
	m_pNetClient = new CNetClient();
}

CSignalControl_NetClient::~CSignalControl_NetClient(void)
{
	if (m_pNetClient)
	{
		delete m_pNetClient;
		m_pNetClient = NULL;
	}

	if (m_pMessageProcessor)
	{
		delete m_pMessageProcessor;
		m_pMessageProcessor = NULL;
	}
}

int CSignalControl_NetClient::Connect( const CString& strIPAddress )
{
	return InitNetwork(strIPAddress);
}

BOOL CSignalControl_NetClient::InitNetwork( const CString& strIPAddress )
{
	if (m_pNetClient==NULL) return 0;

	m_pNetClient->SetIN2P(static_cast<IIOCPNetwork2Parent*>(this));
	m_pNetClient->StartUp();
	m_pNetClient->InitNetwork(ClientMode, 4, NETPORT_NETWORK_SIGNAL, strIPAddress);
	m_pNetClient->SetServerInfo(Socket_SignalServer, NETCODE_NETWORK_SIGNAL, NETVER_NETWORK_SIGNAL,1004);

	BOOL bResult = m_pNetClient->Connect(TRUE);

	if (m_pISCNC2P)
	{
		if (bResult)
		{
			m_pISCNC2P->ISCNC2P_DisplayMessage(_T("[SignalControl_NetClient] [%d]Client Init Connect Cmd Success!"), m_nIndex);
		}
		else
		{
			m_pISCNC2P->ISCNC2P_DisplayMessage(_T("[SignalControl_NetClient] [%d]Client Init Connect Cmd Fail!"), m_nIndex);
		}
	}

	return bResult;
}

void CSignalControl_NetClient::DeinitNetwork()
{
	if (m_pNetClient==NULL) return;

	m_pNetClient->DeinitNetwork();
	m_pNetClient->CleanUp();
}

int CSignalControl_NetClient::Disconnect()
{
	DeinitNetwork();

	return 0;
}

void CHSignalControls_Network::CSignalControl_NetClient::IOCPNet2P_Connected( int Type )
{
	BOOL bSend = FALSE;
	if (m_pNetClient)
	{
		bSend = m_pNetClient->SendToServer(SC2SS_MODULE_INDEX, NET_RESULT_SUCCESS, m_nIndex);
	}

	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_DisplayMessage(_T("[SignalControl_NetClient] [%d]Client is Connected!"), m_nIndex);

		if (bSend)
		{
			m_pISCNC2P->ISCNC2P_DisplayMessage(_T("[SignalControl_NetClient] [%d]Client [MODULE_INDEX] Message Send Success!"), m_nIndex);
			m_pISCNC2P->ISCNC2P_Connected(m_nIndex,TRUE);
		}
		else
		{
			m_pISCNC2P->ISCNC2P_DisplayMessage(_T("[SignalControl_NetClient] [%d]Client [MODULE_INDEX] Message Send Fail!"), m_nIndex);
			m_pISCNC2P->ISCNC2P_Connected(m_nIndex,FALSE);
		}
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::IOCPNet2P_Disconnected( int Type, int nModuleNo /*= -1*/ )
{
	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_DisplayMessage(_T("[SignalControl_NetClient] [%d]Client is Disconnected!"), m_nIndex);
		m_pISCNC2P->ISCNC2P_Connected(m_nIndex,FALSE);
	}
}

BOOL CHSignalControls_Network::CSignalControl_NetClient::IOCPNet2P_Received(int Type, CNetPacket* pPacket, int nContext /*= -1*/)
{
	if (m_pMessageProcessor==NULL) return FALSE;

	if (pPacket==NULL)  return FALSE;		

	switch(Type)	
	{
	case Socket_SignalServer:
		{
			CNetPacket* pCopyPacket = new CNetPacket(pPacket); // copy
			m_pMessageProcessor->AddMessageProcessData(pPacket->GetPacketCode(),(WPARAM)pCopyPacket,(LPARAM)nContext);					
		}
		break;
	}

	return TRUE;
}

void CSignalControl_NetClient::IMP2P_ProcessMessageData( CMessageProcessData* pData )
{
	if (pData==NULL) return;

	CNetPacket *pPacket = (CNetPacket*)pData->m_wParam;
	int nContext = (int)pData->m_lParam;

	CString strLog = _T("");

	switch(pData->m_unMsg)
	{
	case SS2SC_ACK_MODULE_INDEX: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [ACK_MODULE_INDEX] Message Received!"), pPacket->GetModuleNo());
		Process_AckModuleIndex(pPacket->GetModuleNo(), nContext);
		break;

	case SS2SC_ACK_COMMAND_LIGHT: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [ACK_COMMAND_LIGHT] Message Received!"), pPacket->GetModuleNo());
		Process_AckCommandLight(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_ACK_COMMAND_LENS: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [ACK_COMMAND_LENS] Message Received!"), pPacket->GetModuleNo());
		Process_AckCommandLens(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_ACK_COMMAND_MOTOR_GO: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [ACK_COMMAND_MOTOR_GO] Message Received!"), pPacket->GetModuleNo());
		Process_AckCommandMotorGo(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_ACK_COMMAND_GLASS_GO: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [ACK_COMMAND_GLASS_GO] Message Received!"), pPacket->GetModuleNo());
		Process_AckCommandGlassGo(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_ACK_COMMAND_JOG: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [ACK_COMMAND_JOG] Message Received!"), pPacket->GetModuleNo());
		Process_AckCommandJog(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_ACK_COMMAND_JOG_SPEED: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [ACK_COMMAND_JOG_SPEED] Message Received!"), pPacket->GetModuleNo());
		Process_AckCommandJogSpeed(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_ACK_COMMAND_AFM: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [ACK_COMMAND_AFM] Message Received!"), pPacket->GetModuleNo());
		Process_AckCommandAfm(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_ACK_COMMAND_AFM_JOG: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [ACK_COMMAND_AFM_JOG] Message Received!"), pPacket->GetModuleNo());
		Process_AckCommandAfmJog(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_ACK_COMMAND_AFM_JOG_SPEED: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [ACK_COMMAND_AFM_JOG_SPEED] Message Received!"), pPacket->GetModuleNo());
		Process_AckCommandAfmJogSpeed(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_ACK_COMMAND_AFM_HOME: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [ACK_COMMAND_AFM_HOME] Message Received!"), pPacket->GetModuleNo());
		Process_AckCommandAfmHome(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_STATUS_LIGHT: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [STATUS_LIGHT] Message Received!"), pPacket->GetModuleNo());
		Process_StatusLight(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_STATUS_LENS: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [STATUS_LENS] Message Received!"), pPacket->GetModuleNo());
		Process_StatusLens(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_STATUS_MODULE_POS: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [STATUS_MODULE_POS] Message Received!"), pPacket->GetModuleNo());
		Process_StatusModulePos(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_STATUS_JOG_SPEED: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [STATUS_JOG_SPEED] Message Received!"), pPacket->GetModuleNo());
		Process_StatusJogSpeed(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_STATUS_AFM: 
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [STATUS_AFM] Message Received!"), pPacket->GetModuleNo());
		Process_StatusAfm(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_COMMAND_LOADING:
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [COMMAND_LOADING] Message Received!"), pPacket->GetModuleNo());
		Process_CommandLoading(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_COMMAND_REVIEWRESULT:
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [COMMAND_REVIEW_RESULT] Message Received!"), pPacket->GetModuleNo());
		Process_CommandReviewResult(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_COMMAND_PLANSTART:
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [COMMAND_PLAN_START] Message Received!"), pPacket->GetModuleNo());
		Process_CommandPlanStart(pPacket->GetModuleNo(), pPacket);
		break;

	case SS2SC_COMMAND_PLANEND:
		strLog.Format(_T("[SignalControl_NetClient] [%d]Client [COMMAND_PLAN_END] Message Received!"), pPacket->GetModuleNo());
		Process_CommandPlanEnd(pPacket->GetModuleNo(), pPacket);
		break;
	}

	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_DisplayMessage(strLog);
	}

	delete pPacket;
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_AckModuleIndex( int nModuleIndex, int nContext )
{

}

void CHSignalControls_Network::CSignalControl_NetClient::Process_AckCommandLight( int nModuleIndex, CNetPacket* pPacket )
{
	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_AckCommandLight(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_AckCommandLens( int nModuleIndex, CNetPacket* pPacket )
{
	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_AckCommandLens(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_AckCommandMotorGo( int nModuleIndex, CNetPacket* pPacket )
{
	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_AckCommandMotorGo(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_AckCommandGlassGo( int nModuleIndex, CNetPacket* pPacket )
{
	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_AckCommandGlassGo(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_AckCommandJog( int nModuleIndex, CNetPacket* pPacket )
{
	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_AckCommandJog(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_AckCommandJogSpeed( int nModuleIndex, CNetPacket* pPacket )
{
	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_AckCommandJogSpeed(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_AckCommandAfm( int nModuleIndex, CNetPacket* pPacket )
{
	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_AckCommandAfm(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_AckCommandAfmJog( int nModuleIndex, CNetPacket* pPacket )
{
	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_AckCommandAfmJog(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_AckCommandAfmJogSpeed( int nModuleIndex, CNetPacket* pPacket )
{
	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_AckCommandAfmJogSpeed(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_AckCommandAfmHome( int nModuleIndex, CNetPacket* pPacket )
{
	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_AckCommandAfmHome(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_StatusLight( int nModuleIndex, CNetPacket* pPacket )
{
	if (m_pNetClient==NULL) return;

	m_pNetClient->SendToServer(SC2SS_ACK_STATUS_LIGHT, NET_RESULT_SUCCESS, m_nIndex);

	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_StatusLight(nModuleIndex, pPacket->GetInt(0));
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_StatusLens( int nModuleIndex, CNetPacket* pPacket )
{
	if (m_pNetClient==NULL) return;

	m_pNetClient->SendToServer(SC2SS_ACK_STATUS_LENS, NET_RESULT_SUCCESS, m_nIndex);

	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_StatusLens(nModuleIndex, pPacket->GetInt(0));
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_StatusModulePos( int nModuleIndex, CNetPacket* pPacket )
{
	if (m_pNetClient==NULL) return;

	m_pNetClient->SendToServer(SC2SS_ACK_STATUS_MODULE_POS, NET_RESULT_SUCCESS, m_nIndex);

	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_StatusModulePos(nModuleIndex, pPacket->GetInt(0), pPacket->GetInt(1), pPacket->GetInt(2), pPacket->GetInt(3));
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_StatusJogSpeed( int nModuleIndex, CNetPacket* pPacket )
{
	if (m_pNetClient==NULL) return;

	m_pNetClient->SendToServer(SC2SS_ACK_STATUS_JOG_SPEED, NET_RESULT_SUCCESS, m_nIndex);

	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_StatusJogSpeed(nModuleIndex, pPacket->GetDouble(0));
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_StatusAfm( int nModuleIndex, CNetPacket* pPacket )
{
	if (m_pNetClient==NULL) return;

	m_pNetClient->SendToServer(SC2SS_ACK_STATUS_AFM, NET_RESULT_SUCCESS, m_nIndex);

	if (m_pISCNC2P)
	{
		m_pISCNC2P->ISCNC2P_StatusAfm(nModuleIndex, pPacket->GetInt(0));
	}
}

int CHSignalControls_Network::CSignalControl_NetClient::Send_CommandLight( int nLight )
{
	if (m_pNetClient==NULL) return 0;

	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return 0;

	pPacket->SetInt(nLight);

	return m_pNetClient->SendToServer(SC2SS_COMMAND_LIGHT, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetClient::Send_CommandLens( int nLens )
{
	if (m_pNetClient==NULL) return 0;

	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return 0;

	pPacket->SetInt(nLens);

	return m_pNetClient->SendToServer(SC2SS_COMMAND_LENS, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetClient::Send_CommandMotorGo( int nPosUmX, int nPosUmY )
{
	if (m_pNetClient==NULL) return 0;

	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return 0;

	pPacket->SetInt(nPosUmX);
	pPacket->SetInt(nPosUmY);

	return m_pNetClient->SendToServer(SC2SS_COMMAND_MOTOR_GO, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetClient::Send_CommandGlassGo( int nPosUmX, int nPosUmY )
{
	if (m_pNetClient==NULL) return 0;

	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return 0;

	pPacket->SetInt(nPosUmX);
	pPacket->SetInt(nPosUmY);

	return m_pNetClient->SendToServer(SC2SS_COMMAND_GLASS_GO, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetClient::Send_CommandJog( int nJog )
{
	if (m_pNetClient==NULL) return 0;

	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return 0;

	pPacket->SetInt(nJog);

	return m_pNetClient->SendToServer(SC2SS_COMMAND_JOG, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetClient::Send_CommandJogSpeed( int nJogSpeed )
{
	if (m_pNetClient==NULL) return 0;

	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return 0;

	pPacket->SetInt(nJogSpeed);

	return m_pNetClient->SendToServer(SC2SS_COMMAND_JOG_SPEED, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetClient::Send_CommandAfm( int nAfm )
{
	if (m_pNetClient==NULL) return 0;

	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return 0;

	pPacket->SetInt(nAfm);

	return m_pNetClient->SendToServer(SC2SS_COMMAND_AFM, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetClient::Send_CommandAfmJog( int nJog )
{
	if (m_pNetClient==NULL) return 0;

	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return 0;

	pPacket->SetInt(nJog);

	return m_pNetClient->SendToServer(SC2SS_COMMAND_AFM_JOG, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetClient::Send_CommandAfmJogSpeed( int nJogSpeed )
{
	if (m_pNetClient==NULL) return 0;

	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return 0;

	pPacket->SetInt(nJogSpeed);

	return m_pNetClient->SendToServer(SC2SS_COMMAND_AFM_JOG_SPEED, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetClient::Send_CommandAfmHome()
{
	if (m_pNetClient==NULL) return 0;

	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return 0;

	return m_pNetClient->SendToServer(SC2SS_COMMAND_AFM_HOME, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetClient::Send_StatusReviewResult(int nModuleIndex, int nPlanIndex, int nResultCount, char* pResultData)
{
	if (m_pNetClient==NULL) return 0;

	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return 0;

	pPacket->SetInt(nModuleIndex);
	pPacket->SetInt(nPlanIndex);
	pPacket->SetInt(nResultCount);
	int nSize = sizeof(CSignalControlResultData) * nResultCount ;
	pPacket->SetBuffer(nSize,pResultData);

	return m_pNetClient->SendToServer(SC2SS_STATUS_REVIEWRESULT, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_CommandLoading(int nModuleIndex, CNetPacket* pPacket)
{
	if (m_pNetClient==NULL) return;

	m_pNetClient->SendToServer(SC2SS_ACK_COMMAND_LOADING, NET_RESULT_SUCCESS, m_nIndex);

	if (m_pISCNC2P)
	{
		//CString strGlassID = pPacket->GetString(0);
		const char* pBuffer			= pPacket->GetBuffer();
		m_pISCNC2P->ISCNC2P_Command_Loading(nModuleIndex,pBuffer);
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_CommandReviewResult(int nModuleIndex, CNetPacket* pPacket)
{
	if (m_pNetClient==NULL) return;

	m_pNetClient->SendToServer(SC2SS_ACK_COMMAND_REVIEWRESULT, NET_RESULT_SUCCESS, m_nIndex);

	if (m_pISCNC2P)
	{
		// int0 : module index
		// int1 : plan index
		// int2 : result count
		// buffer0 : result pointer
		int nReviewModuleIndex  = pPacket->GetInt(0);
		int nPlanIndex			= pPacket->GetInt(1);
		int nResultcount		= pPacket->GetInt(2);
		int nMagLevel			= pPacket->GetInt(3);
		int nDrsEtcCount		= pPacket->GetInt(4);
		const char* pBuffer		= pPacket->GetBuffer();

		m_pISCNC2P->ISCNC2P_Command_ReviewResult(nModuleIndex,nReviewModuleIndex, nPlanIndex, nResultcount , pBuffer, nMagLevel, nDrsEtcCount);
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_CommandPlanStart(int nModuleIndex, CNetPacket* pPacket)
{
	if (m_pNetClient==NULL) return;

	m_pNetClient->SendToServer(SC2SS_ACK_COMMAND_PLANSTART, NET_RESULT_SUCCESS, m_nIndex);

	if (m_pISCNC2P)
	{
		int nPlanIndex = pPacket->GetInt(0);
		m_pISCNC2P->ISCNC2P_Command_PlanStart(nModuleIndex, nPlanIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetClient::Process_CommandPlanEnd(int nModuleIndex, CNetPacket* pPacket)
{
	if (m_pNetClient==NULL) return;

	m_pNetClient->SendToServer(SC2SS_ACK_COMMAND_PLANEND, NET_RESULT_SUCCESS, m_nIndex);

	if (m_pISCNC2P)
	{
		int nPlanIndex = pPacket->GetInt(0);
		m_pISCNC2P->ISCNC2P_Command_PlanEnd(nModuleIndex, nPlanIndex);
	}
}