Cyd
2b8ca921cb
Complete disaster-recovery snapshot: engine/game source, game data assets, VC6 toolchain + DX SDKs, build outputs, deployed game, and _UNUSED archive. Large binaries in Git LFS; text preserved byte-for-byte (core.autocrlf=false, no eol attributes). See RECOVERY.md for the one-clone rebuild procedure.
1990 lines
61 KiB
C++
1990 lines
61 KiB
C++
// 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)
|