// ctcl.cpp : Defines the entry point for the DLL application.
//

#include "stdafx.h"
#include "ctcls.h"
#include "ctcl.h"

#if !defined(CTCLS_EXPORTS) && !defined(CTCL_LAUNCHER)
#include "recscore.h"
#endif // !defined(CTCLS_EXPORTS) && !defined(CTCL_LAUNCHER)

#define MAX_TESLAS          16
#define MAX_CAMERAS         4

#define PORT_Launcher       1000
#define PORT_Game           1001
#define PORT_CameraShip     1001

#define TCKS_GameInfo       1000

class CTeslaInfo;

#if !defined(CTCL_LAUNCHER)
extern void _stdcall GetFileName4GUID(char szBuf[256], const char* pcszDrv, const char* pcszPath, const char* pcszExt, const GUID& guid = *(const GUID*)NULL);
extern const char* g_pcszGameDataSavePath;
extern const char* g_pcszGameDataExtPR;
extern const char* g_pcszGameDataExtMR;
extern HWND hWindow;
#endif // !defined(CTCL_LAUNCHER)

int GetCTCLTypePort(int nCTCLType);
CSOCClient* CreateSOCClient(const CSOCListen& SOCListen, DWORD dwCSCParam1, DWORD dwCSCParam2);

class CSOC_Server : public CSOCServer
{
	DECLARE_PACKET_MAP(CSOC_Server);
public:
    CTeslaInfo* m_pTI;
    DWORD m_dwLastGameInfo;
    int m_nGameReturn;
public:
    CSOC_Server(CTeslaInfo& TI);
    virtual ~CSOC_Server();
    virtual void OnConnect();
    BOOL CheckLastGameInfo();
    void OnGameReturn();
#if !defined(CTCL_LAUNCHER)
    void OnSendFile();
    void OnInviteCOOP();
#endif // !defined(CTCL_LAUNCHER)
};

class CSOC_2Launcher : public CSOC_Server
{
	DECLARE_PACKET_MAP(CSOC_2Launcher);
public:
    BOOL m_bMissionReview;
public:
	CSOC_2Launcher(CTeslaInfo& TI);
	virtual ~CSOC_2Launcher();
    virtual void OnConnect();
    void CheckConnection();
    void OnGameInfo();
};

class CSOC_2Game : public CSOC_Server
{
	DECLARE_PACKET_MAP(CSOC_2Game);
public:
public:
	CSOC_2Game(CTeslaInfo& TI);
	virtual ~CSOC_2Game();
};

class CSOC_2CameraShip : public CSOC_Server
{
	DECLARE_PACKET_MAP(CSOC_2CameraShip);
public:
public:
	CSOC_2CameraShip(CTeslaInfo& TI);
	virtual ~CSOC_2CameraShip();
};

class CSOC_Client : public CSOCClient
{
	DECLARE_PACKET_MAP(CSOC_Client);
public:
public:
    CSOC_Client();
    virtual ~CSOC_Client();
    virtual void OnAccept();
    void OnOrderAppl();
    void OnErrorStartGame();
    void OnReadyStartGame();
    void OnBOTS();
    void OnSetMechs();
    void OnDoLaunch();
#if !defined(CTCL_LAUNCHER)
    void OnSendFile();
    void OnInviteCOOP();
#endif // !defined(CTCL_LAUNCHER)
};
#if defined(CTCL_LAUNCHER)
class CSOC_Launcher : public CSOC_Client
{
	DECLARE_PACKET_MAP(CSOC_Launcher);
public:
public:
	CSOC_Launcher();
	virtual ~CSOC_Launcher();
    void OnGameInfo();
    void OnOrderAppl();
};
#else // !defined(CTCL_LAUNCHER)
class CSOC_Game : public CSOC_Client
{
	DECLARE_PACKET_MAP(CSOC_Game);
public:
public:
	CSOC_Game();
	virtual ~CSOC_Game();
};

class CSOC_CameraShip : public CSOC_Client
{
	DECLARE_PACKET_MAP(CSOC_CameraShip);
public:
public:
	CSOC_CameraShip();
	virtual ~CSOC_CameraShip();
};
#endif // defined(CTCL_LAUNCHER)
DECLARE_TARRAYREF(CTeslaInfo);
class CTeslaInfo : public CStr
{
public:
    BOOL m_bCameraShip;
    CStr m_strHost;
    u_long m_ulAddr;
	CSOC_2Launcher m_2Launcher;
    CSOC_2Game* m_p2Game;
    CSOC_2CameraShip* m_p2CameraShip;

    int m_nApplType;
    int m_nApplState;
    int m_nGameState;
    int m_nGameTime;
    int m_nGameIsServer;

    CInviteCOOP m_COOP;
public:
    CTeslaInfo();
    void SetTeslaInfo();
    void CheckConnection();
    CSOC_Server& GetGameSOC() const
    {
        if (m_bCameraShip) {
            return *m_p2CameraShip;
        } else {
            return *m_p2Game;
        }
    }
};

class CTeslas : public TARRAYREF(CTeslaInfo)
{
public:
    int m_nCameraShips;
public:
    CTeslas()
    {
        m_nCameraShips = 0;
    }
    ~CTeslas()
    {
        m_nCameraShips = 0;
    }
    CTeslaInfo& AddNew(int nAllocType);
    CTeslaInfo& GetMissionReview() const;
};

#if !defined(CTCL_LAUNCHER)
class CSendFile : public TDBLNK(CSendFile*)
{
public:
    SYSTEMTIME m_SysTime;
    GUID m_guid;
    int m_nType;
    DWORD m_dwLast;
    bool m_bProcessed;
    CStr m_strHost;
    DWORD m_dwTickCreated;
    DWORD m_dwTickDelay;
public:
    CSendFile(const SYSTEMTIME& SysTime, const GUID& guid, int nType);
    void Check();
};

class CSendFileManager : public TDBLNKDESTROY(CSendFile)
{
public:
public:
    CSendFileManager();
    CSendFile* Find(const GUID& guid, int nType) const;
};
#endif // !defined(CTCL_LAUNCHER)

class CCTCLManager : public CSOCManager
{
public:
    CTeslas m_aTIs;
    CStr m_aCmds[_EAT_MAX][2]; // game & cameraship
#if !defined(CTCLS_EXPORTS)
    // Mech4 only
    TARRAY(BYTE) m_aNMP;
#if !defined(CTCL_LAUNCHER)
    CSendFileManager m_SFM_Send;
    CSendFileManager m_SFM_Recv;
    CSendFileManager m_SFM_Done;
#endif // !defined(CTCL_LAUNCHER)
#endif // !defined(CTCLS_EXPORTS)
public:
    CCTCLManager() : CSOCManager(1000) { }
    BOOL Start(int nCTCLType);
    void Stop();
    void Run();
#if !defined(CTCLS_EXPORTS)
    void DoMech4Comm();
    void SaveNMP(const void* p, int nSize);
    void* LoadNMP(int& nSize);
#if !defined(CTCL_LAUNCHER)
    void SendFile(const SYSTEMTIME& SysTime, const GUID& guid, int nType);
    bool DoReprintOrCheck(bool bRealPrint);
    bool IsPendingMissionReplayRequest() const;
#endif / !defined(CTCL_LAUNCHER)
#endif // !defined(CTCLS_EXPORTS)
};
CCTCLManager* g_pCTCLManager = NULL;

#if !defined(CTCL_LAUNCHER)
// not extern "C"
extern bool g_bCOOP; // COin OPeration
extern int g_nCoinCount;
extern int g_nCoinCountTemp;
extern int g_nCoinPerGame;
#endif // !defined(CTCL_LAUNCHER)

#if defined(CTCL_LAUNCHER)
char g_szTeslaName[128];
#else // !defined(CTCL_LAUNCHER)
extern char g_szTeslaName[128];
extern char g_szTeslaAddr[128];
extern DWORD g_dwTeslaAddr;
extern char g_szTeslaInviter[128];
#endif // !defined(CTCL_LAUNCHER)

extern "C" {
int g_nCTCLType = _ECTCL_None;

int g_nCTCL_DoLaunchGame = 0;
#if !defined(CTCLS_EXPORTS)
CInviteCOOP g_InviteCOOP;
// Mech4 only
int g_nMech4Comm = 0;
BOOL g_bIsServer = FALSE;
SPlayerInfo g_aPlayerInfos[20];
int g_nPlayerInfos;
int g_nServer;
int g_nTeslas;
int g_nPrintOut;
int g_nMissionReview;
SYSTEMTIME g_SysTime;
GUID g_guidGameDatas;
char g_szGameName[128];
int g_nBOTs;

DWORD g_dwJoinStartTicks;
#endif // !defined(CTCLS_EXPORTS)

const char PROF_INI[] = "c:\\ctcl.ini";
const char SECT_TESLAS[] = "teslas";
#ifdef _DEBUG
const char SECT_GAMES[] = "games4dbg";
#else // !_DEBUG
const char SECT_GAMES[] = "games";
#endif // _DEBUG
const char SECT_CONFIG[] = "config";

const char SECT_AUX1TEAM[] = "aux1team";
const char SECT_AUX1FFA[] = "aux1ffa";
const char SECT_AUX1MISC[] = "aux1misc";
const char SECT_SND1TEAM[] = "snd1team";
const char SECT_SND1FFA[] = "snd1ffa";
const char SECT_SND1MISC[] = "snd1misc";
} // end of extern "C"

BEGIN_PACKET_MAP(CSOC_Server, CSOCServer)
    PACKET_MAP_ENTRY(CSOC_Server, S_GameReturn, OnGameReturn)
