void KG3DAnimationComposer::SetSkeleton(KG3DSkeleton* pSkeleton)
{
HRESULT hrResult = E_FAIL;
DWORD dwBoneNum = 0;
m_SkeletonInfo.clear();
m_pSkeleton = pSkeleton;
KG_PROCESS_SUCCESS(!m_pSkeleton);
dwBoneNum = (DWORD)m_pSkeleton->GetNumBones();
m_SkeletonInfo.resize(dwBoneNum);
KG_DELETE_ARRAY(m_pWorldResult);
m_pWorldResult = new D3DXMATRIX[dwBoneNum];
KG_PROCESS_ERROR(m_pWorldResult);
Exit1:
hrResult = S_OK;
Exit0:
if (FAILED(hrResult))
{
KG_DELETE_ARRAY(m_pWorldResult);
}
}
BOOL KLevelDropList::UnInit(void)
{
KG_DELETE_ARRAY(m_LevelDropList);
m_dwSize = 0;
return true;
}
BOOL KDoodadClassList::UnInit(void)
{
KG_DELETE_ARRAY(m_DoodadClassList);
m_dwMaxClassID = 0;
return true;
}
HRESULT KG3DRTSInfoCollector::CreateStore(KG3DModel *pModel)
{
HRESULT hrResult = E_FAIL;
HRESULT hrRetCode = E_FAIL;
int nNumBones = 0;
KG_PROCESS_ERROR(pModel);
hrRetCode = pModel->GetNumBones(&nNumBones);
KG_COM_PROCESS_ERROR(hrRetCode);
KG_PROCESS_ERROR(nNumBones > 0);
ASSERT(!m_RTSData);
m_RTSData = new RTS[nNumBones];
KGLOG_PROCESS_ERROR(m_RTSData);
m_dwSize = static_cast<INT>(nNumBones);
hrResult = S_OK;
Exit0:
if (FAILED(hrResult))
{
KG_DELETE_ARRAY(m_RTSData);
}
return hrResult;
}
BOOL KLevelMoneyDropList::UnInit(void)
{
KG_DELETE_ARRAY(m_LevelMoneyDropList);
m_dwSize = 0;
return TRUE;
}
KG_HttpClient::~KG_HttpClient(void)
{
KG_DELETE_ARRAY(m_pResponseBuffer);
ASSERT(m_PostList.empty());
ASSERT(!m_hInternetSession);
ASSERT(!m_hInternetConnection);
ASSERT(!m_hHttpRequest);
}
KG3DAnimationComposer::~KG3DAnimationComposer()
{
for(size_t i = 0; i < m_TweenTimeInfo.size(); i++)
{
m_TweenTimeInfo[i].UnInit();
}
SAFE_DELETE(m_pCollector);
KG_DELETE_ARRAY(m_pWorldResult);
}
HRESULT KG3DAnimationComposer::TweenTimeInfo::Init(DWORD dwNumBones)
{
HRESULT hrResult = E_FAIL;
KG_PROCESS_ERROR(dwNumBones);
pTweenStartInfo = new RTS[dwNumBones];
KGLOG_PROCESS_ERROR(pTweenStartInfo);
pTweenEndInfo = new RTS[dwNumBones];
KGLOG_PROCESS_ERROR(pTweenEndInfo);
this->dwNumBones = dwNumBones;
hrResult = S_OK;
Exit0:
if (FAILED(hrResult))
{
KG_DELETE_ARRAY(pTweenEndInfo);
KG_DELETE_ARRAY(pTweenStartInfo);
}
return hrResult;
}
int KG_HttpClient::AddPostParam(const TCHAR cszParamName[], const TCHAR cszValue[], KG_POST_PARAM_TYPE ePostParamType /* = eNormal */)
{
int nResult = false;
DWORD dwParamNameLen = 0;
DWORD dwValueLen = 0;
KG_POST_PARAM PostParam;
memset(&PostParam, 0, sizeof(PostParam));
KGLOG_PROCESS_ERROR(ePostParamType == eNormal || ePostParamType == eBinaryFile);
dwParamNameLen = (DWORD)_tcslen(cszParamName);
KGLOG_PROCESS_ERROR(dwParamNameLen > 0);
dwValueLen = (DWORD)_tcslen(cszValue);
KGLOG_PROCESS_ERROR(dwValueLen >= 0);
PostParam.eType = ePostParamType;
PostParam.pParamName = new TCHAR[dwParamNameLen + 1];
strncpy(PostParam.pParamName, cszParamName, dwParamNameLen);
PostParam.pParamName[dwParamNameLen] = '\0';
PostParam.pValue = new TCHAR[dwValueLen + 1];
strncpy(PostParam.pValue, cszValue, dwValueLen);
PostParam.pValue[dwValueLen] = '\0';
m_PostList.push_back(PostParam);
nResult = true;
Exit0:
if (!nResult)
{
KG_DELETE_ARRAY(PostParam.pParamName);
KG_DELETE_ARRAY(PostParam.pValue);
}
return nResult;
}
BOOL KPlayerServer::UnInit(void)
{
for (int nConnIndex = 0; nConnIndex < m_nMaxConnection; nConnIndex++)
{
if (m_ConnectionDataList[nConnIndex].piSocketStream)
{
Shutdown(nConnIndex);
}
}
DumpPakStat();
m_SocketServerAcceptor.UnInit(NULL);
KG_DELETE_ARRAY(m_pSocketEventArray);
m_nSocketEventCount = 0;
KG_DELETE_ARRAY(m_ConnectionDataList);
m_nMaxConnection = 0;
return true;
}
void KItemManager::UnInit()
{
m_EnchantLib.UnInit();
if (m_pItemLib)
{
for (int i = 0; i < CURRENT_ITEM_VERSION + 1; i++)
{
m_pItemLib[i].UnInit();
}
KG_DELETE_ARRAY(m_pItemLib);
}
}
void Jx3RoleItemCompensateToActivityTable::UnInit()
{
if (m_FileInitFlag)
{
fclose(m_pOutFile);
m_pOutFile = NULL;
m_FileInitFlag = false;
}
KG_COM_RELEASE(m_piTableBrowser);
if (m_nInitBackupBrowserEnvironmentFlag)
{
KGD_UnInitBackupBrowserEnvironment(NULL);
m_nInitBackupBrowserEnvironmentFlag = false;
}
KG_DELETE_ARRAY(m_pucData);
}
HRESULT KG3DMesh::Helper_LoadSocketFromBuffer(KG3DBufferReader *pBufferReader)
{
HRESULT hrResult = E_FAIL;
int nRetCode = false;
TCHAR *pszParentBone = NULL;
ASSERT(pBufferReader);
nRetCode = pBufferReader->Read(&m_dwNumSocket, sizeof(DWORD));
KGLOG_PROCESS_ERROR(nRetCode);
m_pSockets = new Socket1[m_dwNumSocket];
KG_PROCESS_ERROR(m_pSockets);
for (DWORD i = 0; i < m_dwNumSocket; i++)
{
ASSERT(sizeof(m_pSockets[i].strSocketName) >= sizeof(TCHAR) * MAX_BONE_NAME_LENGTH);
nRetCode = pBufferReader->Read(m_pSockets[i].strSocketName, sizeof(TCHAR) * MAX_BONE_NAME_LENGTH);
KGLOG_PROCESS_ERROR(nRetCode);
m_pSockets[i].strSocketName[countof(m_pSockets[i].strSocketName) - 1] = '\0';
strlwr(m_pSockets[i].strSocketName);
nRetCode = pBufferReader->ReferenceRead((void **)&pszParentBone, sizeof(TCHAR) * MAX_BONE_NAME_LENGTH);
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = pBufferReader->Read(&m_pSockets[i].matMatrixOffset, sizeof(D3DXMATRIX));
KGLOG_PROCESS_ERROR(nRetCode);
int nParentIndex = FindBone(pszParentBone);
KGLOG_PROCESS_ERROR((nParentIndex >= 0) && "can't find parent bone for socket");
m_pSockets[i].dwParentBoneIndex = nParentIndex;
D3DXMatrixMultiply(&m_pSockets[i].matCurMatrix, &m_pSockets[i].matMatrixOffset, &m_pBoneInfo[nParentIndex].CurMatrix);
}
hrResult = S_OK;
Exit0:
if (FAILED(hrResult))
{
KG_DELETE_ARRAY(m_pSockets);
m_dwNumSocket = 0;
}
return hrResult;
}
BOOL KItemManager::Init()
{
BOOL bResult = false;
BOOL bRetCode = false;
BOOL bEnchantLibInitFlag = false;
int nItemLibInitCount = 0;
m_pItemLib = new KItemLib[CURRENT_ITEM_VERSION + 1];
KGLOG_PROCESS_ERROR(m_pItemLib);
for (int i = 0; i < CURRENT_ITEM_VERSION + 1; i++)
{
bRetCode = m_pItemLib[i].Init(i);
KGLOG_PROCESS_ERROR(bRetCode);
++nItemLibInitCount;
}
bRetCode = m_EnchantLib.Init();
KGLOG_PROCESS_ERROR(bRetCode);
bEnchantLibInitFlag = true;
bResult = true;
Exit0:
if (!bResult)
{
if (bEnchantLibInitFlag)
{
m_EnchantLib.UnInit();
bEnchantLibInitFlag = false;
}
for (int i = 0; i < nItemLibInitCount; i++)
{
m_pItemLib[i].UnInit();
}
KG_DELETE_ARRAY(m_pItemLib);
}
return bResult;
}
HRESULT KG3DMesh::CreateBspFile()
{
HRESULT hrResult = E_FAIL;
HRESULT hrRetCode = E_FAIL;
int nRetCode = false;
TCHAR szBSPPathName[MAX_PATH];
void *pvVerticesBuffer = NULL;
WORD* pIndexBuffer = NULL;
D3DXVECTOR3 *pPos = NULL;
DWORD *pdwFaceIndex = NULL;
DWORD dwStride = 0;
DWORD i = 0;
DWORD dwNumFaces = 0;
DWORD dwNumVertices = 0;
DWORD dwStartTime = timeGetTime();
LPD3DXMESH piMesh = m_ppMeshes[SMBT_NORMAL];
KG3DBsp *pBSP = NULL;
KGLOG_PROCESS_ERROR(piMesh);
dwStride = piMesh->GetNumBytesPerVertex();
dwNumVertices = piMesh->GetNumVertices();
dwNumFaces = piMesh->GetNumFaces();
KG_PROCESS_SUCCESS(dwNumFaces < 256);
pPos = new D3DXVECTOR3[dwNumVertices];
KG_ASSERT_EXIT(pPos);
pdwFaceIndex = new DWORD[dwNumFaces * 3];
KG_ASSERT_EXIT(pdwFaceIndex);
hrRetCode = piMesh->LockVertexBuffer(D3DLOCK_READONLY, (void **)&pvVerticesBuffer);
KGLOG_COM_PROCESS_ERROR(hrRetCode);
hrRetCode = piMesh->LockIndexBuffer(D3DLOCK_READONLY, (void **)&pIndexBuffer);
KGLOG_COM_PROCESS_ERROR(hrRetCode);
for (i = 0; i < dwNumVertices; ++i)
{
pPos[i] = *(D3DXVECTOR3 *)(((BYTE *)pvVerticesBuffer) + dwStride * i);
}
for (i = 0; i < dwNumFaces * 3; ++i)
{
pdwFaceIndex[i] = pIndexBuffer[i];
}
// -------------------------- create BSP --------------------------
hrRetCode = ChangePathExtName(m_scName.c_str(), "bsp", sizeof(szBSPPathName), szBSPPathName);
KGLOG_COM_PROCESS_ERROR(hrRetCode);
pBSP = new KG3DBsp;
KGLOG_PROCESS_ERROR(pBSP);
hrRetCode = pBSP->CreateFromMesh(dwNumVertices, dwNumFaces, pPos, pdwFaceIndex);
KGLOG_COM_PROCESS_ERROR(hrRetCode);
hrRetCode = pBSP->SaveToFile(szBSPPathName);
KGLOG_COM_PROCESS_ERROR(hrRetCode);
DWORD dwCost = timeGetTime() - dwStartTime;
if(dwCost > 500)
{
KGLogPrintf(
KGLOG_WARNING, "BSP %d %d Face %s",
dwCost, dwNumFaces, szBSPPathName
);
}
KG_DELETE(m_lpBsp); // recreate
m_lpBsp = pBSP;
pBSP = NULL;
Exit1:
hrResult = S_OK;
Exit0:
KG_DELETE(pBSP);
if (pIndexBuffer)
{
piMesh->UnlockIndexBuffer();
pIndexBuffer = NULL;
}
if (pvVerticesBuffer)
{
piMesh->UnlockVertexBuffer();
pvVerticesBuffer = NULL;
}
KG_DELETE_ARRAY(pdwFaceIndex);
KG_DELETE_ARRAY(pPos);
if(FAILED(hrResult))
{
KGLogPrintf(KGLOG_ERR, "%s 创建失败", szBSPPathName);
}
return hrResult;
}
HRESULT KG3DMesh::_Helper_LoadSkinInfoFromBuffer(KG3DBufferReader *pBufferReader)
{
HRESULT hrResult = E_FAIL;
int nRetCode = 0;
typedef char NAME_ARRAY[s_dwMaxChildBone][MAX_BONE_NAME_LENGTH];
struct _CHILD_NAME
{
DWORD dwChildCount;
NAME_ARRAY *pNames;
};
_CHILD_NAME *pChildNames = NULL;
ASSERT(pBufferReader);
m_dwNumBone = 0;
KG_DELETE_ARRAY(m_pmatReverseMatrix);
KG_DELETE_ARRAY(m_pBoneInfo);
nRetCode = pBufferReader->Read(&m_dwNumBone, sizeof(DWORD));
KGLOG_PROCESS_ERROR(nRetCode);
KGLOG_PROCESS_ERROR(m_dwNumBone < s_dwMaxBone);
KG_PROCESS_SUCCESS(m_dwNumBone == 0);
m_pmatReverseMatrix = new D3DXMATRIX[m_dwNumBone];
KG_PROCESS_ERROR(m_pmatReverseMatrix);
m_pBoneInfo = new BoneInfo1[m_dwNumBone];
KG_PROCESS_ERROR(m_pBoneInfo);
pChildNames = new _CHILD_NAME[m_dwNumBone];
KGLOG_PROCESS_ERROR(pChildNames);
//////////////////////////////////////////////////////////////////////////
for (DWORD i = 0; i < m_dwNumBone; i++)
{
//Read bone name
ASSERT(sizeof(m_pBoneInfo[i].strBoneName) >= sizeof(TCHAR) * MAX_BONE_NAME_LENGTH);
nRetCode = pBufferReader->Read(m_pBoneInfo[i].strBoneName, sizeof(TCHAR) * MAX_BONE_NAME_LENGTH);
KGLOG_PROCESS_ERROR(nRetCode);
m_pBoneInfo[i].strBoneName[countof(m_pBoneInfo[i].strBoneName)-1] = '\0';
strlwr(m_pBoneInfo[i].strBoneName);
//seek parent name, child info is enough to build the skeleton
nRetCode = pBufferReader->Seek(sizeof(TCHAR) * MAX_BONE_NAME_LENGTH, SEEK_CUR);
KGLOG_PROCESS_ERROR(nRetCode);
// child bone
nRetCode = pBufferReader->Read(&(pChildNames[i].dwChildCount), sizeof(DWORD));
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = pBufferReader->ReferenceRead(
(void **)&(pChildNames[i].pNames), sizeof(TCHAR) * MAX_BONE_NAME_LENGTH * pChildNames[i].dwChildCount
);
KGLOG_PROCESS_ERROR(nRetCode);
//
nRetCode = pBufferReader->Read(&m_pmatReverseMatrix[i], sizeof(D3DXMATRIX)); // MatrixOffset
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = pBufferReader->Seek(sizeof(D3DXMATRIX), SEEK_CUR); // MatrixOffsetBase_NoUse
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = pBufferReader->Read(&m_pBoneInfo[i].NumVerticesRef, sizeof(DWORD));
KGLOG_PROCESS_ERROR(nRetCode);
ASSERT(!m_pBoneInfo[i].VerticesIndexRef);
m_pBoneInfo[i].VerticesIndexRef = new DWORD[m_pBoneInfo[i].NumVerticesRef];
KGLOG_PROCESS_ERROR(m_pBoneInfo[i].VerticesIndexRef);
ASSERT(!m_pBoneInfo[i].VerticesWeightRef);
m_pBoneInfo[i].VerticesWeightRef = new float[m_pBoneInfo[i].NumVerticesRef];
KGLOG_PROCESS_ERROR(m_pBoneInfo[i].VerticesWeightRef);
nRetCode = pBufferReader->Read(m_pBoneInfo[i].VerticesIndexRef, sizeof(DWORD) * m_pBoneInfo[i].NumVerticesRef);
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = pBufferReader->Read(m_pBoneInfo[i].VerticesWeightRef, sizeof(float) * m_pBoneInfo[i].NumVerticesRef);
KGLOG_PROCESS_ERROR(nRetCode);
D3DXMatrixInverse(&m_pBoneInfo[i].CurMatrix, NULL, &m_pmatReverseMatrix[i]);
if (m_dwOptionEx & MESH_SAVE_BONEBBOX)
{
nRetCode = pBufferReader->Read(&m_pBoneInfo[i].BBoxScaleMatrix, sizeof(D3DXMATRIX));
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = pBufferReader->Read(&m_pBoneInfo[i].bBox.A, sizeof(D3DXVECTOR3));
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = pBufferReader->Read(&m_pBoneInfo[i].bBox.B, sizeof(D3DXVECTOR3));
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = pBufferReader->Read(&m_pBoneInfo[i].bBox.bInit, sizeof(BOOL));
KGLOG_PROCESS_ERROR(nRetCode);
}
}
// -------------------------- Build Skeleton --------------------------
for (DWORD i = 0; i < m_dwNumBone; i++)
{
m_pBoneInfo[i].dwNumChild = pChildNames[i].dwChildCount;
for (size_t j = 0; j < pChildNames[i].dwChildCount; ++j)
{
const char *pszChileName = (*(pChildNames[i].pNames))[j];
int nChildIndex = FindBone(pszChileName);
KGLOG_PROCESS_ERROR((nChildIndex >= 0) && "Can't find child bone");
m_pBoneInfo[i].dwChildIndex[j] = nChildIndex;
m_pBoneInfo[nChildIndex].dwParentIndex = i;
}
}
for (DWORD i = 0; i < m_dwNumBone; i++)
{
if (m_pBoneInfo[i].dwParentIndex == s_dwInvalidateIndex)
{
m_nBaseBoneID.push_back(i);
}
}
m_dwOption |= MESH_SKINED;
Exit1:
hrResult = S_OK;
Exit0:
KG_DELETE_ARRAY(pChildNames);
if (FAILED(hrResult))
{
KG_DELETE_ARRAY(m_pmatReverseMatrix);
KG_DELETE_ARRAY(m_pBoneInfo);
m_dwNumBone = 0;
}
return hrResult;
}
void KDoodadTemplateList::UnInit(void)
{
m_nDoodadTemplateCount = 0;
m_mapDoodadTemplateList.clear();
KG_DELETE_ARRAY(m_pDoodadTemplateList);
}
int KTgaBlockLoader::ReadUITex(LPCTSTR pcszUITex, int nLoadStyle, int nFindKind, int TgaInd, int nFrameNum)
{
int nResult = false;
int nRetCode = false;
int nPosed = 0;
int nIndexCanchangeable = 0;
KTga32 MyTga;
LPCTSTR pcszTga;
TCHAR szTgaName[MAX_PATH];
szTgaName[0] = _T('\0');
FILE *fpUiTex = NULL;
size_t uReadIn;
UITEXFILEHEADER UiTexFileHeader;
KAnimateBlock *pAnimate = NULL;
TCHAR szAnimate[MAX_PATH];
szAnimate[0] = _T('\0');
int nBufferSize = 0;
KTgaBlock *pBlock = NULL;
TCHAR szName[MAX_PATH];
TCHAR szFrameName[MAX_PATH];
szName[0] = _T('\0');
szFrameName[0] = _T('\0');
BYTE *pBuffer = NULL;
UITEXFRAMEDATASTRUCTURE FrameInfo;
std::vector<UITEXFRAMEDATASTRUCTURE> aFrameVector;
int i = 0;
int j = 0;
int k = 0;
switch(nLoadStyle)
{
case LOAD_AS_APPEND:
nPosed = false;
nIndexCanchangeable = true;
break;
case LOAD_AS_REPLACE:
nPosed = true;
nIndexCanchangeable = false;
break;
default:
ASSERT(0);
}
pcszTga = KTgaBlockLoader::GetSelf().GetTgaName();
_tcsncpy(szTgaName, pcszTga, sizeof(szTgaName) / sizeof(TCHAR));
nRetCode = MyTga.CreateFromFile((char *)szTgaName, TRUE);
KG_PROCESS_ERROR(nRetCode);
nRetCode = MyTga.ReadAllDataToSelfMemory();
KG_PROCESS_ERROR(nRetCode);
fpUiTex = fopen(pcszUITex, "rb");
KG_PROCESS_ERROR(fpUiTex);
uReadIn = fread(&UiTexFileHeader, sizeof(UiTexFileHeader), 1, fpUiTex);
KG_PROCESS_ERROR(uReadIn == 1);
aFrameVector.reserve(UiTexFileHeader.nFrameCount);
for (i = 0; i < UiTexFileHeader.nFrameCount; ++i)
{
uReadIn = fread(&FrameInfo, sizeof(FrameInfo), 1, fpUiTex);
FrameInfo.dwInfo = 0;
KG_PROCESS_ERROR(uReadIn == 1);
aFrameVector.push_back(FrameInfo);
}
k = 0;
for (i = 0; i < UiTexFileHeader.nAnimateCount; ++i)
{
int nAnimateFrameCount = 0;
int nThisAnimateFrame = 0;//¶¯»Ö¡ÐòºÅ
uReadIn = fread(&nAnimateFrameCount, sizeof(int), 1, fpUiTex);
KG_PROCESS_ERROR(uReadIn == 1);
LPTSTR pcszAnimate = NULL;
if (k < 0 || k >= m_aNewTgaTxtVector.size())
_sntprintf(szAnimate, sizeof(szAnimate) / sizeof(TCHAR), "%s:%s%d", pcszUITex, "Animate", i);
else
{
_tcsncpy(szAnimate, m_aNewTgaTxtVector[k].szTxtFile, sizeof(szAnimate)/sizeof(TCHAR));
pcszAnimate = _tcsrchr(szAnimate, _T('_'));
if(pcszAnimate)
*pcszAnimate = _T('\0');
}
pAnimate = KAnimateBlock::Create(szAnimate, nIndexCanchangeable, i);
k += nAnimateFrameCount;
KG_PROCESS_ERROR(pAnimate);
for (j = 0; j < nAnimateFrameCount; ++j)
{
uReadIn = fread(&nThisAnimateFrame, sizeof(int), 1, fpUiTex);
KG_PROCESS_ERROR(uReadIn == 1);
KG_PROCESS_ERROR(nThisAnimateFrame < UiTexFileHeader.nFrameCount);
aFrameVector[nThisAnimateFrame].dwInfo = 1;
if (nThisAnimateFrame >= 0 && nThisAnimateFrame < (int)m_aNewTgaTxtVector.size() && m_aNewTgaTxtVector[nThisAnimateFrame].nTextNum == nThisAnimateFrame)
_tcsncpy(szName, m_aNewTgaTxtVector[nThisAnimateFrame].szTxtFile, sizeof(szName)/sizeof(TCHAR));
else
_sntprintf(szName, sizeof(szName) / sizeof(TCHAR), "%s_%d", szAnimate, j);
szName[sizeof(szName) / sizeof(TCHAR) - 1] = _T('\0');
// if (KTgaManager::GetSelf().IsTgaExist(szName))
// continue;
while (KTgaManager::GetSelf().IsTgaExist(szName))
{
TCHAR szNewName[MAX_PATH];
TCHAR szRelName[MAX_PATH];
_tcscpy(szNewName, szName);
LPTSTR pszClip = _tcsrchr((LPTSTR)szNewName, _T('\\'));
if (pszClip)
{
LPTSTR pszTemp = _tcsrchr((LPTSTR)szNewName, _T('/'));
if (pszTemp)
pszClip = pszTemp;
}
if (pszClip)
pszClip++;
else
pszClip = szNewName;
_tcscpy(szRelName, pszClip);
*pszClip = _T('\0');
_tcscpy(pszClip, _T("(new)"));
_tcscat(pszClip, szRelName);
_tcscpy(szName, szNewName);
}
nBufferSize = aFrameVector[nThisAnimateFrame].nWidth * aFrameVector[nThisAnimateFrame].nHeight * 4;
KG_DELETE_ARRAY(pBuffer);
pBuffer = new BYTE[nBufferSize];
KG_PROCESS_ERROR(pBuffer);
MyTga.CopyRectBufferTo(
pBuffer, nBufferSize,
aFrameVector[nThisAnimateFrame].nLeft, aFrameVector[nThisAnimateFrame].nTop,
aFrameVector[nThisAnimateFrame].nWidth, aFrameVector[nThisAnimateFrame].nHeight
);
pBlock = KTgaBlock::CreateFromBuffer(
pBuffer, nBufferSize,
aFrameVector[nThisAnimateFrame].nWidth, aFrameVector[nThisAnimateFrame].nHeight,
aFrameVector[nThisAnimateFrame].nLeft, aFrameVector[nThisAnimateFrame].nTop,
nIndexCanchangeable, nThisAnimateFrame, nPosed, szName
);
KG_PROCESS_ERROR(pBlock);
if (nFindKind == FIND_ICON_FILE)
{
if (nThisAnimateFrame == TgaInd)
{
KIconBlock *pIcon = NULL;
LPCTSTR pcszFrameName = NULL;
_tcsncpy(szFrameName, pcszUITex, sizeof(szFrameName) / sizeof(szFrameName[0]));
pcszFrameName = _tcsrchr(szName, _T('\\'));
pcszFrameName++;
m_pIcon = KIconBlock::CreateFromBuffer(
pBuffer, nBufferSize, nFrameNum, TgaInd,
aFrameVector[i].nWidth, aFrameVector[i].nHeight,
szName, szFrameName
);
nRetCode = KIconManager::GetSelf().Append(m_pIcon);
KG_PROCESS_ERROR(nRetCode);
goto Exit1;
}
}
else
{
nRetCode = KTgaManager::GetSelf().Append(pBlock);
KG_PROCESS_ERROR(pBlock);
nRetCode = pAnimate->AppendFrame(szName);
KG_PROCESS_ERROR(nRetCode);
}
}
if (nFindKind == NOT_FIND_ICON_FILE)
{
nRetCode = KAnimateManager::GetSelf().Append(pAnimate);
KG_PROCESS_ERROR(nRetCode);
}
}
j = 0;
for (int i = 0; i < UiTexFileHeader.nFrameCount; ++i)
{
if (aFrameVector[i].dwInfo)
continue;
aFrameVector[i].dwInfo = 1;
if (i >= 0 && i < m_aNewTgaTxtVector.size() && m_aNewTgaTxtVector[i].nTextNum == i)
_tcsncpy(szName, m_aNewTgaTxtVector[i].szTxtFile, sizeof(szName)/sizeof(TCHAR));
else
_sntprintf(szName, sizeof(szName) / sizeof(TCHAR), "%s:%s%d", pcszUITex, "Frame", j);
szName[sizeof(szName) / sizeof(TCHAR) - 1] = _T('\0');
++j;
if (KTgaManager::GetSelf().IsTgaExist(szName))
continue;
nBufferSize = aFrameVector[i].nWidth * aFrameVector[i].nHeight * 4;
KG_DELETE_ARRAY(pBuffer);
if (nBufferSize == 0)
continue;
pBuffer = new BYTE[nBufferSize];
KG_PROCESS_ERROR(pBuffer);
MyTga.CopyRectBufferTo(
pBuffer, nBufferSize,
aFrameVector[i].nLeft, aFrameVector[i].nTop,
aFrameVector[i].nWidth, aFrameVector[i].nHeight
);
pBlock = KTgaBlock::CreateFromBuffer(
pBuffer, nBufferSize,
aFrameVector[i].nWidth, aFrameVector[i].nHeight,
aFrameVector[i].nLeft, aFrameVector[i].nTop,
nIndexCanchangeable, i, nPosed, szName
);
if (pBlock)
{
if (nFindKind == FIND_ICON_FILE)
{
if (i == TgaInd)
{
KIconBlock *pIcon = NULL;
LPCTSTR pcszFrameName = NULL;
_tcsncpy(szFrameName, pcszUITex, sizeof(szFrameName) / sizeof(szFrameName[0]));
pcszFrameName = _tcsrchr(szName, _T('\\'));
pcszFrameName++;
m_pIcon = KIconBlock::CreateFromBuffer(
pBuffer, nBufferSize, nFrameNum, TgaInd,
aFrameVector[i].nWidth, aFrameVector[i].nHeight,
szName, szFrameName
);
nRetCode = KIconManager::GetSelf().Append(m_pIcon);
KG_PROCESS_ERROR(nRetCode);
goto Exit1;
}
}
else
{
nRetCode = KTgaManager::GetSelf().Append(pBlock);
KG_PROCESS_ERROR(pBlock);
}
}
}
KG_DELETE_ARRAY(pBuffer);
Exit1:
nResult = true;
Exit0:
MyTga.Release();
if (!nResult)
{
if (nLoadStyle == LOAD_AS_REPLACE)
KSaveManager::GetSelf().Clear();
KTgaManager::GetSelf().Remove(pBlock);
KAnimateManager::GetSelf().Remove(pAnimate);
KG_COM_RELEASE(pBlock);
KG_COM_RELEASE(pAnimate);
}
KG_DELETE_ARRAY(pBuffer);
if (fpUiTex)
{
fclose(fpUiTex);
fpUiTex = NULL;
}
return nResult;
}
int Jx3RoleItemCompensateToActivityTable::Init()
{
int nResult = false;
int nRetCode = false;
int nTabFileInit = false;
int nLoadItemCount = 0;
ITabFile* piTabFile = NULL;
KG_SERVERINFO tempServerInfo;
KG_COMPENSATE_ITEM_INFO tempCompensateItemInfo;
m_pucData = NULL;
unUseDataSize = 0;
m_FileInitFlag = false;
m_pucData = new unsigned char[900000];
KGLOG_PROCESS_ERROR(m_pucData);
nRetCode = KGD_InitBackupBrowserEnvironment(NULL);
KGLOG_PROCESS_ERROR(nRetCode);
m_nInitBackupBrowserEnvironmentFlag = true;
piTabFile = g_OpenTabFile(KG_SEVERINFOLIST_FILE);
KGLOG_PROCESS_ERROR(piTabFile);
nTabFileInit = true;
for (int i = 2; i <= piTabFile->GetHeight(); i++)
{
nRetCode = piTabFile->GetString(i, "ZoneName", "", tempServerInfo.szZoneName, sizeof(tempServerInfo.szZoneName));
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = piTabFile->GetString(i, "ServerName", "", tempServerInfo.szServerName, sizeof(tempServerInfo.szServerName));
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = piTabFile->GetString(i, "LogServerName", "", tempServerInfo.szLogServerName, sizeof(tempServerInfo.szLogServerName));
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = piTabFile->GetString(i, "BackUpFilePath", "", tempServerInfo.szBackUpFilePath, sizeof(tempServerInfo.szBackUpFilePath));
KGLOG_PROCESS_ERROR(nRetCode);
m_ServerList.push_back(tempServerInfo);
}
if (nTabFileInit)
{
KG_COM_RELEASE(piTabFile);
nTabFileInit = false;
}
piTabFile = g_OpenTabFile(KG_COMPENSATEITEM_FILE);
KGLOG_PROCESS_ERROR(piTabFile);
nTabFileInit = true;
for (int i = 2; i <= piTabFile->GetHeight(); i++)
{
nRetCode = piTabFile->GetInteger(i, "ItemTabType", 0, &tempCompensateItemInfo.nTabType);
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = piTabFile->GetInteger(i, "ItemIndex", 0, &tempCompensateItemInfo.nIndex);
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = piTabFile->GetString(i, "ItemName", "", tempCompensateItemInfo.szItemName, sizeof(tempCompensateItemInfo.szItemName));
KGLOG_PROCESS_ERROR(nRetCode);
m_CompensateItemList.push_back(tempCompensateItemInfo);
m_CompensateItemCountList.push_back(0);
}
m_pOutFile = fopen("activity.txt", "w");
KGLOG_PROCESS_ERROR(m_pOutFile);
m_FileInitFlag = true;
// 判断是不是读入了16个道具
nLoadItemCount = m_CompensateItemList.size();
KGLOG_PROCESS_ERROR(nLoadItemCount == 16);
nResult = true;
Exit0:
if (!nResult)
{
if (m_FileInitFlag)
{
fclose(m_pOutFile);
m_pOutFile = NULL;
m_FileInitFlag = false;
}
}
if (nTabFileInit)
{
KG_COM_RELEASE(piTabFile);
nTabFileInit = false;
}
if (!nResult)
{
if (m_nInitBackupBrowserEnvironmentFlag)
{
KGD_UnInitBackupBrowserEnvironment(NULL);
m_nInitBackupBrowserEnvironmentFlag = false;
}
KG_DELETE_ARRAY(m_pucData);
}
return nResult;
}
int KDBTools::GetNextRecord(MYSQL_RES* pRecordSet, FIELD_INFO_VECTOR& refFieldInfoVector, bool& refbIsNoMoreRecodes)
{
int nResult = false;
int nRetCode = false;
// int nCreateBufferFlag = false;
MYSQL_ROW Row = NULL;
unsigned long *pulLengths = NULL;
unsigned uFieldCount = 0;
// unsigned uBufferSize = 0;
FIELD_INFO fieldInfo;
fieldInfo.uDataSize = 0;
KGLOG_PROCESS_ERROR(pRecordSet);
uFieldCount = mysql_num_fields(pRecordSet);
KGLOG_PROCESS_ERROR(uFieldCount);
//refFieldInfoVector.resize(uFieldCount);
Row = mysql_fetch_row(pRecordSet);
if (Row == NULL)
{
nRetCode = (int)mysql_errno(m_pDBHandle);
KGD_MYSQL_PROCESS_ERROR(nRetCode == 0, m_pDBHandle, "mysql_fetch_row()");
refbIsNoMoreRecodes = true;
KG_PROCESS_SUCCESS(true); // no more records
}
else
{
refbIsNoMoreRecodes = false;
}
pulLengths = mysql_fetch_lengths(pRecordSet);
KGLOG_PROCESS_ERROR(pulLengths);
for (unsigned i = 0; i < uFieldCount; i++)
{
fieldInfo.pvData = NULL;
fieldInfo.uDataSize = 0;
if (pulLengths[i] != 0) // NULL or empty string
{
fieldInfo.pvData = new unsigned char[pulLengths[i]];
KGLOG_PROCESS_ERROR(fieldInfo.pvData);
fieldInfo.uDataSize = (unsigned)pulLengths[i];
memcpy(fieldInfo.pvData, Row[i], (unsigned)pulLengths[i]);
}
refFieldInfoVector.push_back(fieldInfo);
}
Exit1:
nResult = true;
Exit0:
if (!nResult)
{
for (size_t i = 0; i < refFieldInfoVector.size(); i++)
{
KG_DELETE_ARRAY(refFieldInfoVector[i].pvData);
}
refFieldInfoVector.clear();
}
return nResult;
}
BOOL KG_HttpClient::GetPostBuffer(BYTE **ppbyPostBuffer, DWORD *pdwPostBufferSize)
{
int nResult = false;
int nRetCode = false;
DWORD dwFileSize = 0;
DWORD dwReadBytes = 0;
BYTE *pbyBuffer = NULL;
BYTE *pbyPostBuffer = NULL;
DWORD dwPostSize = 0;
TCHAR szBoundary[] = "-------------------------24822581126073";
HANDLE hFile = INVALID_HANDLE_VALUE;
struct POST_BLOCK
{
DWORD dwDataSize;
BYTE *pbyData;
} PostBlock;
std::vector<POST_BLOCK> PostBlocksList;
ZeroMemory(&PostBlock, sizeof(PostBlock));
KGLOG_PROCESS_ERROR(ppbyPostBuffer);
for (size_t i = 0; i < m_PostList.size(); ++i)
{
switch (m_PostList[i].eType)
{
case eNormal:
{
PostBlock.dwDataSize = 0;
PostBlock.pbyData = new BYTE[2 * 1024];
nRetCode = _stprintf(
(TCHAR *)PostBlock.pbyData,
"--%s\r\n"
"Content-Disposition: form-data; name=\"%s\"\r\n"
"\r\n%s\r\n",
szBoundary, m_PostList[i].pParamName, m_PostList[i].pValue
);
KGLOG_PROCESS_ERROR(nRetCode > 0);
PostBlock.dwDataSize = nRetCode;
PostBlocksList.push_back(PostBlock);
dwPostSize += nRetCode;
PostBlock.dwDataSize = 0;
PostBlock.pbyData = NULL;
break;
}
case eBinaryFile:
{
hFile = ::CreateFile(
m_PostList[i].pValue,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
NULL
);
KGLOG_PROCESS_ERROR(hFile != INVALID_HANDLE_VALUE);
dwFileSize = GetFileSize(hFile, NULL);
PostBlock.dwDataSize = 0;
PostBlock.pbyData = new BYTE[2 * 1024 + dwFileSize];
nRetCode = _stprintf(
(TCHAR *)PostBlock.pbyData,
"--%s\r\n"
"Content-Disposition: form-data; name=\"%s\"; filename=\"%s\"\r\n"
"Content-Type: application/octet-stream\r\n"
"\r\n",
szBoundary, m_PostList[i].pParamName, m_PostList[i].pValue
);
KGLOG_PROCESS_ERROR(nRetCode > 0);
PostBlock.dwDataSize += nRetCode;
dwPostSize += nRetCode;
pbyBuffer = PostBlock.pbyData + nRetCode;
nRetCode = ::ReadFile(hFile, pbyBuffer, dwFileSize, &dwReadBytes, NULL);
KGLOG_PROCESS_ERROR(nRetCode);
::CloseHandle(hFile);
hFile = INVALID_HANDLE_VALUE;
PostBlock.dwDataSize += dwReadBytes;
PostBlocksList.push_back(PostBlock);
dwPostSize += dwReadBytes;
PostBlock.dwDataSize = 0;
PostBlock.pbyData = NULL;
pbyBuffer = NULL;
break;
} // case eBinaryFile:
default:
KGLOG_PROCESS_ERROR(false);
}
}
pbyPostBuffer = new BYTE[dwPostSize + 2 * 1024];
pbyBuffer = pbyPostBuffer;
for (unsigned i = 0; i < PostBlocksList.size(); ++i)
{
CopyMemory(pbyBuffer, PostBlocksList[i].pbyData, PostBlocksList[i].dwDataSize);
pbyBuffer += PostBlocksList[i].dwDataSize;
}
CopyMemory(pbyBuffer, "\r\n--", _tcslen("\r\n--"));
dwPostSize += (DWORD)_tcslen("\r\n--");
pbyBuffer += (DWORD)_tcslen("\r\n--");
CopyMemory(pbyBuffer, szBoundary, _tcslen(szBoundary));
dwPostSize += (DWORD)_tcslen(szBoundary);
pbyBuffer += (DWORD)_tcslen(szBoundary);
CopyMemory(pbyBuffer, "--\r\n", _tcslen("--\r\n"));
dwPostSize += (DWORD)_tcslen("--\r\n");
pbyBuffer = NULL;
*ppbyPostBuffer = pbyPostBuffer;
*pdwPostBufferSize = dwPostSize;
pbyPostBuffer = NULL;
nResult = true;
Exit0:
for (unsigned i = 0; i < PostBlocksList.size(); ++i)
{
KG_DELETE_ARRAY(PostBlocksList[i].pbyData);
}
if (hFile!= INVALID_HANDLE_VALUE)
{
::CloseHandle(hFile);
hFile = INVALID_HANDLE_VALUE;
}
if (!nResult)
{
KG_DELETE_ARRAY(pbyPostBuffer);
}
return nResult;
}
int KG_HttpClient::RequestPost(
const TCHAR cszAgent[],
const TCHAR cszAddress[],
const TCHAR cszVerb[],
int nPort
)
{
int nResult = false;
int nRetCode = false;
LPCSTR clpAcceptTypeArray[] = {"*/*", NULL};
BYTE *pbyBuffer = NULL;
DWORD dwBufferSize = 0;
DWORD dwBytesWrite = 0;
DWORD dwBytesRead = 0;
DWORD dwBytesToRead = 0;
INTERNET_BUFFERS InternetBuffer;
LPCSTR clpContent = TEXT("Content-Type: multipart/form-data; boundary=-------------------------24822581126073\r\n");
TCHAR szContentLength[64];
KG_DELETE_ARRAY(m_pResponseBuffer);
m_hInternetSession = ::InternetOpen(
cszAgent,
INTERNET_OPEN_TYPE_PRECONFIG,
NULL,
NULL,
0
);
KGLOG_PROCESS_ERROR(m_hInternetSession);
m_hInternetConnection = ::InternetConnect(
m_hInternetSession,
cszAddress,
(INTERNET_PORT)nPort,
NULL,
NULL,
INTERNET_SERVICE_HTTP,
INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_NO_CACHE_WRITE,
0
);
KGLOG_PROCESS_ERROR(m_hInternetConnection);
m_hHttpRequest = ::HttpOpenRequest(
m_hInternetConnection,
"POST",
cszVerb,
HTTP_VERSION,
NULL,
clpAcceptTypeArray,
INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_NO_CACHE_WRITE | INTERNET_FLAG_FORMS_SUBMIT,
0
);
KGLOG_PROCESS_ERROR(m_hHttpRequest);
nRetCode = GetPostBuffer(&pbyBuffer, &dwBufferSize);
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = ::HttpAddRequestHeaders(m_hHttpRequest, "Accept: */*\r\n", (DWORD)_tcslen("Accept: */*\r\n"), HTTP_ADDREQ_FLAG_REPLACE);
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = ::HttpAddRequestHeaders(m_hHttpRequest, clpContent, (DWORD)_tcslen(clpContent), HTTP_ADDREQ_FLAG_ADD_IF_NEW);
KGLOG_PROCESS_ERROR(nRetCode);
_stprintf(szContentLength, "Content-Length: %d\r\n", dwBufferSize);
nRetCode = ::HttpAddRequestHeaders(m_hHttpRequest, szContentLength,(DWORD) _tcslen(szContentLength), HTTP_ADDREQ_FLAG_ADD_IF_NEW);
KGLOG_PROCESS_ERROR(nRetCode);
memset(&InternetBuffer, 0, sizeof(InternetBuffer));
InternetBuffer.dwStructSize = sizeof(InternetBuffer);
nRetCode = ::HttpSendRequestEx(m_hHttpRequest, &InternetBuffer, NULL, HSR_INITIATE, 0);
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = ::InternetWriteFile(m_hHttpRequest, pbyBuffer, dwBufferSize, &dwBytesWrite);
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = ::HttpEndRequest(m_hHttpRequest, NULL, HSR_INITIATE, 0);
KGLOG_PROCESS_ERROR(nRetCode);
dwBufferSize = (DWORD)sizeof(szContentLength);
nRetCode = ::HttpQueryInfo(m_hHttpRequest, HTTP_QUERY_CONTENT_LENGTH, szContentLength, &dwBufferSize, NULL);
KGLOG_PROCESS_ERROR(nRetCode);
dwBytesToRead = atoi(szContentLength);
KG_DELETE_ARRAY(m_pResponseBuffer);
m_pResponseBuffer = new BYTE[dwBytesToRead + 1];
ZeroMemory(m_pResponseBuffer, dwBytesToRead + 1);
nRetCode = ::InternetReadFile(m_hHttpRequest, m_pResponseBuffer, dwBytesToRead, &dwBytesRead);
KGLOG_PROCESS_ERROR(nRetCode);
m_pResponseBuffer[dwBytesToRead] = '\0';
m_dwBufferSize = dwBytesRead;
nResult = true;
Exit0:
if (!nResult)
{
KG_DELETE_ARRAY(m_pResponseBuffer);
}
KG_DELETE_ARRAY(pbyBuffer);
KG_INTERNET_HANDLE_CLOSE(m_hHttpRequest);
KG_INTERNET_HANDLE_CLOSE(m_hInternetConnection);
KG_INTERNET_HANDLE_CLOSE(m_hInternetSession);
for (size_t i = 0; i < m_PostList.size(); ++i)
{
KG_DELETE_ARRAY(m_PostList[i].pParamName);
KG_DELETE_ARRAY(m_PostList[i].pValue);
}
m_PostList.clear();
return nResult;
}
// 初始化面向客户端的连接
BOOL KPlayerServer::Init()
{
BOOL bResult = false;
int nRetCode = false;
BOOL bSocketServerInit = false;
IIniFile* piIniFile = NULL;
unsigned long ulInternalIPAddressMask = 0;
unsigned long ulExternalIPAddress = INADDR_NONE;
unsigned long ulInternalIPAddress = INADDR_NONE;
//int nListenPort = 0;
int nNatPort = 0;
int nMaxConnection = 0;
int nRecvBufferSize = 0;
int nSendBufferSize = 0;
int nClientGM = 0;
int nMaxClientPackPerFrame = 0;
char szNatIP[16];
char szInternalIPMask[16];
unsigned char byInternalMacAddress[6];
unsigned char byExternalMacAddress[6];
struct in_addr InAddr;
assert(g_pSO3World);
piIniFile = g_OpenIniFile(GS_SETTINGS_FILENAME);
KGLOG_PROCESS_ERROR(piIniFile);
memset(szNatIP, 0, sizeof(szNatIP));
piIniFile->GetString("GS-Player", "NatIP", "", szNatIP, sizeof(szNatIP));
piIniFile->GetInteger("GS-Player", "NatPort", 0, &nNatPort);
piIniFile->GetString("GS-Player", "InternalIPAddressMask", "192.168.0.0", szInternalIPMask, 16);
piIniFile->GetInteger("GS-Player", "MaxConnection", 1024, &nMaxConnection);
piIniFile->GetInteger("GS-Player", "RecvBufferSize", 8000, &nRecvBufferSize);
piIniFile->GetInteger("GS-Player", "SendBufferSize", 64000, &nSendBufferSize);
piIniFile->GetInteger("GS-Player", "PingCycle", 0, &m_nPingCycle);
piIniFile->GetInteger("GS-Player", "ClientGM", 0, &nClientGM);
piIniFile->GetInteger("GS-Player", "MaxClientPackPerFrame", 256, &nMaxClientPackPerFrame);
if (m_szLocalIP[0] != '\0')
{
ulExternalIPAddress = (unsigned long)inet_addr(m_szLocalIP);
if (ulExternalIPAddress == INADDR_NONE)
{
KGLogPrintf(KGLOG_ERR, "[KPlayerServerBase] Invalid ip address or format.\n");
goto Exit0;
}
}
else
{
char* pszInternetAddr = NULL;
ulInternalIPAddressMask = inet_addr(szInternalIPMask);
KGLOG_PROCESS_ERROR(ulInternalIPAddressMask != INADDR_NONE);
nRetCode = gGetMacAndIPAddress(
byInternalMacAddress, &ulInternalIPAddress,
byExternalMacAddress, &ulExternalIPAddress, ulInternalIPAddressMask
);
KGLOG_PROCESS_ERROR(nRetCode > 0);
InAddr.s_addr = ulExternalIPAddress;
pszInternetAddr = inet_ntoa(InAddr);
KGLOG_PROCESS_ERROR(pszInternetAddr);
strcpy(m_szLocalIP, pszInternetAddr);
}
KGLOG_PROCESS_ERROR(nMaxConnection > 0);
m_dwTimeNow = KG_GetTickCount();
m_nClientGM = nClientGM;
ResetPakStat();
m_nMaxConnection = nMaxConnection;
m_nMaxClientPackPerFrame = nMaxClientPackPerFrame;
m_ConnectionDataList = new KConnectionData[nMaxConnection];
KGLOG_PROCESS_ERROR(m_ConnectionDataList);
m_ConnectionDataListFreeVector.reserve(nMaxConnection);
for (int i = 0; i < nMaxConnection; i++)
{
m_ConnectionDataListFreeVector.push_back(nMaxConnection - i - 1);
}
m_nSocketEventCount = nMaxConnection + KG_MAX_ACCEPT_EACH_WAIT;
m_pSocketEventArray = new KG_SOCKET_EVENT[m_nSocketEventCount];
KGLOG_PROCESS_ERROR(m_pSocketEventArray);
nRetCode = m_SocketServerAcceptor.Init(
m_szLocalIP, m_nListenPort, KG_MAX_ACCEPT_EACH_WAIT,
nRecvBufferSize, nSendBufferSize, KSG_ENCODE_DECODE_NONE, NULL
);
KGLogPrintf(
KGLOG_INFO, "Start service at %s:%d ... ... [%s]",
m_szLocalIP, m_nListenPort, nRetCode ? "OK" : "Failed"
);
KGLOG_PROCESS_ERROR(nRetCode);
bSocketServerInit = true;
m_dwInternetAddr = ulExternalIPAddress;
if (szNatIP[0] != '\0')
{
m_nListenPort = nNatPort;
m_dwInternetAddr = (unsigned long)inet_addr(szNatIP);
KGLogPrintf(KGLOG_INFO, "NAT at %s:%d", szNatIP, nNatPort);
}
m_nNextCheckConnection = 0;
bResult = true;
Exit0:
if (!bResult)
{
if (bSocketServerInit)
{
m_SocketServerAcceptor.UnInit(NULL);
bSocketServerInit = false;
}
KG_DELETE_ARRAY(m_pSocketEventArray);
KG_DELETE_ARRAY(m_ConnectionDataList);
}
KG_COM_RELEASE(piIniFile);
return bResult;
}
KDropList::~KDropList(void)
{
KG_DELETE_ARRAY(m_ItemList);
}
BOOL KScriptManager::Reload(const char* pszFileName)
{
BOOL bResult = false;
BOOL bRetCode = false;
IFile* piFile = NULL;
char* pszBuffer = NULL;
DWORD dwScriptID = 0;
DWORD dwFileSize = 0;
DWORD dwReadSize = 0;
KLuaScriptData* pScriptData = NULL;
char szPathName[MAX_PATH];
char szFileName[MAX_PATH];
assert(pszFileName);
piFile = g_OpenFile(pszFileName);
KG_PROCESS_ERROR(piFile);
dwFileSize = piFile->Size();
pszBuffer = new char[dwFileSize];
KG_PROCESS_ERROR(pszBuffer);
dwReadSize = piFile->Read(pszBuffer, dwFileSize);
KG_PROCESS_ERROR(dwReadSize == dwFileSize);
g_GetFullPath(szPathName, pszFileName);
bRetCode = g_GetFilePathFromFullPath(szFileName, szPathName);
KG_PROCESS_ERROR(bRetCode);
dwScriptID = g_FileNameHash(szFileName);
bRetCode = IsScriptExist(dwScriptID);
KG_PROCESS_ERROR(bRetCode);
bRetCode = m_piScript->LoadFromBuffer(dwScriptID, szPathName, pszBuffer, dwFileSize);
KG_PROCESS_ERROR(bRetCode);
pScriptData = m_piScript->GetScriptData(dwScriptID);
if (pScriptData)
{
std::vector<DWORD>::iterator it = pScriptData->vecIncludeScriptID.begin();
std::vector<DWORD>::iterator itEnd = pScriptData->vecIncludeScriptID.end();
for (NULL; it != itEnd; ++it)
{
KLuaScriptData* pNewScriptData = NULL;
pNewScriptData = m_piScript->GetScriptData(*it);
if (pNewScriptData)
Reload(pNewScriptData->szName);
}
}
bResult = true;
Exit0:
if (!bResult)
{
KGLogPrintf(KGLOG_ERR, "[Lua] Failed to reload file \"%s\" !\n", pszFileName);
}
KG_DELETE_ARRAY(pszBuffer);
KG_COM_RELEASE(piFile);
return bResult;
}
