SDC/A5_QD_CF_REVIEW.git

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