#if !defined(CTCL_LAUNCHER)
    PACKET_MAP_ENTRY(CSOC_Server, S_SendFile, OnSendFile)
    PACKET_MAP_ENTRY(CSOC_Server, S_InviteCOOP, OnInviteCOOP)
#endif // !defined(CTCL_LAUNCHER)
END_PACKET_MAP(CSOC_Server)

BEGIN_PACKET_MAP(CSOC_2Launcher, CSOC_Server)
    PACKET_MAP_ENTRY(CSOC_2Launcher, S_GameInfo, OnGameInfo)
END_PACKET_MAP(CSOC_2Launcher)

BEGIN_PACKET_MAP(CSOC_2Game, CSOC_Server)
END_PACKET_MAP(CSOC_2Game)

BEGIN_PACKET_MAP(CSOC_2CameraShip, CSOC_Server)
END_PACKET_MAP(CSOC_2CameraShip)

BEGIN_PACKET_MAP(CSOC_Client, CSOCClient)
    PACKET_MAP_ENTRY(CSOC_Client, C_OrderAppl, OnOrderAppl)
    PACKET_MAP_ENTRY(CSOC_Client, C_ErrorStartGame, OnErrorStartGame)
    PACKET_MAP_ENTRY(CSOC_Client, C_ReadyStartGame, OnReadyStartGame)
    PACKET_MAP_ENTRY(CSOC_Client, C_BOTS, OnBOTS)
    PACKET_MAP_ENTRY(CSOC_Client, C_SetMechs, OnSetMechs)
    PACKET_MAP_ENTRY(CSOC_Client, C_DoLaunch, OnDoLaunch)
#if !defined(CTCL_LAUNCHER)
    PACKET_MAP_ENTRY(CSOC_Client, C_SendFile, OnSendFile)
    PACKET_MAP_ENTRY(CSOC_Client, C_InviteCOOP, OnInviteCOOP)
#endif // !defined(CTCL_LAUNCHER)
END_PACKET_MAP(CSOC_Client)

#if defined(CTCL_LAUNCHER)
BEGIN_PACKET_MAP(CSOC_Launcher, CSOC_Client)
    PACKET_MAP_ENTRY(CSOC_Launcher, C_GameInfo, OnGameInfo)
    PACKET_MAP_ENTRY(CSOC_Launcher, C_OrderAppl, OnOrderAppl)
END_PACKET_MAP(CSOC_Launcher)
#else // !defined(CTCL_LAUNCHER)
BEGIN_PACKET_MAP(CSOC_Game, CSOC_Client)
END_PACKET_MAP(CSOC_Game)

BEGIN_PACKET_MAP(CSOC_CameraShip, CSOC_Client)
END_PACKET_MAP(CSOC_CameraShip)
#endif // defined(CTCL_LAUNCHER)

#if !(defined(CTCLS_EXPORTS) || defined(CTCL_LAUNCHER))
void LoadAux1Data();
#endif // !(defined(CTCLS_EXPORTS) || defined(CTCL_LAUNCHER))

#if !(defined(CTCLS_EXPORTS) || defined(CTCL_LAUNCHER))
void LoadAux1Data()
{
extern char aux1_messages[14 + 2][60];
extern char aux1_sounds[14 + 2][60];
    char sz[4 + 60 + 10/*safety*/];
    char szName[64];
    char* psz = &sz[4];

    for(int i = 1; i <= 7; i++) {
        sprintf(szName, "%d", i);

        sprintf(sz, "%d - ", i);
        GetPrivateProfileString(SECT_AUX1TEAM, szName, "", psz, 60 - 4, PROF_INI);
        if (psz[0]) {
            strcpy(&aux1_messages[i - 1][0], sz);
        }

        GetPrivateProfileString(SECT_AUX1FFA, szName, "", psz, 60 - 4, PROF_INI);
        if (psz[0]) {
            strcpy(&aux1_messages[i - 1 + 7][0], sz);
        }

        if (i <= 2) { // misc
            GetPrivateProfileString(SECT_AUX1MISC, szName, "", psz, 60 - 4, PROF_INI);
            if (sz[0]) {
                strcpy(&aux1_messages[i - 1 + 14][0], sz);
            }
        }

        GetPrivateProfileString(SECT_SND1TEAM, szName, "", sz, 60, PROF_INI);
        if (sz[0]) {
            strcat(sz, "{handle}");
            strcpy(&aux1_sounds[i - 1][0], sz);
        }

        GetPrivateProfileString(SECT_SND1FFA, szName, "", sz, 60, PROF_INI);
        if (sz[0]) {
            strcat(sz, "{handle}");
            strcpy(&aux1_sounds[i - 1 + 7][0], sz);
        }

        if (i <= 2) { // misc
            GetPrivateProfileString(SECT_SND1MISC, szName, "", sz, 60, PROF_INI);
            if (sz[0]) {
                strcat(sz, "{handle}");
                strcpy(&aux1_sounds[i - 1 + 14][0], sz);
            }
        }
    }
}
#endif // !(defined(CTCLS_EXPORTS) || defined(CTCL_LAUNCHER))

bool _stdcall RunExec(const CStr& strExec)
{
    if (strExec.GetLength() > 0) {
        CStr strDir;
        int nStart = 0, nLen;
        const char* pcszExec = strExec.String();
        if (*pcszExec == '"') {
            nStart++;
            nLen = strExec.Find('"');
            if (nLen != -1) {
                nLen--;
            }
        } else {
            nLen = strExec.Find(' ');
        }
        strDir.Assign(&pcszExec[nStart], nLen);
        strDir.AsDirectory(TRUE);

        char szBuf[512];
        strcpy(szBuf, strExec.String());
        STARTUPINFO si;
        memset(&si, 0, sizeof(si));
        si.cb = sizeof(si);
        si.dwX = si.dwY = si.dwXSize = si.dwYSize = CW_USEDEFAULT;
        PROCESS_INFORMATION pi;
    
        return !!CreateProcess(NULL, szBuf, NULL, NULL, FALSE, CREATE_DEFAULT_ERROR_MODE | CREATE_NEW_PROCESS_GROUP | HIGH_PRIORITY_CLASS, NULL, strDir.String(), &si, &pi);
    }

    return false;
}

int GetCTCLTypePort(int nCTCLType)
{
    switch(nCTCLType) {
    case _ECTCL_Launcher:
        return PORT_Launcher;
    case _ECTCL_Game:
        return PORT_Game;
    case _ECTCL_CameraShip:
        return PORT_CameraShip;
    default:
        ASSERT(FALSE);
        return 0;
    }
}

CSOCClient* CreateSOCClient(const CSOCListen& SOCListen, DWORD dwCSCParam1, DWORD dwCSCParam2)
{
    &dwCSCParam1, &dwCSCParam2;

    switch(dwCSCParam1) {
#if defined(CTCL_LAUNCHER)
    case _ECTCL_Launcher:
        return new CSOC_Launcher();
#else // !defined(CTCL_LAUNCHER)
    case _ECTCL_Game:
        return new CSOC_Game();
    case _ECTCL_CameraShip:
        return new CSOC_CameraShip();
#endif // defined(CTCL_LAUNCHER)
    default:
        ASSERT(FALSE);
        return NULL;
    }
}
#if !defined(CTCLS_EXPORTS)
CInviteCOOP::CInviteCOOP()
{
    m_pParent = NULL;

    Clear();
}

void CInviteCOOP::Clear()
{
    m_nTimeInvite = 0;
    m_nResult = 0;
    m_nResultAccepted = 0;
    memset(&m_guidGameData, 0, sizeof(m_guidGameData));
}
#endif // !defined(CTCLS_EXPORTS)
CSOC_Server::CSOC_Server(CTeslaInfo& TI)
    : m_pTI(&TI)
{
    m_dwLastGameInfo = 0;
    m_nGameReturn = _EGR_NotConnected;
}

CSOC_Server::~CSOC_Server()
{
}

void CSOC_Server::OnConnect()
{
    m_nGameReturn = _EGR_Connected;
}

BOOL CSOC_Server::CheckLastGameInfo()
{
    DWORD dwTicks = GetTickCount();
    if (m_dwLastGameInfo) {
        if ((m_dwLastGameInfo + TCKS_GameInfo) <= dwTicks) {
            m_dwLastGameInfo = dwTicks;
            return TRUE;
        }
    } else {
        m_dwLastGameInfo = dwTicks - TCKS_GameInfo + (rand() % TCKS_GameInfo);
    }
    return FALSE;
}

