TIMESTAMP_STRUCT* CAutoTableManager::GetTableItemInLineAsDATETIME(UINT uItemIndex, UINT uLineIndex)
{
m_pDataTime = (TIMESTAMP_STRUCT*)this->GetTableItemInLine(uItemIndex, uLineIndex);
AssertEx(AL_NORMAL, m_pDataTime,_T("m_pDataTime为空,函数失败"));
AssertEx(AL_NORMAL, (m_pAi[uItemIndex].m_pAta == MS_SQL_TYPE_DATETIME),_T("类型不匹配,错误传参"));
return m_pDataTime;
}
FLOAT* CAutoTableManager::GetTableItemInLineAsFLOAT(UINT uItemIndex, UINT uLineIndex)
{
m_pFloat = (FLOAT*)this->GetTableItemInLine(uItemIndex, uLineIndex);
AssertEx(AL_NORMAL, m_pFloat,_T("m_pFloat为空,函数失败"));
AssertEx(AL_NORMAL, (m_pAi[uItemIndex].m_pAta == MS_SQL_TYPE_FLOAT),_T("类型不匹配,错误传参"));
return m_pFloat;
}
VOID CAutoTableManager::GetTablePointer(UINT& uItemIndex, UINT& uLineIndex)
{
AssertEx(AL_NORMAL, (uItemIndex < m_uItemCount), _T("uItemIndex访问越界,错误传参"));
AssertEx(AL_NORMAL, (uLineIndex < m_uLineCount), _T("uLineIndex访问越界,错误传参"));
uItemIndex = m_uItemIndex;
uLineIndex = m_uLineIndex;
}
BOOL GaiBangSkill004_T::EffectOnUnitOnce(Obj_Character& rMe, Obj_Character& rTar, BOOL bCriticalFlag) const
{
__ENTER_FUNCTION
SkillInfo_T& rSkillInfo = rMe.GetSkillInfo();
TargetingAndDepletingParams_T& rParams = rMe.GetTargetingAndDepletingParams();
INT nDepleteStrikePointSegment = rParams.GetDepletedStrikePoints()/STRIKE_POINT_SEGMENT_SIZE;
if(1>nDepleteStrikePointSegment)
{
AssertEx(FALSE,"[GaiBangSkill004_T::TakeEffectNow]: Depleted strike point segment illegal!");
nDepleteStrikePointSegment=1;
}
else if(MAX_STRIKE_POINT_SEGMENT<nDepleteStrikePointSegment)
{
AssertEx(FALSE,"[GaiBangSkill004_T::TakeEffectNow]: Depleted strike point segment illegal!");
nDepleteStrikePointSegment=MAX_STRIKE_POINT_SEGMENT;
}
INT nAdditionalAttackPower = rSkillInfo.GetDescriptorByIndex(nDepleteStrikePointSegment)->GetValue();
// init impact1
OWN_IMPACT impact;
CombatCore_T myCombatCore;
myCombatCore.Reset();
myCombatCore.SetAdditionalAttackLight(nAdditionalAttackPower);
myCombatCore.GetResultImpact(rMe, rTar, impact);
// register impact event
RegisterImpactEvent(rTar, rMe, impact, rParams.GetDelayTime(), bCriticalFlag);
return TRUE;
__LEAVE_FUNCTION
return FALSE;
}
TCA* CAutoTableManager::GetTableItemInLineAsTCHAR(UINT uItemIndex, UINT uLineIndex)
{
m_pTchar = (TCA*)this->GetTableItemInLine(uItemIndex, uLineIndex);
AssertEx(AL_NORMAL, m_pTchar,_T("m_pTchar为空,函数失败"));
AssertEx(AL_NORMAL, (m_pAi[uItemIndex].m_pAta == MS_SQL_TYPE_TCHAR),_T("类型不匹配,错误传参"));
return m_pTchar;
}
// DllGame启动线程函数
DWORD WINAPI RrTetris::RrTetrisThread(LPVOID)
{
RrTetris::gs_lpCMsPacketFactory = NEW CMsPacketFactory(DG2S_PACKET_MAX_COUNT);
AssertEx(AL_CATAST, gs_lpCMsPacketFactory, _T("内存不足"));
RrTetris::gs_lpCMsPacketFactory->Register(g_lpCMsBasePacket, PACKET_MAX_COUNT);
RrTetrisWritePacket(0,NULL);
// 等待基本初始化
while(!g_IsMsBaseInit)
{
NO_CONTINUOUS;
}
// 申请日志对象
RrTetris::gs_pMsLog = NEW CMsLog(_T("%s/Log/Dll_RrTetris_C.log"), TRUE);
AssertEx(AL_CATAST, gs_pMsLog, _T("内存不足"));
// 申请配置对象
RrTetris::gs_pRrTetrisConfig = NEW CMsIni(_T("%s/RrTetris/RrTetris.ini"));
AssertEx(AL_CATAST, gs_pRrTetrisConfig, _T("内存不足"));
::PostThreadMessage(gs_dwGameStationLogicThreadId, MSM_DLL_EXIT, 0, 0);
SAFE_DELETE(RrTetris::gs_lpCMsPacketFactory);
// 等待基本释放
while(g_IsMsBaseInit)
{
NO_CONTINUOUS;
}
return 0;
}
uint CGLockTargetHandler::Execute( CGLockTarget* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
GamePlayer* pGamePlayer = (GamePlayer*)pPlayer ;
Assert( pGamePlayer ) ;
Obj_Human* pHuman = pGamePlayer->GetHuman() ;
if(NULL==pHuman)
{
AssertEx(FALSE,"[CGLockTargetHandler::Execute]: NULL Obj_Human pointer found!!");
return PACKET_EXE_ERROR ;
}
Scene* pScene = pHuman->getScene() ;
if( pScene==NULL )
{
Assert(FALSE) ;
return PACKET_EXE_ERROR ;
}
//检查线程执行资源是否正确
Assert( MyGetCurrentThreadID()==pScene->m_ThreadID ) ;
ObjID_t nMeID = pHuman->GetID();
if( nMeID == INVALID_ID )
{
Assert(FALSE) ;
return PACKET_EXE_ERROR ;
}
//update target
if(NULL==pPacket)
{
AssertEx(FALSE,"[CGLockTargetHandler::Execute]: NULL packet pointer found!!");
return PACKET_EXE_ERROR ;
}
pHuman->SetLockedTarget(pPacket->getTargetID());
// 当锁定的目标是NPC时将会触发NPC的泡泡说话
Obj* pTarget = pScene->GetObjManager()->GetObj(pPacket->getTargetID());
if (pTarget->GetObjType() == Obj::OBJ_TYPE_MONSTER)
{
((Obj_Monster*)pTarget)->ProcessPaoPao();
}
g_pLog->FastSaveLog( LOG_FILE_1, "CGLockTargetHandler: ok obj=%d scene=%d",
nMeID, pScene->SceneID() ) ;
return PACKET_EXE_CONTINUE ;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR ;
}
VOID PNGAPI CMsPngImage::FlushPng(png_structp png_ptr)
{
CMsPngImage* pPngImage = (CMsPngImage*)png_get_io_ptr(png_ptr);
if (pPngImage->m_hFile)
{
BOOL bRet = ::FlushFileBuffers(pPngImage->m_hFile);
AssertEx(bRet, _T("写入图片失败"));
}
else
{
AssertEx(pPngImage->m_hFile, _T("写入图片失败"));
}
}
// 初始化表格管理器
BOOL CAutoTableManager::Init(VOID)
{
_ENTER_FUN_C;
for (UINT i = 0; i < m_uItemCount; i++)
{
switch (m_pAi[i].m_pAta)
{
case MS_SQL_TYPE_INT:
{
m_pInt = new INT[m_uLineCount];
AssertEx(AL_NORMAL, m_pInt, _T("m_pInt为空,内存不足"));
ZeroMemory(m_pInt, sizeof(INT) * m_uLineCount);
m_pAi[i].m_lpItem = m_pInt;
}break;
case MS_SQL_TYPE_TCHAR:
{
m_pTchar = new TCA[m_uLineCount];
AssertEx(AL_NORMAL, m_pTchar, _T("m_pInt为空,内存不足"));
ZeroMemory(m_pTchar, sizeof(TCA) * m_uLineCount);
m_pAi[i].m_lpItem = m_pTchar;
}break;
case MS_SQL_TYPE_FLOAT:
{
m_pFloat = new FLOAT[m_uLineCount];
AssertEx(AL_NORMAL, m_pFloat, _T("m_pInt为空,内存不足"));
ZeroMemory(m_pFloat, sizeof(FLOAT) * m_uLineCount);
m_pAi[i].m_lpItem = m_pFloat;
}break;
case MS_SQL_TYPE_DATETIME:
{
m_pDataTime = new TIMESTAMP_STRUCT[m_uLineCount];
AssertEx(AL_NORMAL, m_pDataTime, _T("m_pInt为空,内存不足"));
ZeroMemory(m_pDataTime, sizeof(TIMESTAMP_STRUCT) * m_uLineCount);
m_pAi[i].m_lpItem = m_pDataTime;
}break;
default:
{
AssertEx(AL_NORMAL, FALSE,_T("无效类型,错误逻辑"));
}
}
}
m_uValidLine = 0;
m_IsInit = TRUE;
// 返回成功
return TRUE;
_LEAVE_FUN_DISPOSE_END_C;
return FALSE;
}
// DllGame启动线程函数
DWORD WINAPI RrTetris::RrTetrisThread(LPVOID)
{
RrTetris::gs_lpCMsPacketFactory = NEW CMsPacketFactory(DG2S_PACKET_MAX_COUNT);
AssertEx(AL_CATAST, gs_lpCMsPacketFactory, _T("内存不足"));
RrTetris::gs_lpCMsPacketFactory->Register(g_lpCMsBasePacket, PACKET_MAX_COUNT);
RrTetris::gs_pCMsBaseRun = NEW CMsBaseRun(_T("%s/Log/Dll_RrTetris_Assertx.log"), _T("RrTetrisClass"), _T("RrTetris"), RrTetrisHookProc, RrTetrisWndProc, NULL);
AssertEx(AL_CATAST, gs_pCMsBaseRun, _T("内存不足"));
S_2DEngineWndInfo s_ewi;
s_ewi.m_bTopMost= FALSE;
s_ewi.m_nX = CW_USEDEFAULT;
s_ewi.m_nY = 0;
s_ewi.m_nWidth = CW_USEDEFAULT;
s_ewi.m_nHeight = 0;
s_ewi.m_dwStyle = WS_OVERLAPPEDWINDOW;
// 等待基本初始化
while(!g_IsMsBaseInit)
{
NO_CONTINUOUS;
}
// 申请日志对象
RrTetris::gs_pMsLog = NEW CMsLog(_T("%s/Log/Dll_RrTetris_C.log"), TRUE);
AssertEx(AL_CATAST, gs_pMsLog, _T("内存不足"));
// 申请配置对象
RrTetris::gs_pRrTetrisConfig = NEW CMsIni(_T("%s/RrTetris/RrTetris.ini"));
AssertEx(AL_CATAST, gs_pRrTetrisConfig, _T("内存不足"));
RrTetris::gs_hModule = ::GetModuleHandle(_T("Dll_RrTetris_C.dll"));
RrTetris::gs_hInstance = (HINSTANCE)RrTetris::gs_hModule;
if (RrTetris::gs_hInstance)
{
g_pCMsWinMain->Init(RrTetris::gs_hInstance, NULL, _T(""), SW_SHOW, &s_ewi);
g_pCMsWinMain->Run();
g_pCMsWinMain->WaitQuit();
}
::PostThreadMessage(gs_dwGameStationLogicThreadId, MSM_DLL_EXIT, (WPARAM)RrTetris::gs_hModule, 0);
SAFE_DELETE(RrTetris::gs_pCMsBaseRun);
SAFE_DELETE(RrTetris::gs_lpCMsPacketFactory);
// 等待基本释放
while(g_IsMsBaseInit)
{
NO_CONTINUOUS;
}
return 0;
}
Bitmap::Bitmap(int width, int height, int bpp)
: m_width(width), m_height(height), m_bpp(bpp), m_data(NULL) {
AssertEx(m_bpp == 1 || m_bpp == 8 || m_bpp == 16 || m_bpp == 24 || m_bpp == 32
|| m_bpp == 96 || m_bpp == 128, "Invalid number of bits per pixel");
AssertEx(width > 0 && height > 0, "Invalid bitmap size");
if (bpp == 96 || bpp == 128)
m_gamma = 1.0f;
else
m_gamma = -1.0f; // sRGB
// 1-bit masks are stored in a packed format.
m_size = (size_t) std::ceil(((double) m_width * m_height * m_bpp) / 8.0);
m_data = static_cast<uint8_t *>(allocAligned(m_size));
}
// PNG 读取回调
VOID PNGAPI CMsPngImage::ReadPng(png_structp png_ptr, png_bytep data, png_size_t length)
{
CMsPngImage* pPngImage = (CMsPngImage*)png_get_io_ptr(png_ptr);
if (pPngImage->m_hFile)
{
DWORD dwReadSize;
BOOL bRet = ::ReadFile(pPngImage->m_hFile, data, length, &dwReadSize, NULL);
AssertEx(bRet, _T("读取图片失败"));
}
else
{
AssertEx(pPngImage->m_hFile, _T("读取图片失败"));
}
}
VOID StdImpact030_T::OnFadeOut(OWN_IMPACT& rImp, Obj_Character& rMe) const
{
__ENTER_FUNCTION
Obj_Character* pTar=NULL;
Scene* pScene = rMe.getScene();
if(NULL==pScene)
{
AssertEx(FALSE, "[StdImpact030_T::OnFadeOut]: Empty scene pointer found!!");
return;
}
OBJLIST Targets;
if(FALSE==ScanUnitForTarget(rImp, rMe, *(rMe.getWorldPos()), (FLOAT)GetScanRadius(rImp), GetEffectedObjCount(rImp), Targets))
{
return;
}
INT nImpact = GetSubImpactIndex(rImp);
if(INVALID_ID==nImpact)
{
return;
}
// impacts init finished
for(INT nIdx=0; Targets.m_Count>nIdx;++nIdx)
{
pTar = (Obj_Character*)Targets.m_aObj[nIdx];
if(NULL!=pTar)
{
pScene->GetEventCore().RegisterBeSkillEvent(pTar->GetID(), rMe.GetID(), BEHAVIOR_TYPE_HOSTILITY, 500);
g_ImpactCore.SendImpactToUnit(*pTar, nImpact, rMe.GetID(), 500);
}
}
return;
__LEAVE_FUNCTION
}
VOID SceneTimer::FreeTimer(INT index)
{
if( index <0 || index >= maxCount )
{
#ifdef _DEBUG
CHAR szTemp[MAX_FILE_PATH];
sprintf(szTemp,"index = %d",index);
AssertEx(FALSE,szTemp) ;
#endif
return ;
}
InitOne(index);//释放时初始化
MyTimer* temp = (MyTimer*)&(m_pTimers[index]);
*((MyTimer**)temp) = head;
head = temp;
#if _DEBUG
m_currentUse--;
#endif
}
UINT LBAskAuthHandler::Execute(LBAskAuth* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
TID CurrentThreadID = MyGetCurrentThreadID();
if(CurrentThreadID == g_pServerManager->m_ThreadID)
{
Assert(pPacket);
ServerPlayer* pServerPlayer = (ServerPlayer*)pPlayer;
Assert(pServerPlayer);
pServerPlayer->SendPacket(pPacket);
}
else
{
AssertEx(FALSE,"LBAskAuthHandler 线程资源执行错误!");
}
Log::SaveLog(LOGIN_LOGFILE,"LBAskAuthHandler::Execute() ....OK");
return PACKET_EXE_CONTINUE;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR;
}
AreaLuminaire(const Properties &props) : Luminaire(props), m_shape(NULL) {
AssertEx(m_luminaireToWorld.isIdentity(), "Error: non-identity transformation found. "
"Area luminaires inherit their transformation from their associated shape!");
m_intensity = props.getSpectrum("intensity", Spectrum(1));
m_type = EDiffuseDirection | EOnSurface;
m_intersectable = true;
}
KVOID Kylin::Scene::SpawnScene()
{
Assert(KylinRoot::GetSingletonPtr()->GetGameFramePtr());
m_pSceneLoader = KylinRoot::GetSingletonPtr()->GetGameFramePtr()->CreateSceneLoader();
//-----------------------------------------------------------------
// ╪стьЁ║╬╟
Ogre::FileInfoListPtr resPtr = Ogre::ResourceGroupManager::getSingletonPtr()->findResourceFileInfo("General", m_kSceneHag.m_sSceneFile);
Ogre::FileInfo fInfo = (*(resPtr->begin()));
KSTR sName = fInfo.archive->getName();
sName += "/" + m_kSceneHag.m_sSceneFile;
//------------------------------------------------------------------
// ╪сть╠Ё╬╟рТюж
KylinRoot::GetSingletonPtr()->CreateSound("$BackgroundSound",m_kSceneHag.m_nBgSound);
//------------------------------------------------------------------
// ж╢ппluaнд╪Ч
KSTR sLua = StringUtils::replace(sName,".xml",".lua");
OgreRoot::GetSingletonPtr()->GetScriptVM()->ExecuteScriptFile(sLua.data());
//-----------------------------------------------------------------
// ╪стьlevel
m_pSceneLoader->LoadLevel(m_kSceneHag.m_sSceneFile);
//-----------------------------------------------------------------
// ╪стьЁ║╬╟ё╛NPC╣х
if (!m_pSceneLoader->LoadScene(m_kSceneHag.m_sSceneFile))
{
AssertEx(NULL,"Ё║╬╟╪стьй╖╟эё║");
return;
}
//-----------------------------------------------------------------
// ╪стьмФ╪р
m_pSceneLoader->LoadPlayer();
}
UINT LBAskRegAuthHandler::Execute(LBAskRegAuth* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
TID CurrentThreadID = MyGetCurrentThreadID();
if(CurrentThreadID == g_pServerManager->m_ThreadID)
{
Assert(pPacket);
BillingPlayer* pBillPlayer= (BillingPlayer*)pPlayer;
Assert(pBillPlayer);
LBRegPassPort Msg;
Msg.SetAccount(pPacket->GetAccount());
Msg.SetSuperPassWord(pPacket->GetSuperPassWord());
Msg.SetPassWord(pPacket->GetPassWord());
Msg.SetPacketIndex(pPacket->GetPlayerID());
Msg.SetIPAddr(pPacket->GetIP());
Msg.SetEmail(pPacket->GetEmail());
pBillPlayer->SendPacket(&Msg);
}
else
{
AssertEx(FALSE,"LBAskRegAuthHandler 线程资源执行错误!");
}
g_pLog->FastSaveLog(LOG_FILE_0,"LBAskRegAuthHandler::Execute() Acc=%s IP=%s....OK", pPacket->GetAccount(),pPacket->GetIP() );
return PACKET_EXE_CONTINUE;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR;
}
VOID DBCFile::CreateIndex(INT nColum, const CHAR* szFileName)
{
if(nColum <0 || nColum >= m_nFieldsNum || m_nIndexColum==nColum) return;
m_hashIndex.clear();
for(INT i=0; i<(INT)m_nRecordsNum; i++)
{
FIELD* p = &(m_vDataBuf[i*m_nFieldsNum]);
FIELD_HASHMAP::iterator itFind = m_hashIndex.find(p->iValue);
if(itFind != m_hashIndex.end())
{
CHAR szTemp[260];
_snprintf(szTemp, 260, "[%s]Multi index at line %d(SAME:value=%d)", szFileName, i+1, p->iValue);
#ifdef GAME_CLIENT
throw std::exception(szTemp);
#else
AssertEx(FALSE,szTemp);
#endif
return;
}
m_hashIndex.insert(std::make_pair(p->iValue, p));
}
}
UINT SSScenePlayerCountHandler::Execute(SSScenePlayerCount* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
TID CurrentThreadID = MyGetCurrentThreadID();
if(CurrentThreadID == g_pServerManager->m_ThreadID)
{
//修改g_WorldPlayerCounter 中数据
Assert(pPacket);
g_WorldPlayerCounter.m_WorldPlayerCount = pPacket->GetTotalPlayerCount();
//修改场景负载数据
//todo..
}
else
{
AssertEx(FALSE,"SSScenePlayerCountHandler 线程资源执行错误!");
}
Log::SaveLog(LOGIN_LOGFILE,"SSScenePlayerCountHandler::Execute()....OK,WorldPlayerCount = %d",
g_WorldPlayerCounter.m_WorldPlayerCount);
return PACKET_EXE_CONTINUE;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR;
}
BOOL RootTrap01_T::EffectOnChar(Obj_Special& rThis, Obj_Character& rTar) const
{
SpecialObjData_T const* pData = rThis.GetDataRecord();
if(NULL==pData)
{
AssertEx(FALSE,"[RootTrap01_T::EffectOnChar]: Can't find Data record.");
return FALSE;
}
INT nImpactID = pData->GetDescriptorByIndex(0)->GetValue();
Time_t nContinuance = pData->GetDescriptorByIndex(1)->GetValue();
OWN_IMPACT impact;
SOT_Root_T ImpactLogic;
ImpactLogic.InitStruct(impact);
impact.m_nCasterID = rThis.GetOwnerID();
impact.m_nSkillID = INVALID_ID;
impact.m_nImpactID = nImpactID;
ImpactLogic.SetContinuance(impact, nContinuance);
impact.m_nPRI = rThis.GetXinFaLevelForBuffMutex();
Scene* pScene = rThis.getScene();
if(NULL!=pScene)
{
pScene->GetEventCore().RegisterBeSkillEvent(rTar.GetID(), rThis.GetOwnerID(), BEHAVIOR_TYPE_HOSTILITY, 500);
pScene->GetEventCore().RegisterImpactEvent(rTar.GetID(), rThis.GetOwnerID(), impact, 500);
}
return FALSE;
}
Graphics::Graphics(const RECT& rect) : stage(rect) {
linePainter = new LinePainter(rect);
AssertEx(rect.bottom - rect.top == rect.right - rect.left, "only square stage is supported");
camera = new Camera(moveSpeed, rotateSpeed, rect.bottom - rect.top);
LightAttribute lightAttr;
lightAttr.diffuse = Color(255, 255, 255);
lightAttr.direction = Vector3::right;
lightAttr.lightOn = true;
lightAttr.lightType = LightTypeDirection;
lightAttr.position.Set(200, 0, 0);
camera->AddLight(Light(lightAttr));
lightAttr.ambient = Color(90, 90, 90);
lightAttr.lightType = LightTypeAmbient;
lightAttr.lightOn = true;
camera->AddLight(Light(lightAttr));
zBuffer = new ZBuffer(stage.right - stage.left, stage.bottom - stage.top);
VertexContainer vertices;
IndexedTriangleContainer triangles;
CreatePlane(vertices, triangles, Texture("bmp/metal.bmp"), 2, 3);
street = new Object();
//street->Initialize(vertices, triangles, 5.f, 12.f, Vector3(), Vector3());
AddObject(street);
xmin = stage.left + 1;
xmax = stage.right - 2;
ymin = stage.top + 1;
ymax = stage.bottom - 2;
}
// 释放完成端口
BOOL CMsIocpManager::Release(VOID)
{
_ENTER_FUN_C;
this->LogIocp(_T("[开始释放!]"));
BOOL bRet = TRUE;
this->Stop(TRUE, TRUE);
if (m_hCompetionPort)
{
bRet = ::CloseHandle(m_hCompetionPort);
AssertEx(AL_CATAST, bRet, _T("释放完成端口失败,函数失败"));
m_hCompetionPort = NULL;
}
m_IsInit = FALSE;
this->LogIocp(_T("[释放成功!]"));
// 返回成功
return TRUE;
_LEAVE_FUN_DISPOSE_CONTINUE_C;
this->LogIocp(_T("[释放失败!]"));
return FALSE;
}
MonteCarloIntegrator::MonteCarloIntegrator(const Properties &props) : SampleIntegrator(props) {
/* Depth to begin using russian roulette */
m_rrDepth = props.getInteger("rrDepth", 10);
/* Longest visualized path length (\c -1 = infinite).
A value of \c 1 will visualize only directly visible light sources.
\c 2 will lead to single-bounce (direct-only) illumination, and so on. */
m_maxDepth = props.getInteger("maxDepth", -1);
/**
* This parameter specifies the action to be taken when the geometric
* and shading normals of a surface inconsistently classify a ray as
* being located *both* on the front and back-side.
*
* When \c strictNormals is set to \c false, the shading normal has
* precedence, and rendering proceeds normally at the risk of
* introducing small light leaks (this is the default).
*
* When \c strictNormals is set to \c true, the random walk is
* terminated when encountering such a situation. This may
* produce black silhouette edges on badly tesselated meshes.
*/
m_strictNormals = props.getBoolean("strictNormals", false);
AssertEx(m_rrDepth > 0, "rrDepth == 0 breaks the computation of alpha values!");
}
Item* HumanItemLogic::GetBankItem(Obj_Human* pHuman,UINT BankIndex)
{
__ENTER_FUNCTION
Assert(BankIndex<MAX_BANK_SIZE);
Assert(BankIndex>=0);
if(BankIndex<0||BankIndex>MAX_BANK_SIZE)
{
AssertEx(FALSE,"HumanItemLogic::GetBankItem() BankIndex 不在合法范围 ");
return NULL;
}
ItemContainer* pBankContainer = pHuman->GetBankContain();
Assert(pBankContainer);
if(!pBankContainer)
{
return NULL;
}
return pBankContainer->GetItem((UINT)BankIndex);
__LEAVE_FUNCTION
return NULL;
}
// 初始化
BOOL CDistricNode::Init(DWORD dwRoomNodeCount)
{
m_dwChildCount = dwRoomNodeCount;
if (m_dwChildCount)
{
m_lppChildList = NEW lpCBaseNode[m_dwChildCount];
if (m_lppChildList)
{
FOR_x_TO(i, m_dwChildCount)
{
m_lppChildList[i] = NEW CRoomNode;
AssertEx(m_lppChildList[i], _T("内存不足"));
}
if (g_pCGameStation)
{
//DWORD dwDeskCountInEveryRoom = g_pCGameStation->GetConfig()->dwDeskCountInEveryRoom;
FOR_x_TO(i, m_dwChildCount)
{
m_lppChildList[i]->Init(0);
}
return TRUE;
}
else
{
UINT LWChangeNameHandler::Execute(LWChangeName* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
TID CurrentThreadID = MyGetCurrentThreadID();
if(CurrentThreadID == g_pServerManager->m_ThreadID)
{
Assert(pPacket);
ServerPlayer* pServerPlayer = (ServerPlayer*)pPlayer;
Assert(pServerPlayer);
pServerPlayer->SendPacket(pPacket);
}
else
{
AssertEx(FALSE,"LWChangeNameHandler 线程资源执行错误!");
}
g_pLog->FastSaveLog(LOG_FILE_0,"LWChangeNameHandler::Execute() ....OK");
return PACKET_EXE_CONTINUE;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR;
}
uint CGDispelBuffReqHandler::Execute( CGDispelBuffReq* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
GamePlayer* pGamePlayer = (GamePlayer*)pPlayer ;
Assert( pGamePlayer ) ;
Obj_Human* pHuman = pGamePlayer->GetHuman() ;
if(NULL==pHuman)
{
AssertEx(FALSE,"[CGDispelBuffReqHandler::Execute]: NULL Obj_Human pointer found!!");
return PACKET_EXE_ERROR ;
}
Scene* pScene = pHuman->getScene() ;
if( pScene==NULL )
{
AssertEx(FALSE,"[CGDispelBuffReqHandler::Execute]: NULL scene pointer found!!") ;
return PACKET_EXE_ERROR ;
}
//检查线程执行资源是否正确
Assert( MyGetCurrentThreadID()==pScene->m_ThreadID ) ;
ObjID_t nMeID = pHuman->GetID();
if( nMeID == INVALID_ID )
{
Assert(FALSE) ;
return PACKET_EXE_ERROR ;
}
//update target
if(NULL==pPacket)
{
AssertEx(FALSE,"[CGDispelBuffReqHandler::Execute]: NULL packet pointer found!!");
return PACKET_EXE_ERROR ;
}
Obj_Character& rMe = *((Obj_Character*)pHuman);
rMe.Impact_UnRegisterImpactBySN(pPacket->GetSN());
g_pLog->FastSaveLog( LOG_FILE_1, "CGDispelBuffReqHandler: ok obj=%d scene=%d",
nMeID, pScene->SceneID() ) ;
return PACKET_EXE_CONTINUE ;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR ;
}
VOID DS_EMei014_T::OnFadeOut(OWN_IMPACT& rImp, Obj_Character& rMe) const
{
__ENTER_FUNCTION
Obj_Character* pTar=NULL;
OBJLIST Targets;
if(FALSE==ScanUnitForTarget(rImp, rMe, *(rMe.getWorldPos()), (FLOAT)GetScanRadius(rImp), GetEffectedObjNumber(rImp), Targets))
{
return;
}
// init impact
OWN_IMPACT impact;
DI_ModifyRage_T const* pImpactLogic = (DI_ModifyRage_T const*)g_ImpactLogicList.GetLogicById(DI_MODIFY_RAGE);
if(NULL==pImpactLogic)
{
AssertEx(FALSE,"[SOT_EMei014_T::OnFadeOut]:Can't find the logic for DI_MODIFY_RAGE. check now.");
return;
}
pImpactLogic->InitStruct(impact);
impact.m_nSkillID = rImp.m_nSkillID;
impact.m_nCasterID = rMe.GetID();
impact.m_nImpactID = GetSubImpactID(rImp);
INT nRage = GetRageModification(rImp);
0<nRage?nRage=-nRage:NULL;
pImpactLogic->SetRageModification(impact, nRage);
Scene* pScene = rMe.getScene();
if(NULL==pScene)
{
AssertEx(FALSE,"[SOT_EMei014_T::OnFadeOut]:Empty Scene pointer. check now.");
return;
}
// impacts init finished
for(INT nIdx=0; Targets.m_Count>nIdx;++nIdx)
{
pTar = (Obj_Character*)Targets.m_aObj[nIdx];
if(NULL==pTar)
{
continue;
}
pScene->GetEventCore().RegisterBeSkillEvent(pTar->GetID(), rMe.GetID(), BEHAVIOR_TYPE_HOSTILITY, 500);
pScene->GetEventCore().RegisterImpactEvent(pTar->GetID(), rMe.GetID(), impact, 500);
}
return;
__LEAVE_FUNCTION
}
RecyclePlayerManager::~RecyclePlayerManager()
{
__ENTER_FUNCTION
AssertEx(GetPlayerNumber() == 0,"场景中还有玩家存在,强制回收玩家管理器!");
__LEAVE_FUNCTION
}