void CSOC_Server::OnGameReturn()
{
    Disassemble("n", &m_nGameReturn);
}
#if !defined(CTCL_LAUNCHER)
void CSOC_Server::OnSendFile()
{
    BYTE bCode;
    if (Disassemble("B", &bCode)) {
        ASSERT((bCode == 0) || (bCode == 3));
        // ¹Þ¾Æ°¡½Ã¿À from Game to console...
        SYSTEMTIME* pSysTime;
        WORD wSysTimeSize;
        GUID* pGUID;
        WORD wSize;
        int nType;
        DWORD dwTickDelay;
        if (Disassemble("xxnD", &pSysTime, &wSysTimeSize, &pGUID, &wSize, &nType, &dwTickDelay)) {
            if (pSysTime && (wSysTimeSize == sizeof(SYSTEMTIME)) && pGUID && (wSize == sizeof(GUID))) {
                CSendFile* pSF;
                pSF = g_pCTCLManager->m_SFM_Done.Find(*pGUID, nType);
                if (!pSF) {
                    // not already processed...
                    pSF = g_pCTCLManager->m_SFM_Recv.Find(*pGUID, nType);
                    if (pSF) {
                        if (bCode == 3) {
                            // ¹Ì¼Ç¸®ºä ¼­¹ö°¡ mission review ¹Þ¾Ò´Ù´Â °ÍÀ» ¹Þ¾Ò´À³Ä?
                            pSF->m_bProcessed = true;
                            g_pCTCLManager->m_SFM_Recv.Cut(pSF);
                            g_pCTCLManager->m_SFM_Done.AddTail(pSF);
                        }
                    } else {
                        // not already receieved...
                        pSF = new CSendFile(*pSysTime, *pGUID, nType);
                        pSF->m_strHost.Assign(m_pTI->m_strHost);
                        pSF->m_dwTickDelay = dwTickDelay;
                        g_pCTCLManager->m_SFM_Recv.AddTail(pSF);
                    }
                }
                if (bCode == 0)
                    DoSendX("BBxxnD", C_SendFile, 1, pSysTime, wSysTimeSize, pGUID, wSize, nType, 0);
            }
        }
    }
}

void CSOC_Server::OnInviteCOOP()
{
    int nTimeInvite;
    GUID* pGUID;
    WORD wGUID;
    int nResult;

    if (Disassemble("nxn", &nTimeInvite, &pGUID, &wGUID, &nResult)) {
        if (pGUID && (wGUID == sizeof(GUID))) {
            CInviteCOOP& COOP = m_pTI->m_COOP;
            if ((COOP.m_nTimeInvite == nTimeInvite) && (memcmp(&COOP.m_guidGameData, pGUID, sizeof(GUID)) == 0)) {
                DoSendX("Bnxn", S_InviteCOOP, nTimeInvite, pGUID, wGUID, -1); // result accepted...
                COOP.m_nResult = nResult;
            } else {
                DoSendX("Bnxn", S_InviteCOOP, nTimeInvite, pGUID, wGUID, -2); // forget result... I don't know...
            }
        }
    }
}
#endif // !defined(CTCL_LAUNCHER)
CSOC_2Launcher::CSOC_2Launcher(CTeslaInfo& TI)
    : CSOC_Server(TI), m_bMissionReview(FALSE)
{
}

CSOC_2Launcher::~CSOC_2Launcher()
{
}

void CSOC_2Launcher::OnConnect()
{
    CSOC_Server::OnConnect();
    DoSendX("B", C_GameInfo);
}

void CSOC_2Launcher::CheckConnection()
{
#if !defined(CTCLS_EXPORTS) && !defined(CTCL_LAUNCHER)
    if (g_bCOOP) {
        m_pTI->CheckConnection();
    } else {
#endif // !defined(CTCLS_EXPORTS) && !defined(CTCL_LAUNCHER)
    if (/*!m_bMissionReview && */!IsValid()) {
        g_pCTCLManager->DoConnect(this);
    } else {
        if (GetConnectionState() == +1) {
            if (CheckLastGameInfo()) {
                DoSendX("B", C_GameInfo);
            }
            m_pTI->CheckConnection();
        }
    }
#if !defined(CTCLS_EXPORTS) && !defined(CTCL_LAUNCHER)
    }
#endif // !defined(CTCLS_EXPORTS) && !defined(CTCL_LAUNCHER)
}

void CSOC_2Launcher::OnGameInfo()
{
    BYTE bApplType;
    BYTE bApplState;
    BYTE bGameState;
    int nGameTime;
    BYTE bGameIsServer;

    if (Disassemble("BBBDB", &bApplType, &bApplState, &bGameState, &nGameTime, &bGameIsServer)) {
        m_pTI->m_nApplType = bApplType;
        m_pTI->m_nApplState = bApplState;
        m_pTI->m_nGameState = bGameState;
        m_pTI->m_nGameTime = nGameTime;
        m_pTI->m_nGameIsServer = bGameIsServer;
    }
}

CSOC_2Game::CSOC_2Game(CTeslaInfo& TI)
    : CSOC_Server(TI)
{
    SetTarget(TI.m_ulAddr);
    SetPort(PORT_Game);
    SetSOCPP((CSOC **)&TI.m_p2Game);
}

CSOC_2Game::~CSOC_2Game()
{
}

CSOC_2CameraShip::CSOC_2CameraShip(CTeslaInfo& TI)
    : CSOC_Server(TI)
{
    SetTarget(TI.m_ulAddr);
    SetPort(PORT_CameraShip);
    SetSOCPP((CSOC **)&TI.m_p2CameraShip);
}

CSOC_2CameraShip::~CSOC_2CameraShip()
{
}

CSOC_Client::CSOC_Client()
{
}

CSOC_Client::~CSOC_Client()
{
    if (g_InviteCOOP.m_pParent == this) {
        g_InviteCOOP.m_pParent = NULL;
        //?g_InviteCOOP.Clear();
    }
}

void CSOC_Client::OnOrderAppl()
{
    BYTE bOrder, bCameraShip;
    int nParam;

    if (Disassemble("BDB", &bOrder, &nParam, &bCameraShip)) {
        switch(bOrder) {
        case _CTCL_Order_Terminate: // terminate
            CTCL_DoTerminateAppl();
            break;
        case _CTCL_Order_EndMission: // End Mission
            CTCL_DoEndMission();
            break;
        }
    }
}
#if defined(CTCL_LAUNCHER)
CSOC_Launcher::CSOC_Launcher()
{
}

CSOC_Launcher::~CSOC_Launcher()
{
}

void CSOC_Launcher::OnGameInfo()
{
    int nApplType = CTCL_GetApplType();
    int nApplState = CTCL_GetApplState();
    int nGameState = CTCL_GetGameState();
    int nGameTime = CTCL_GetGameTime();
    int nGameIsServer = CTCL_GetGameIsServer();
    DoSendX("BBBBDB", S_GameInfo, nApplType, nApplState, nGameState, nGameTime, nGameIsServer);
}

void CSOC_Launcher::OnOrderAppl()
{
    BYTE bOrder, bCameraShip;
    int nParam;

    if (Disassemble("BDB", &bOrder, &nParam, &bCameraShip)) {
        switch(bOrder) {
        case _CTCL_Order_Launch: // Launch
            if ((0 < nParam) && (nParam <= _EAT_MAX)) {
                nParam--;
                const CStr& strExec = g_pCTCLManager->m_aCmds[nParam][bCameraShip ? 1: 0];
                if (strExec.GetLength() > 0) {
                    //WinExec(strExec, SW_SHOWNORMAL);
                    RunExec(strExec);
                }
            } else {
                ASSERT(FALSE);
            }
            break;
        case _CTCL_Order_Shutdown:
        case _CTCL_Order_Reboot:
          {
            HANDLE hToken;
            TOKEN_PRIVILEGES TokenPrivileges;
            int nErr = 0;
            if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
                LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME/*SE_REMOTE_SHUTDOWN_NAME*/, &(TokenPrivileges.Privileges[0].Luid));
                TokenPrivileges.PrivilegeCount           = 1;
                TokenPrivileges.Privileges[0].Attributes = 2;
                AdjustTokenPrivileges(hToken, FALSE, &TokenPrivileges, sizeof(TOKEN_PRIVILEGES), NULL, NULL);
                CloseHandle(hToken);
#if 1
                if (!ExitWindowsEx((bOrder == _CTCL_Order_Shutdown) ? EWX_POWEROFF: EWX_REBOOT, 0)) {
                    GetLastError();
                }
#else
                if (!InitiateSystemShutdown(NULL,  // name of computer to shut down 
                    NULL,      // address of message to display
                    10,       // time to display dialog box 
                    TRUE, // force applications with unsaved changes flag 
                    FALSE))
                {
                    GetLastError();
                }
#endif
            }
            break;
           }
		case _CTCL_Order_Unload:
			PostQuitMessage(0);
			break;
        }
    }
}
#else // !defined(CTCL_LAUNCHER)
CSOC_Game::CSOC_Game()
{
}

CSOC_Game::~CSOC_Game()
{
}

CSOC_CameraShip::CSOC_CameraShip()
{
}

CSOC_CameraShip::~CSOC_CameraShip()
{
}
#endif // defined(CTCL_LAUNCHER)
void CSOC_Client::OnAccept()
{
    // include launcher?
    g_pCTCLManager->m_aNMP.Reset();
    g_bIsServer = FALSE;
    g_nPlayerInfos = 0;
    g_nServer = -1;
    g_nTeslas = 0;
    g_nBOTs = 0;
    g_szGameName[0] = '\0';
}

void CSOC_Client::OnErrorStartGame()
{
#if !defined(CTCLS_EXPORTS)
    // to main menu....
	//$$COOP
    if (g_nMech4Comm) {
        if (g_bIsServer) {
        } else {
        }
    }
#endif // !defined(CTCLS_EXPORTS)
}

void CSOC_Client::OnReadyStartGame()
{
#if !defined(CTCLS_EXPORTS)
	//$$COOP
    BYTE bType;
    BYTE* p;
    WORD wLen;
	BYTE bTeam;
    const char* pcszName;
    int nMechIndex;
	short fileID;
	WORD recordID;
    const char* pcszMech;
    int nTeamOrSkin;
    int nDecal;
    DWORD dwAddr;
    BYTE bPrintOut;
    BYTE bMissionReview;
    BYTE* pGUID;
    WORD wGuidSize;
    SYSTEMTIME* pSysTime;
    WORD wSysTime;

    if (Disassemble("BnnxBsDWwsnnDBBxx", &bType, &g_nTeslas, &g_nBOTs, &p, &wLen, &bTeam, &pcszName,
        &nMechIndex, &fileID, &recordID, &pcszMech, &nTeamOrSkin, &nDecal, &dwAddr,
        &bPrintOut, &bMissionReview, &pGUID, &wGuidSize, &pSysTime, &wSysTime)) {
        if (pGUID && (wGuidSize == sizeof(GUID)) && pSysTime && (wSysTime == sizeof(SYSTEMTIME))) {
            g_nPlayerInfos = 1 + g_nBOTs + g_nTeslas;
            g_bIsServer = (bType == 1) ? TRUE: FALSE;
            const GUID& guid = *(const GUID*)pGUID;
            sprintf(g_szGameName, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
                    guid.Data1, guid.Data2, guid.Data3,
                    guid.Data4[0], guid.Data4[1],
                    guid.Data4[2], guid.Data4[3], guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);

            g_pCTCLManager->SaveNMP(p, wLen);

            SPlayerInfo& PI = g_aPlayerInfos[0];
            PI.m_bBot = FALSE;
		    PI.m_bTeam = bTeam;
            PI.m_nLevelOrTesla = 0; // never mind
            strcpy(PI.m_szName, pcszName);
            PI.m_uPlayerID = 0;
            PI.m_nMechIndex = nMechIndex;
	        PI.m_fileID = fileID;
	        PI.m_recordID = recordID;
            strcpy(PI.m_szMech, pcszMech);
            PI.m_nTeamOrSkin = nTeamOrSkin;
            PI.m_nDecal = nDecal;
            PI.m_dwAddr = dwAddr;
            g_nPrintOut = bPrintOut;
            g_nMissionReview = bMissionReview;
            g_guidGameDatas = *(GUID*)pGUID;
            g_SysTime = *pSysTime;

            CTCL_DoSendGameReturn(_EGR_PreparingStarted);
        } else {
            Drop();
        }
    }
#endif // !defined(CTCLS_EXPORTS)
}

void CSOC_Client::OnBOTS()
{
#if !defined(CTCLS_EXPORTS)
	//$$COOP
    ASSERT(g_bIsServer);
    int i;
    BYTE bBOT;
    int nLevelOrTesla;
    const char* pcszName;
    int nMechIndex;
	short fileID;
	WORD recordID;
    const char* pcszMech;
    int nTeamOrSkin;
    int nDecal;

    for(i = 1; i < g_nPlayerInfos; i++) {
        if (Disassemble("BnsDWwsnn", &bBOT, &nLevelOrTesla, &pcszName, &nMechIndex, &fileID, &recordID, &pcszMech, &nTeamOrSkin, &nDecal)) {
            SPlayerInfo& PI = g_aPlayerInfos[i];
            PI.m_bBot = bBOT ? TRUE: FALSE;
            PI.m_nLevelOrTesla = nLevelOrTesla;
            strcpy(PI.m_szName, pcszName);
            PI.m_uPlayerID = 0;
            PI.m_nMechIndex = nMechIndex;
	        PI.m_fileID = fileID;
	        PI.m_recordID = recordID;
            strcpy(PI.m_szMech, pcszMech);
            PI.m_nTeamOrSkin = nTeamOrSkin;
            PI.m_nDecal = nDecal;
        } else {
            return;
        }
    }
    g_nMech4Comm = 1;
#endif // !defined(CTCLS_EXPORTS)
}

void CSOC_Client::OnSetMechs()
{
    ASSERT(!g_bIsServer);
    CTCL_DoJoinGame();
}

void CSOC_Client::OnDoLaunch()
{
	CTCL_StartGame(TRUE);
}
#if !defined(CTCL_LAUNCHER)
void CSOC_Client::OnSendFile()
{
    BYTE bCode;
    if (Disassemble("B", &bCode)) {
        ASSERT((bCode == 1) || (bCode == 2));
        // ¹Þ¾Ò¿À from console to Game...
        SYSTEMTIME* pSysTime;
        WORD wSysTimeSize;
        GUID* pGUID;
        WORD wSize;
        int nType;
        if (Disassemble("xxn", &pSysTime, &wSysTimeSize, &pGUID, &wSize, &nType)) {
            if (pSysTime && (wSysTimeSize == sizeof(SYSTEMTIME)) && pGUID && (wSize == sizeof(GUID))) {
                CSendFile* pSF;

                if (bCode == 1) {
                    pSF = g_pCTCLManager->m_SFM_Send.Find(*pGUID, nType);
                    if (pSF) {
                        // receieved by ...
                        g_pCTCLManager->m_SFM_Send.Cut(pSF);
                        delete pSF;
                    }
                } else {
                    ASSERT(bCode == 2);
                    const char* pcszFile;
                    if (Disassemble("s", &pcszFile)) {
                        pSF = g_pCTCLManager->m_SFM_Done.Find(*pGUID, nType);
                        if (!pSF) {
                            pSF = g_pCTCLManager->m_SFM_Recv.Find(*pGUID, nType);
                            if (!pSF) {
                                CSendFile* pSF = new CSendFile(*pSysTime, *pGUID, nType);
                                pSF->m_strHost.Assign(pcszFile);
                                if ((nType == 1) && (g_nCTCLType == _ECTCL_CameraShip) && (*pSF->m_strHost.String() != '\0')) {
                                    g_pCTCLManager->m_SFM_Recv.AddTail(pSF);
                                    CTCL_SetGameState(_EGS_Preparing);
                                } else {
                                    g_pCTCLManager->m_SFM_Done.AddTail(pSF);
                                }
                            }
                        }
                        DoSendX("BBxxnD", S_SendFile, 3, pSysTime, wSysTimeSize, pGUID, wSize, nType, 0);
                    }
                }
            }
        }
    }
}

void CSOC_Client::OnInviteCOOP()
{
    int nTimeInvite;
    GUID* pGUID;
    WORD wGUID;
    int nResult;

    if (Disassemble("nxn", &nTimeInvite, &pGUID, &wGUID, &nResult)) {
        if (pGUID && (wGUID == sizeof(GUID))) {
            if (nResult == 0) { // requested...
                if (nTimeInvite == -999) {
                    if (g_InviteCOOP.m_pParent == this) {
                        g_InviteCOOP.Clear();
                        g_InviteCOOP.m_pParent = NULL;
                    }
                    DoSendX("Bnxn", C_InviteCOOP, nTimeInvite, pGUID, wGUID, -1);
                    return;
                /*} else if (g_nCoinCount < g_nCoinPerGame) {
                    g_InviteCOOP.Clear();
                    g_InviteCOOP.m_pParent = NULL;
                    DoSendX("Bnxn", C_InviteCOOP, nTimeInvite, pGUID, wGUID, 0);
                    return;*/
                } else if (g_InviteCOOP.m_pParent) {
                    if (g_InviteCOOP.m_pParent == this) {
                        if ((g_InviteCOOP.m_nTimeInvite == nTimeInvite) && (memcmp(&g_InviteCOOP.m_guidGameData, pGUID, sizeof(GUID)) == 0)) {
                            if (g_InviteCOOP.m_nResult == 0) {
                                g_InviteCOOP.m_nResult = 1;
                            }
                            DoSendX("Bnxn", C_InviteCOOP, nTimeInvite, pGUID, wGUID, g_InviteCOOP.m_nResult);
                        } else {
                            goto as_new;
                        }
                    } else {
                        if (g_InviteCOOP.m_nResult == 2) {
                            if (g_InviteCOOP.m_nResultAccepted)
                                goto as_new;
                        }
                    }
                } else {
as_new:
                    g_InviteCOOP.m_pParent = this;

                    g_InviteCOOP.m_nTimeInvite = nTimeInvite;
                    g_InviteCOOP.m_nResult = 0;
                    g_InviteCOOP.m_nResultAccepted = 0;
                    memcpy(&g_InviteCOOP.m_guidGameData, pGUID, sizeof(GUID));

                    const char* pcszTesla = "Unknown";
                    const CTeslas& aTIs = g_pCTCLManager->m_aTIs;
                    int i, nTesla = aTIs.GetSize();

                    for(i = 0; i < nTesla; i++)
                    {
                        CTeslaInfo& ti = aTIs.GetAt(i);
                        if (ti.m_ulAddr == m_Addr.GetTargetAddr()) {
                            pcszTesla = ti.String();
                            break;
                        }
                    }
                    strcpy(&g_szTeslaInviter[0], pcszTesla);
                }
            } else {
                ASSERT((nResult == -1) || (nResult == -2));
                if (g_InviteCOOP.m_pParent == this) {
                    if ((g_InviteCOOP.m_nTimeInvite == nTimeInvite) && (memcmp(&g_InviteCOOP.m_guidGameData, pGUID, sizeof(GUID)) == 0)) {
                        g_InviteCOOP.m_nResultAccepted = 1;
                    }
                }
            }
        }
    }
}
#endif // !defined(CTCL_LAUNCHER)
CTeslaInfo::CTeslaInfo()
    : m_2Launcher(*this)
{
    m_bCameraShip = FALSE;
    m_ulAddr = INADDR_ANY;

    m_2Launcher.SetAutoDelete(FALSE);
    m_p2Game = NULL;
    m_p2CameraShip = NULL;
}

void CTeslaInfo::SetTeslaInfo()
{
    m_2Launcher.m_pTI = this;
#if !defined(CTCL_LAUNCHER)
    if (g_bCOOP) {
        const char* pcszHost = m_strHost.String();
        ASSERT((pcszHost[0] == '\\') && (pcszHost[1] == '\\'));
        CSockAddr addr(0, &pcszHost[2]);
        u_long ulAddr = addr.GetTargetAddr();
        if ((ulAddr != INADDR_NONE) && (ulAddr != INADDR_ANY)  && (ulAddr != INADDR_LOOPBACK)) {
            m_ulAddr = ulAddr;
        }
    }
#endif // !defined(CTCL_LAUNCHER)
}

void CTeslaInfo::CheckConnection()
{
#if !defined(CTCLS_EXPORTS) && !defined(CTCL_LAUNCHER)
    if (g_bCOOP || (m_nApplType != _EAT_None))
#else // !defined(CTCLS_EXPORTS) && !defined(CTCL_LAUNCHER)
    if (m_nApplType != _EAT_None)
#endif // !defined(CTCLS_EXPORTS) && !defined(CTCL_LAUNCHER)
    {
        if (m_bCameraShip) {
            if (m_p2CameraShip)
                return;
            m_p2CameraShip = new CSOC_2CameraShip(*this);
            g_pCTCLManager->DoConnect(m_p2CameraShip);
        } else {
            if (m_p2Game)
                return;
            m_p2Game = new CSOC_2Game(*this);
            g_pCTCLManager->DoConnect(m_p2Game);
        }
    }
}

CTeslaInfo& CTeslas::AddNew(int nAllocType)
{
    if (nAllocType < 0) {
        int nSize = GetSize();
        if (nAllocType == -2) {
            nAllocType = nSize;
        } else {
            ASSERT(nAllocType == -1);
            int nStart = nSize - m_nCameraShips;
            while(nStart < nSize) {
                CTeslaInfo& ti = GetAt(nStart);
                if (ti.m_2Launcher.m_bMissionReview)
                    break;
                nStart++;
            }
            nAllocType = nStart;
        }
    }

    return Ins(nAllocType);
}

CTeslaInfo& CTeslas::GetMissionReview() const
{
    if (m_nCameraShips > 0) {
        CTeslaInfo* pTI = &GetAt(GetSize() - m_nCameraShips);
        CTeslaInfo* pTIEnd = &pTI[m_nCameraShips];
        while(pTI < pTIEnd) {
            if (pTI->m_2Launcher.m_bMissionReview) {
                return *pTI;
            }
            pTI++;
        }
        //return pTIEnd[-1];
    }
    return *(CTeslaInfo*)NULL;
}

BOOL CTCL_API CTCL_Start(int nCTCLType)
{
    ASSERT(g_nCTCLType == _ECTCL_None);
    g_pCTCLManager = new CCTCLManager();
    if (g_pCTCLManager) {
        if (g_pCTCLManager->Start(nCTCLType)) {
            return TRUE;
        }
        delete g_pCTCLManager;
        g_pCTCLManager = NULL;
    }
    return FALSE;
}

void CTCL_API CTCL_Stop()
{
    if (g_pCTCLManager) {
        g_pCTCLManager->Stop();
        delete g_pCTCLManager;
        g_pCTCLManager = NULL;
    }
}

void CTCL_API CTCL_Run()
{
    if (g_pCTCLManager) {
        g_pCTCLManager->Run();
    }
}
#if !defined(CTCLS_EXPORTS)
#if !defined(CTCL_LAUNCHER)
CSendFile::CSendFile(const SYSTEMTIME& SysTime, const GUID& guid, int nType)
    : m_SysTime(SysTime), m_guid(guid), m_nType(nType), m_dwLast(0), m_bProcessed(false), m_dwTickCreated(GetTickCount()), m_dwTickDelay(0)
{
    extern int g_nSecsMissionReplay;
    extern int g_nSecsMissionReport;

    if (m_nType == 1) { // mission replay file...
        m_dwTickDelay = g_nSecsMissionReplay * 1000;
    }
}

void CSendFile::Check()
{
    CSOC& SOC = *g_pCTCLManager->FindSOC(0);

    if (SOC.GetConnectionState() == 1) {
        DWORD dw = GetTickCount();
        if ((m_dwLast == 0) || ((m_dwLast + 500) < dw)) {
            m_dwLast = dw;
            DWORD dwTickDelay = m_dwTickDelay;
            DWORD dwElapsed = GetTickCount() - m_dwTickCreated;
            if (dwElapsed > dwTickDelay)
                dwTickDelay = 0;
            else
                dwTickDelay -= dwElapsed;
            SOC.DoSendX("BBxxnD", S_SendFile, 0, &m_SysTime, sizeof(m_SysTime), &m_guid, sizeof(m_guid), m_nType, dwTickDelay);
        }
    }
}

CSendFileManager::CSendFileManager()
{
}

CSendFile* CSendFileManager::Find(const GUID& guid, int nType) const
{
    CSendFile* pSF = GetHead();
    while(pSF) {
        if ((memcmp(&pSF->m_guid, &guid, sizeof(guid)) == 0) && (pSF->m_nType == nType))
            return pSF;
        pSF = pSF->m_pNext;
    }

    return pSF;
}
#endif // !defined(CTCL_LAUNCHER)
#endif // !defined(CTCLS_EXPORTS)
BOOL CCTCLManager::Start(int nCTCLType)
{
    if (Init()) {
        g_nCTCLType = nCTCLType;

#if !(defined(CTCLS_EXPORTS) || defined(CTCL_LAUNCHER))
        if ((nCTCLType == _ECTCL_Game) || (nCTCLType == _ECTCL_CameraShip)) {
            LoadAux1Data();
        }
#endif // !(defined(CTCLS_EXPORTS) || defined(CTCL_LAUNCHER))
        CSockAddr addrHost(0, GetHostAddress());
#if !defined(CTCL_LAUNCHER)
        strcpy(&g_szTeslaName[0], addrHost.GetTarget());
        //g_szTeslaAddr[0] = '\x01';
        strcpy(&g_szTeslaAddr[0], addrHost.GetTarget());
        g_dwTeslaAddr = addrHost.GetTargetAddr();
#endif // !defined(CTCL_LAUNCHER)

        char sz[1024];
        char szName[256];
        if (CTCL_IsConsoleOrCOOP()) {
            // Load TeslaInfos...
            bool bMissionReviewFound = false;
            sz[0] = '\0';
            GetPrivateProfileString(SECT_TESLAS, NULL, "", sz, sizeof(sz), PROF_INI);
            const char* pcsz = &sz[0];
            int nTIs = 0;
            while(*pcsz)
            {
                char c = pcsz[0];
                BOOL bCameraShip;
                
                if ((c == '#') || (c == '*')) {
                    pcsz++;
                    bCameraShip = TRUE;
                } else {
                    bCameraShip = FALSE;
                }
                CSockAddr addr(0, pcsz);
                u_long ulAddr = addr.GetTargetAddr();
                int i, n = m_aTIs.GetSize();
                bool bOK = false;
                if ((ulAddr != INADDR_NONE) && (ulAddr != INADDR_ANY)  && (ulAddr != INADDR_LOOPBACK)) {
                for(i = 0; i < n; i++) {
                    const CTeslaInfo& TI = m_aTIs.GetAt(i);
                        if (TI.m_ulAddr == ulAddr)
                        break;
                }
                if (i == n) {
                        bOK = true;
                    }
                }
                if (bOK) {
                        GetPrivateProfileString(SECT_TESLAS, bCameraShip ? &pcsz[-1]: pcsz, "", szName, sizeof(szName), PROF_INI);
                        char* pComma = strchr(szName,',');
                        if (pComma) {
                            *pComma++ = '\0';
                            CStr strName(szName), strHost(pComma);
                            strName.TrimAll();
                            strHost.TrimAll();
                            if ((strName.GetLength() > 0) && (strHost.GetLength() > 0)) {
                            BOOL bAdd = FALSE;
                            if (addrHost.GetTargetAddr() == ulAddr) {
                                strcpy(&g_szTeslaName[0], strName);
                            } else {
                                if (bCameraShip) {
                                    if (m_aTIs.m_nCameraShips < MAX_CAMERAS)
                                        bAdd = TRUE;
                                } else {
                                    if (nTIs < MAX_TESLAS)
                                        bAdd = TRUE;
                                }
                            }
                            if (bAdd) {
                                int nAllocType;
                                if (bCameraShip) {
                                    if (bMissionReviewFound || (pcsz[-1] == '*'))
                                        nAllocType = -2;
                                    else
                                        nAllocType = -1;
                                } else {
                                    nAllocType = nTIs;
                                }
                                CTeslaInfo& TI = m_aTIs.AddNew(nAllocType);
                                TI.Assign(strName);
                                TI.m_bCameraShip = bCameraShip;
                                TI.m_strHost.Assign("\\\\");
                                TI.m_strHost += strHost;
                                TI.m_ulAddr = ulAddr;
                                TI.m_2Launcher.SetTarget(ulAddr);
					            TI.m_2Launcher.SetPort(PORT_Launcher);
                                if (bCameraShip) {
                                    m_aTIs.m_nCameraShips++;
                                    if (!bMissionReviewFound && (nAllocType == -2)) {
                                        TI.m_2Launcher.m_bMissionReview = TRUE;
                                        bMissionReviewFound = true;
                                    }
                                } else {
                                    nTIs++;
                                }
                            }
                        }
                    }
                }
                pcsz += strlen(pcsz) + 1;
            }
            for(int i = 0; i < m_aTIs.GetSize(); i++) {
                m_aTIs.GetAt(i).SetTeslaInfo();
            }
            if (
#if !defined(CTCL_LAUNCHER)
                !g_bCOOP && 
#endif // !defined(CTCL_LAUNCHER)
                (nTIs <= 0) && (m_aTIs.m_nCameraShips <= 0)) {
                Exit();
                g_nCTCLType = _ECTCL_None;
                MessageBox(NULL, "no valid tesla infos!!!", "ctcl.ini error", MB_OK);
                return FALSE;
            }
        } else {
#ifdef CTCL_LAUNCHER
            if (nCTCLType == _ECTCL_Launcher) {
                for(int i = 1; i <= _EAT_MAX; i++) {
                    sprintf(szName, "%d", i); // game
                    GetPrivateProfileString(SECT_GAMES, szName, "", sz, sizeof(sz), PROF_INI);
                    CStr& str1 = m_aCmds[i - 1][0];
                    str1.Assign(sz);
                    str1.TrimAll();

                    sprintf(szName, "#%d", i); // camera ship
                    GetPrivateProfileString(SECT_GAMES, szName, "", sz, sizeof(sz), PROF_INI);
                    CStr& str2 = m_aCmds[i - 1][1];
                    str2.Assign(sz);
                    str2.TrimAll();
                }
            }
#endif // CTCL_LAUNCHER
            }
        if (nCTCLType != _ECTCL_Console) {
            if (!DoListen(GetCTCLTypePort(nCTCLType), CreateSOCClient, nCTCLType, 0)) {
                Exit();
                g_nCTCLType = _ECTCL_None;
                return FALSE;
            }
        }
        return TRUE;
    }

    return FALSE;
}

void CCTCLManager::Stop()
{
    ASSERT(g_nCTCLType != _ECTCL_None);
    Exit();
    if (g_nCTCLType == _ECTCL_Console) {
        m_aTIs.Reset();
    }
    g_nCTCLType = _ECTCL_None;
}

void CCTCLManager::Run()
{
    static BOOL s_bRunning = FALSE;
    int i, nSize;

    if (!s_bRunning) {
        if (CTCL_IsConsoleX()) {
            CTCL_SetApplState(_EAS_Launched);
            CTCL_SetGameState(_EGS_Idle);
        }
        s_bRunning = TRUE;
    }
    if (CTCL_IsConsoleOrCOOP()) {
        static DWORD s_dwLast = 0;
        if ((s_dwLast == 0) || ((s_dwLast + 500) <= GetTickCount())) {
            nSize = m_aTIs.GetSize();
            for(i = 0; i < nSize; i++) {
                m_aTIs.GetAt(i).m_2Launcher.CheckConnection();
            }
            s_dwLast = GetTickCount();
        }
    }
    if (g_nCTCLType == _ECTCL_Console) {
#if !defined(CTCL_LAUNCHER)
        bool bPrinted = false, bMissionReplay = false;
        CSendFile* pSF = m_SFM_Recv.GetHead();
        while(pSF && !(bPrinted && bMissionReplay)) {
            CSendFile* pSFNext = pSF->m_pNext;

            DWORD dw = GetTickCount();
            if ((pSF->m_dwLast == 0) || ((pSF->m_dwLast + 500) < dw)) {
                pSF->m_dwLast = dw;

                MW4PRINT_COPYDATASTRUCT cd;

                if (pSF->m_nType == 0) {
                    if (!bPrinted) {
                        HWND hWndPrint = FindWindow(NULL, "mw4print");
                        if (hWndPrint) {
                            GetFileName4GUID(cd.m_szFile, pSF->m_strHost, g_pcszGameDataSavePath, g_pcszGameDataExtPR, pSF->m_guid);
                            cd.dwData = MW4PRINT_COPYDATA_META;
                            cd.cbData = sizeof(cd) - sizeof(COPYDATASTRUCT);
                            cd.lpData = &cd.m_GUID;
                            cd.m_GUID = GUID_NULL;
                            if (::SendMessage(hWndPrint, WM_COPYDATA, (WPARAM)hWindow, (LPARAM)&cd) == 1) {
                                pSF->m_bProcessed = true;
                                m_SFM_Recv.Cut(pSF);
                                m_SFM_Done.AddTail(pSF);
                            }
                        }
                        bPrinted = true;
                    }
                } else if (pSF->m_nType == 1) {
                    if (!bMissionReplay) {
                        DWORD dwTickDelay = GetTickCount() - pSF->m_dwTickCreated;
                        if (pSF->m_dwTickDelay <= dwTickDelay) {
                            GetFileName4GUID(cd.m_szFile, pSF->m_strHost, g_pcszGameDataSavePath, g_pcszGameDataExtMR, pSF->m_guid);
                            CTeslaInfo& TI = m_aTIs.GetMissionReview();
                            if (&TI) {
                                ASSERT(TI.m_bCameraShip && TI.m_2Launcher.m_bMissionReview);
                                CSOC_Server& SOC = TI.GetGameSOC();
                                if (SOC.GetConnectionState() == +1) {
                                    SOC.DoSendX("BBxxnsD", S_SendFile, 2, &pSF->m_SysTime, sizeof(pSF->m_SysTime), &pSF->m_guid, sizeof(pSF->m_guid), pSF->m_nType, cd.m_szFile, 0);
                                }
                            }
                        }
                        bMissionReplay = true;
                    }
                } else {
                    if (pSF->m_nType == 2) {
                        extern void _stdcall CTCL_SaveLogGameEnd(const SYSTEMTIME& SysTime, const GUID& guid, const char* pcszHost);
                        CTCL_SaveLogGameEnd(pSF->m_SysTime, pSF->m_guid, pSF->m_strHost.String());
                    } else {
                        // error...
                    }
                    pSF->m_bProcessed = true;
                    m_SFM_Recv.Cut(pSF);
                    m_SFM_Done.AddTail(pSF);
                }
            }
            pSF = pSFNext;
        }
#endif // !defined(CTCL_LAUNCHER)
    } else {
		/*
		Ŭ¶óÀ̾ðÆ®³ª ¼­¹öÀÇ °æ¿ì ½ÇÇàµÇ´Â ÄÚµåÀÌ´Ù.

		*ÀÖÀ»¼ö ÀÖ´Â »óŵé
			¼­¹ö/Ŭ¶óÀ̾ðÆ®°¡ °áÁ¤µÇ±âÀü.. ¸í·É ´ë±â»óÅÂ
				(Á¾·á/¼­¹ö½ÃÀÛ/Ŭ¶óÀ̾ðÆ® ½ÃÀÛµîÀÇ ¸í·ÉÀÌ ¿Ã¼ö ÀÖ´Ù.)

			¼­¹ö·Î ½ÇÇàµÇ¾î ¼­¹ö ¸ÞÅ© ¼³Á¤¿¡ ´ëÇÑ µ¥ÀÌŸ¸¦ ±â´Ù¸®´Â »óÅÂ
				(CreateSession°¡ ½ÇÇàµÈ »óÅÂÀÌ´Ù.)
			¼­¹ö·Î ½ÇÇàµÇ¾î Botµé¿¡ ´ëÇÑ Á¤º¸¸¦ ±â´Ù¸®´Â »óÅÂ
				(Ŭ¶óÀ̾ðÆ®ÀÇ Âü¿©´Â Ŭ¶óÀ̾ðÆ®¿Í ¼­¹ö°£¿¡ ÀÚµ¿À¸·Î ÀÌ·ç¾îÁø´Ù.)
			¼­¹ö·Î ½ÇÇàµÇ¾î Launch¸¦ ±â´Ù¸®´Â »óÅÂ

			==>Ŭ¶óÀ̾ðÆ®´Â ½ÇÇàÁï½Ã µ¥ÀÌŸµéÀÌ Àü´ÞµÇ¹Ç·Î ´ë±â»óÅ°¡ ¾ø´Ù.

		==>°¢°¢ÀÇ »óŸ¦ Á¤ÀÇÇÏ°í °¢ »óÅ¿¡ ¸Â´Â 󸮸¦ ÇØÁÖ¸é µÈ´Ù.
		switch(state){
		}
		*/
#if !defined(CTCL_LAUNCHER)
        CSendFile* pSF;
        pSF = m_SFM_Send.GetHead();
        while(pSF) {
            pSF->Check();
            pSF = pSF->m_pNext;
        }
        if (g_nMech4Comm == 0) {
            pSF = m_SFM_Recv.GetHead();
            if (pSF) {
                extern bool _stdcall CTCL_DoMissionReplay(const char* pcszFile);
                if (CTCL_DoMissionReplay(pSF->m_strHost)) {
                    m_SFM_Recv.Cut(pSF);
                    m_SFM_Done.AddTail(pSF);
                }
            }
        }
#endif // !defined(CTCL_LAUNCHER)
    }
#if !defined(CTCLS_EXPORTS)
    // Mech4 only...
    if (g_nMech4Comm) {
        DoMech4Comm();
    }
#endif // !defined(CTCLS_EXPORTS)
    SingleStep();
}
#if !defined(CTCLS_EXPORTS)
void CCTCLManager::DoMech4Comm()
{
	//$$COOP
    ASSERT(g_nMech4Comm);
    if (CTCL_IsConsole()) {
        int i, nMech4CommOld = g_nMech4Comm;
        SPlayerInfo& SVR_PI = g_aPlayerInfos[g_nServer];
        const CTeslaInfo& SVR = m_aTIs.GetAt(SVR_PI.m_nLevelOrTesla);
        CSOC_Server& SOCGame = SVR.GetGameSOC();

        for(i = 0; g_nMech4Comm && (i < g_nPlayerInfos); i++) {
            SPlayerInfo& pi = g_aPlayerInfos[i];
            if (!pi.m_bBot) {
                CTeslaInfo& ti = m_aTIs.GetAt(pi.m_nLevelOrTesla);
                CSOC_Server& soc = ti.GetGameSOC();
                if (soc.GetConnectionState() == 1) {
                    if (g_nMech4Comm == 1) {
                        soc.m_nGameReturn = _EGR_NoError;
                    } else {
                        switch(soc.m_nGameReturn) {
                        case _EGR_Connected: //newly connected
                        case _EGR_ErrCreateSession:
                        case _EGR_ErrJoinSession:
                            g_nMech4Comm = 0;
                            break;
                        }
                    }
                } else {
                    g_nMech4Comm = 0;
                }
            }
        }
        switch(g_nMech4Comm)
        {
        case 0: // all error goes to here!!!
            if (nMech4CommOld != 1) {
                for(i = 0; i < g_nPlayerInfos; i++) {
                    SPlayerInfo& pi = g_aPlayerInfos[i];
                    if (!pi.m_bBot) {
                        CTeslaInfo& ti = m_aTIs.GetAt(pi.m_nLevelOrTesla);
                        CSOC_Server& soc = ti.GetGameSOC();
                        if (soc.GetConnectionState() == 1) {
                            // error to main screen...
                            soc.DoSendCmdWOP(C_ErrorStartGame);
                        }
                    }
                }
            }
            break;
        case 1:
		    //¼­¹ö/Ŭ¶óÀ̾ðÆ®·Î¼­ ½ÇÇàÁغñÇϵµ·Ï ¸í·ÉÀ» Àü´ÞÇÑ´Ù.
		    //¶ÇÇÑ ¼­¹ö¸¦ ½ÇÇàÇϴµ¥ ÇÊ¿äÇÑ ¸ðµç ÆĶó¹ÌÅ͵µ ÇÔ²² Àü´ÞÇÑ´Ù.
            for(i = 0; i < g_nPlayerInfos; i++) {
                SPlayerInfo& pi = g_aPlayerInfos[i];
                if (!pi.m_bBot) {
                    CTeslaInfo& ti = m_aTIs.GetAt(pi.m_nLevelOrTesla);
                    CSOC_Server& soc = ti.GetGameSOC();
                    if (&soc) {
                        soc.DoSendX("BBnnxBsDWwsnnDBBxx", C_ReadyStartGame, (i == g_nServer) ? 1: 0, g_nTeslas, g_nPlayerInfos - g_nTeslas - 1, &m_aNMP.GetAt(0), m_aNMP.GetSize(),
                            pi.m_bTeam, pi.m_szName, pi.m_nMechIndex, pi.m_fileID, pi.m_recordID, pi.m_szMech, pi.m_nTeamOrSkin, pi.m_nDecal, SVR.m_ulAddr,
                            !!g_nPrintOut, !!g_nMissionReview, &g_guidGameDatas, sizeof(g_guidGameDatas), &g_SysTime, sizeof(g_SysTime));
                    }
                }
            }
            g_nMech4Comm = 2;
            break;
        case 2:
            for(i = 0; i < g_nPlayerInfos; i++) {
                SPlayerInfo& pi = g_aPlayerInfos[i];
                if (!pi.m_bBot) {
                    CTeslaInfo& ti = m_aTIs.GetAt(pi.m_nLevelOrTesla);
                    CSOC_Server& soc = ti.GetGameSOC();
                    if (soc.m_nGameReturn != _EGR_PreparingStarted) {
                        break;
                    }
                }
            }
            if (i == g_nPlayerInfos) {
		        // Botµé¿¡ ´ëÇÑ Á¤º¸¸¦ ¸ðµÎ Çѵ¥ ¹­¾î¼­ º¸³½´Ù.
                CPacket pak(&SVR.GetGameSOC());

                pak.Assemble("B", C_BOTS);
                for(i = 0; i < g_nPlayerInfos; i++) {
                    if (i != g_nServer) { // ¿ø·¡ Bot¸¸ Áö±ÝÀº ¼­¹ö¸¦ Á¦¿ÜÇÑ ÀüºÎ...
                        SPlayerInfo& pi = g_aPlayerInfos[i];
                        pak.Assemble("BnsDWwsnn", pi.m_bBot, pi.m_nLevelOrTesla, pi.m_szName, pi.m_nMechIndex, pi.m_fileID, pi.m_recordID, pi.m_szMech, pi.m_nTeamOrSkin, pi.m_nDecal);
                    }
                }

                SOCGame.DoSend(pak);
                g_nMech4Comm = 4;
            }
            break;
        case 4:
		    // °ÔÀÓÀÌ ¼º°øÀûÀ¸·Î ¸¸µé¾îÁö¸é ¼­¹ö¿Í Ŭ¶óÀ̾ðÆ®µéÀÇ Mech¿¡ ´ëÇÑ Á¤º¸µéÀ» SetÇÑ´Ù...
            if (SOCGame.m_nGameReturn == _EGR_OkCreateSession) {
                for(i = 0; i < g_nPlayerInfos; i++) {
                    if (i != g_nServer) { // ¼­¹ö´Â ÀÌ¹Ì SetMech¿¡ ÁøÀÔÇÑ »óÅÂ...
                        SPlayerInfo& pi = g_aPlayerInfos[i];
                        if (!pi.m_bBot) {
                            CTeslaInfo& ti = m_aTIs.GetAt(pi.m_nLevelOrTesla);
                            CSOC_Server& soc = ti.GetGameSOC();
                            soc.DoSendCmdWOP(C_SetMechs);
                        }
                    }
                }
                g_nMech4Comm = 6;
            }
            break;
        case 6:
		    //¸ðµç Ŭ¶óÀ̾ðµåµéÀÌ ¼­¹ö¿¡ Âü¿©Çϱ⸦ ±â´Ù¸°´Ù.<==ÀÌ ÀÀ´äÀº ¼­¹ö·Î ºÎÅÍ ¾òÀ» ¼ö ÀÖ´Ù.
		    //Âü¿©°¡ ¸ðµÎ ³¡³µÀ¸¸é, ¼­¹ö·Î ÇÏ¿©±Ý °ÔÀÓÀ» Launch½ÃÅ°µµ·Ï ÇÑ´Ù.
            if (SOCGame.m_nGameReturn == _EGR_OkLaunchReady) {
                g_nMech4Comm = 9;
            }
            break;
        case 9:
            // wait...
            break;
        case 10:
            SOCGame.DoSendX("B", C_DoLaunch);
            g_nMech4Comm = 0;
            break;
        }
    } else if (g_bIsServer) { // server
        switch(g_nMech4Comm)
        {
		case -1:
			g_nMech4Comm = +1;
			break;
		case -3:
			g_nMech4Comm = -2;
			break;
		case -2:
			CTCL_StartGame(TRUE);
			break;
        case 1:
            CTCL_DoCreateGame();
            break;
        case 2: // wait SendRequestConnectionMessage
            CTCL_CheckNetConnectedToServer();
            break;
		case 3:
			CTCL_SetMissionParams();
			break;
        case 5:
			CTCL_SetMechs();
			break;
        case 7:
            CTCL_CheckClientReady();
            break;
        case 8:
            CTCL_CheckServerReady();
            break;
        case 9:
            // wait... load
            break;
        case 10:
            // wait... C_DoLaunch
            break;
        case 11:
            // wait... launch
            break;
        }
    } else { // clients
        switch(g_nMech4Comm)
        {
        case 1:
            CTCL_CheckJoinGame();
            break;
        case 2: // wait SendRequestConnectionMessage
            CTCL_CheckNetConnectedToServer();
            break;
		case 4:
			CTCL_CheckMissionParams();
			break;
        case 5:
			CTCL_SetMechs();
			break;
        case 7:
            CTCL_CheckClientReady();
            break;
        }
    }
}

void CCTCLManager::SaveNMP(const void* p, int nSize)
{
    m_aNMP.SetSize(nSize);
    BYTE* p2 = &m_aNMP.GetAt(0);
    if (nSize > 0) {
        memcpy(p2, p, nSize);
    }
    m_aNMP.FreeExtra();
}

void* CCTCLManager::LoadNMP(int& nSize)
{
    //if (g_bIsServer) {
        nSize = m_aNMP.GetSize();
        if (nSize > 0) {
            return &m_aNMP.GetAt(0);
        }
    //}

    return NULL;
}
#if !defined(CTCL_LAUNCHER)
void CCTCLManager::SendFile(const SYSTEMTIME& SysTime, const GUID& guid, int nType)
{
    CSendFile* pSF = new CSendFile(SysTime, guid, nType);
    m_SFM_Send.AddTail(pSF);
    pSF->Check();
}

bool CCTCLManager::DoReprintOrCheck(bool bRealPrint)
{
    if (this) {
        CSendFile* pSFFound = NULL;
        CSendFile* pSF = m_SFM_Done.GetHead();
        while(pSF) {
            if (pSF->m_nType == 0) {
                pSFFound = pSF;
                if (!bRealPrint)
                    break;
            }
            pSF = pSF->m_pNext;
        }
        if (pSFFound) {
            if (bRealPrint) {
                pSF = pSFFound;

                HWND hWndPrint = FindWindow(NULL, "mw4print");
                if (hWndPrint) {
                    MW4PRINT_COPYDATASTRUCT cd;

                    GetFileName4GUID(cd.m_szFile, pSF->m_strHost, g_pcszGameDataSavePath, g_pcszGameDataExtPR, pSF->m_guid);
                    cd.dwData = MW4PRINT_COPYDATA_META;
                    cd.cbData = sizeof(cd) - sizeof(COPYDATASTRUCT);
                    cd.lpData = &cd.m_GUID;
                    cd.m_GUID = GUID_NULL;
                    if (::SendMessage(hWndPrint, WM_COPYDATA, (WPARAM)hWindow, (LPARAM)&cd) == 1) {
                        return true;
                    }
                }
                return false;
            } else {
                return true;
            }
        }
    }

    return false;
}

bool CCTCLManager::IsPendingMissionReplayRequest() const
{
    CSendFile* pSF = m_SFM_Recv.GetHead();
    while(pSF) {
        if (pSF->m_nType == 1)
            return true;
        pSF = pSF->m_pNext;
    }

    return false;
}
#endif // !defined(CTCL_LAUNCHER)
#endif // !defined(CTCLS_EXPORTS)
int CTCL_API CTCL_GetType()
{
    return g_nCTCLType;
}

BOOL CTCL_API CTCL_IsNone()
{
    return g_nCTCLType == _ECTCL_None;
}

BOOL CTCL_API CTCL_IsConsole()
{
    return g_nCTCLType == _ECTCL_Console;
}

bool CTCL_API CTCL_IsCOOP()
{
#if defined(CTCL_LAUNCHER)
    return false;
#else // !defined(CTCL_LAUNCHER)
    return g_bCOOP;
#endif // defined(CTCL_LAUNCHER)
}

BOOL CTCL_API CTCL_IsConsoleOrCOOP()
{
#if defined(CTCL_LAUNCHER)
    return g_nCTCLType == _ECTCL_Console;
#else // !defined(CTCL_LAUNCHER)
    return (g_nCTCLType == _ECTCL_Console) || g_bCOOP;
#endif // defined(CTCL_LAUNCHER)
}

BOOL CTCL_API CTCL_IsConsoleX()
{
    return (g_nCTCLType == _ECTCL_Game) || (g_nCTCLType == _ECTCL_CameraShip);
}

int CTCL_API CTCL_GetTeslaCountAll()
{
    ASSERT(CTCL_IsConsoleOrCOOP());
    if (g_pCTCLManager)
    return g_pCTCLManager->m_aTIs.GetSize();
    return 0;
}

int CTCL_API CTCL_GetTeslaCount()
{
    ASSERT(CTCL_IsConsoleOrCOOP());
    if (g_pCTCLManager)
    return g_pCTCLManager->m_aTIs.GetSize() - g_pCTCLManager->m_aTIs.m_nCameraShips;
    return 0;
}
#if !defined(CTCL_LAUNCHER)
TESLA_HANDLE CTCL_API CTCL_GetTeslaInfo(int nIndex, STeslaInfo& TI)
{
    ASSERT(CTCL_IsConsole());
    if ((0 <= nIndex) && (nIndex < g_pCTCLManager->m_aTIs.GetSize())) {
        CTeslaInfo& ti = g_pCTCLManager->m_aTIs.GetAt(nIndex);
        TI.m_bCameraShip = ti.m_bCameraShip;
        TI.m_ulAddr = ti.m_ulAddr;
        TI.m_pcsz = ti;
        TI.m_nLauncherConnection = ti.m_2Launcher.GetConnectionState();
        TI.m_nConnection2 = ti.GetGameSOC().GetConnectionState();

        TI.m_nApplType = ti.m_nApplType;
        TI.m_nApplState = ti.m_nApplState;
        TI.m_nGameState = ti.m_nGameState;
        TI.m_nGameTime = ti.m_nGameTime;
        TI.m_nGameIsServer = ti.m_nGameIsServer;
        if (ti.m_2Launcher.m_bMissionReview) {
            if (g_pCTCLManager->IsPendingMissionReplayRequest()) {
                if ((ti.m_nApplType != _EAT_None) && (ti.m_nApplState == _EAS_Launched)) {
                    if (TI.m_nGameState == _EGS_Idle) {
                        TI.m_nGameState = _EGS_Preparing;
                    } else {
                    }
                } else {
                }
            }
        }

        return (TESLA_HANDLE)&ti;
    }

    return (TESLA_HANDLE)NULL;
}

int CTCL_API CTCL_InviteCOOP(int nTimeInvite, int& nYes, int& nNo, int& nProcessings)
{
    ASSERT(CTCL_IsConsoleOrCOOP());

    int i, nTesla = CTCL_GetTeslaCountAll();

    int nTotal = 0;
    nYes = nNo = nProcessings = 0;

    for(i = 0; i < nTesla; i++)
    {
        CTeslaInfo& ti = g_pCTCLManager->m_aTIs.GetAt(i);
        CSOC_Server& SOC = ti.GetGameSOC();
        CInviteCOOP& COOP = ti.m_COOP;
        if (SOC.GetConnectionState() == +1) {
            if (nTimeInvite == -999) {
                if ((COOP.m_nTimeInvite != -999) || (COOP.m_nResult != -1)) {
                    if (COOP.m_nTimeInvite != -999) {
                        COOP.Clear();
                        COOP.m_nTimeInvite = -999;
                    }
                    SOC.DoSendX("Bnxn", C_InviteCOOP, nTimeInvite, &COOP.m_guidGameData, sizeof(GUID), 0);
                }
                nTotal++;
            } else if (nTimeInvite) {
                bool bInvite = false;

                if (nTimeInvite < 0) {
                    // invite cameraship : -1 1st-camera, -2 2nd camera...
                    if (ti.m_bCameraShip) {
                        if (nTimeInvite == -(i - CTCL_GetTeslaCount()+ 1)) {
                            bInvite = true;
                        }
                    }
                } else {
                    // invite players
                    if (!ti.m_bCameraShip)
                        bInvite = true;
                }
                if (bInvite) {
                    if ((COOP.m_nTimeInvite == nTimeInvite) && (memcmp(&COOP.m_guidGameData, &g_guidGameDatas, sizeof(GUID)) == 0)) {
                        if ((COOP.m_nResult == 0) || (COOP.m_nResult == 1)) {
                            SOC.DoSendX("Bnxn", C_InviteCOOP, nTimeInvite, &COOP.m_guidGameData, sizeof(GUID), 0);
                            if (COOP.m_nResult == 1)
                                nProcessings++;
                        } else {
                            ASSERT((COOP.m_nResult == 2) || (COOP.m_nResult == 3));
                            if (COOP.m_nResult == 2)
                                nNo++;
                            else
                                nYes++;
                        }
                    } else {
                        COOP.Clear();
                        COOP.m_nTimeInvite = nTimeInvite;
                        //COOP.m_nResult = 0;
                        //COOP.m_nResultAccepted = 0;
                        memcpy(&COOP.m_guidGameData, &g_guidGameDatas, sizeof(GUID));
                    }
                    nTotal++;
                }
            } else {
                COOP.Clear();
                nTotal++;
            }
        } else {
            COOP.Clear();
        }
    }

    return nTotal; // nTesla;
}
#endif // !defined(CTCL_LAUNCHER)
const char* CTCL_API CTCL_GetTeslaName(int nIndex)
{
    ASSERT(CTCL_IsConsole());
    return g_pCTCLManager->m_aTIs.GetAt(nIndex).String();
}

int CTCL_API CTCL_OrderAppl(int nIndex, int nOrder, int nParam)
{
    int nRet = 0;

    if ((0 <= nIndex) && (nIndex < g_pCTCLManager->m_aTIs.GetSize())) {
        CTeslaInfo& ti = g_pCTCLManager->m_aTIs.GetAt(nIndex);
        if (100 <= nOrder) {
            if (ti.m_2Launcher.GetConnectionState() == +1) {
                ti.m_2Launcher.DoSendX("BBDB", C_OrderAppl, nOrder, nParam, ti.m_bCameraShip);
                nRet = 1;
            }
        } else {
            CSOC_Server& SOC = ti.GetGameSOC();
            if (SOC.GetConnectionState() == +1) {
                SOC.DoSendX("BBDB", C_OrderAppl, nOrder, nParam, ti.m_bCameraShip);
                nRet = 1;
            }
        }
    }

    return nRet;
}
#if !defined(CTCLS_EXPORTS)
void CTCL_API CTCL_DoSendGameReturn(int nValue)
{
    CSOC& SOC = *g_pCTCLManager->FindSOC(0);

    if (SOC.GetConnectionState() == 1)
        SOC.DoSendX("Bn", S_GameReturn, nValue);
}

void CTCL_API CTCL_SaveNMP(const void* p, int nSize)
{
    g_pCTCLManager->SaveNMP(p, nSize);
}

void* CTCL_API CTCL_LoadNMP(int& nSize)
{
    return g_pCTCLManager->LoadNMP(nSize);
}
#if !defined(CTCL_LAUNCHER)
void CTCL_API CTCL_SendFile(const SYSTEMTIME& SysTime, const GUID& guid, int nType)
{
    g_pCTCLManager->SendFile(SysTime, guid, nType);
}

bool CTCL_API CTCL_DoReprintOrCheck(bool bRealPrint)
{
    return g_pCTCLManager->DoReprintOrCheck(bRealPrint);
}

void CTCL_API CTCL_SetGameStateAsIdle()
{
    CSendFile* pSF;

    pSF = g_pCTCLManager->m_SFM_Recv.GetHead();
    while(pSF) {
        if (pSF->m_nType == 1) {
            CTCL_SetGameState(_EGS_Preparing);
            return;
        }
        pSF = pSF->m_pNext;
    }

    CTCL_SetGameState(_EGS_Idle);
}
#endif // !defined(CTCL_LAUNCHER)
#endif // !defined(CTCLS_EXPORTS)