VOID CUIWindowItem::LoadWindow(VOID)
{
TDAssert(m_pWindow == NULL);
if(m_bLayoutLoaded) return;
//----------------------------------------------------------------------------
//加载布局文件
m_pWindow = CEGUI::WindowManager::getSingleton().loadWindowLayout(m_strLayoutFileName, "", "",
callbackProperty);
TDAssert(m_pWindow);
//初始状态：隐藏
m_pWindow->hide();
CUIWindowMng::GetClientScreen()->addChildWindow(m_pWindow);
//注册控件
_RegisterControlToScript(m_pWindow);
//---------------------------------------
//执行其中的***_OnLoad函数
CHAR szTemp[MAX_PATH] = {0};
_snprintf(szTemp, MAX_PATH, "%s_OnLoad", m_strWindowName.c_str());
m_pScriptEnv->DoFunction(szTemp);
FILE * fp;
if((fp=fopen("Out.txt","a"))!=0){
fprintf(fp,"->>>%s\n",szTemp);
fclose(fp);
}
m_bLayoutLoaded = TRUE;
}
VOID CFairyObject::SetActorFile(LPCTSTR szActorFile)
{
TDAssert(szActorFile&& m_pFairyObj);
m_pFairyObj->setProperty(FOBJ_ACTOR_FILE, Fairy::String(szActorFile));
#if 0
//得到所有动作列表
{
//确认是人物模型
if(m_pFairyObj->getType() != EOBJ_TYPE_ACTOR) return;
//确认资源已经Load
Fairy::Actor* pActor = ((Fairy::ActorObject*)m_pFairyObj.get())->getActor();
if(!pActor) return;
Ogre::LogManager::getSingleton().logMessage("Load ActorFile " + Ogre::String(szActorFile));
std::vector< STRING > vAllAnim = pActor->getImpl()->GetObjAllAnimName();
for(int i=0; i<(int)vAllAnim.size(); i++)
{
Ogre::LogManager::getSingleton().logMessage(Ogre::String(vAllAnim[i].c_str()));
}
}
#endif
}
VOID CActionSystem::UpdateAction_FromSkill(const SCLIENT_SKILL* pSkill)
{
TDAssert(pSkill);
//检查时候已经有该操作
CActionItem_Skill* pSkillAction = (CActionItem_Skill*)GetAction_SkillID(pSkill->m_pDefine->m_nID*100 + pSkill->m_nLevel);
//AxTrace(0, 0, "Skill:%d", pSkill->m_pDefine->m_dwID);
//如果没有,创建
if(!pSkillAction)
{
pSkillAction = new CActionItem_Skill(_CreateID());
pSkillAction->Update_Skill(pSkill);
//INT nPos = pSkillAction->GetPosIndex();
//加入
m_mapAllAction[pSkillAction->GetID()] = pSkillAction;
UpdateToolBar();
//如果有上次存的默认技能，则设置为它。
if( pSkill->m_pDefine->m_nID*100 + pSkill->m_nLevel == CGameProcedure::s_pVariableSystem->GetAs_Int("DefaultSkill") )
{
CGameInterface::GetMe()->Skill_SetActive(pSkillAction);
}
}
else
{
pSkillAction->Update_Skill(pSkill);
}
}
// 初始化窗口管理器
VOID CUIWindowMng::Init(VOID)
{
//创建ui系统底板
// PROFILE_PUSH(Create_MainBoard);
m_pBackGroundSheet = CEGUI::WindowManager::getSingleton().createWindow((CEGUI::utf8*)"DefaultGUISheet", (CEGUI::utf8*)"__BACKGOUNDSHEET__");
m_pBackGroundSheet->setMouseHollow(true);
m_pBackGroundSheet->moveToFront();
//m_pBackGroundSheet->captureInput();
m_pBackGroundSheet->setDistributesCapturedInputs(true);
CEGUI::System::getSingleton().setGUISheet( m_pBackGroundSheet );
// PROFILE_POP(Create_MainBoard);
//加载UI
tDataBaseSystem* pUIDBC = (tDataBaseSystem*)g_pKernel->GetNode("bin\\dbc");
TDAssert(pUIDBC);
const tDataBase* pDBC = pUIDBC->GetDataBase(DBC_UI_LAYOUTDEFINE);
for(INT i=0; i<(INT)pDBC->GetRecordsNum(); i++)
{
const _DBC_UI_LAYOUTDEFINE* pLine = (const _DBC_UI_LAYOUTDEFINE*)((tDataBase*)pDBC)->Search_LineNum_EQU(i);
//产生一个新的WindowItem
CUIWindowItem* pItem = new CUIWindowItem(pLine);
//预加载窗口
pItem->PreLoadWindow();
m_aWindowList.push_back( pItem );
}
}
VOID CFairyObject::SetActorObjectProperty(LPCTSTR szName, LPCTSTR szValue)
{
TDAssert(m_pFairyObj);
//确认是人物模型
if(m_pFairyObj->getType() != EOBJ_TYPE_ACTOR) return;
//确认资源已经Load
Fairy::Actor* pActor = ((Fairy::ActorObject*)m_pFairyObj.get())->getActor();
if(!pActor) return;
// AxTrace(-1, 0, "<DObject|Set %s to %s>", szName, szValue);
try
{
std::vector< std::string > vName, vValue;
vName.push_back(szName);
vValue.push_back(szValue);
pActor->getImpl()->ChangeAttributes(vName, vValue);
}
catch(...)
{
}
}
VOID CActionSystem::UpdateAction_FromItem(tObject_Item* pItem)
{
TDAssert(pItem);
//检查时候已经有该操作
CActionItem_Item* pItemAction = (CActionItem_Item*)GetAction_ItemID(pItem->GetID());
//如果没有,创建
if(!pItemAction)
{
pItemAction = new CActionItem_Item(_CreateID());
pItemAction->Update_Item(pItem);
//加入链表
m_mapAllAction[pItemAction->GetID()] = pItemAction;
UpdateToolBar();
}
//如果有，更新
else
{
pItemAction->Update_Item(pItem);
for(INT i=0; i<(INT)m_barMain.size(); i++)
{
ACTIONBAR_ITEM& barItem = m_barMain[i];
if(barItem.idImpl == pItem->GetIdTable())
{
MainMenuBar_Set(i,pItemAction->GetID());
}
}
}
}
UINT CNetManager::_ConnectThread(LPVOID pParam)
{
TDAssert(pParam);
CNetManager* pNetManager = (CNetManager*) pParam;
return pNetManager->ConnectThread();
}
VOID CWXObj_Object::SetOrientation(const fVector3& vRotate)
{
TDAssert(m_pWXObject);
Ogre::Quaternion qu(Ogre::Radian(vRotate.y), Ogre::Vector3::UNIT_Y);
m_pWXObject->setProperty(FOBJ_ORIENTATION, qu);
}
VOID CObject_Item_StoreMap::AsStoreMap(const _DBC_ITEM_STOREMAP* pStoreMapDefine)
{
TDAssert(pStoreMapDefine);
m_theBaseDef = pStoreMapDefine;
m_nParticularID = ( ( ( ( ( m_theBaseDef->nClass * 100 ) + m_theBaseDef->nQuality ) * 100 ) + m_theBaseDef->nType ) * 1000 ) + m_theBaseDef->nIndex;
}
//插件初始化
extern "C" VOID __stdcall DllInit( tKernel* pKernel )
{
TDAssert(pKernel);
g_pKernel = pKernel;
pKernel->ReisgerClass(GETCLASS(CUISystem));
}
VOID CRenderSystem::Destroy_EntityObject(tEntityNode* pNode)
{
TDAssert(pNode);
delete ((CWXObject*)pNode);
//之后不能调用和该node相关的任何代码
return;
}
VOID CObject_Item_Gem::AsGem(const _DBC_ITEM_GEM* pGemDefine)
{
TDAssert(pGemDefine);
m_theBaseDef = pGemDefine;
m_nParticularID = ( ( ( ( ( m_theBaseDef->nClass * 100 ) + m_theBaseDef->nQuality ) * 100 ) + m_theBaseDef->nType ) * 1000 ) + m_theBaseDef->nGemIndex;
}
VOID CWXObj_Object::SetPosition(const fVector3& vPos)
{
TDAssert(m_pWXObject);
//坐标转化
fVector3 fvGfxPos;
CRenderSystem::GetMe()->Axis_Trans(CRenderSystem::AX_GAME, vPos, CRenderSystem::AX_GFX, fvGfxPos);
m_pWXObject->setProperty(FOBJ_POSITION, Ogre::Vector3(fvGfxPos.x, fvGfxPos.y, fvGfxPos.z));
}
//设置详细解释
VOID CObject_Item_Gem::SetExtraInfo(const _ITEM * pItemInfo)
{
TDAssert(pItemInfo);
//调用基类函数，保存_ITEM结构
CObject_Item::SetExtraInfo(pItemInfo);
SetNumber(pItemInfo->GetItemCount());
SetManufacturer(pItemInfo);
}
VOID CActionItem_Skill::Update_Skill(const SCLIENT_SKILL* pSkill)
{
TDAssert(pSkill);
//引用
m_idSkillImpl = pSkill->m_pDefine->m_nID*100 + pSkill->m_nLevel;
//名称
m_strName = pSkill->m_pDefine->m_lpszName;
//图标
m_strIconName = pSkill->m_pDefine->m_lpszIconName;
BOOL bOldEnable = IsEnabled();
BOOL bNewEnable = FALSE;
ORESULT oResult = pSkill->IsCanUse_CheckDeplete( CObjectManager::GetMe()->GetMySelf()->GetID());
if ( OR_SUCCEEDED( oResult ) )
{
oResult = pSkill->IsCanUse_Leaned();
if ( OR_SUCCEEDED( oResult ) )
{
bNewEnable = TRUE;
}
}
if ( bNewEnable != bOldEnable )
{
(bNewEnable)?(Enable()):(Disable());
//通知UI
UpdateToRefrence();
}
////引用
//m_idSkillImpl = pSkill->m_pDefine->m_nID;
////名称
//m_strName = pSkill->m_pDefine->m_lpszName;
////图标
//m_strIconName = pSkill->m_pDefine->m_lpszIconName;
//
//const SCLIENT_XINFA* pXinfa = CObjectManager::GetMe()->GetMySelf()->GetCharacterData()->Get_XinFa(pSkill->m_pDefine->m_nXinFaID);
//if(pXinfa && pXinfa->m_nLevel < pSkill->m_pDefine->m_nXinFaLevelRequirement)
//{
// Disable();
//}
////是否激活
//else if( (0==pSkill->m_nActiveTime) || (FALSE == pSkill->m_bLeaned) )
//{
// Disable();
//}
//else
//{
// Enable();
//}
////通知UI
//UpdateToRefrence();
}
HANDLE CEffectObject::AddEffect(INT idEffect, BOOL bLoop, LPCTSTR /*szLocatorName*/)
{
//创建特效实例
Fairy::Effect* pEffectIml = Fairy::EffectManager::getSingleton().createEffect("g01_jingangquan_01");
if(!pEffectIml) return NULL;
//创建场景节点
Ogre::SceneNode* pSceneNode = pEffectIml->createSceneNode();
//保存
m_listEffectImpl.push_back(std::make_pair(pEffectIml, pSceneNode));
return pEffectIml;
#if 0
//-------------------------------------------------------------
//得到数据库系统模块
static const tDataBaseSystem* s_pDataBase = NULL;
if(!s_pDataBase) s_pDataBase = (tDataBaseSystem*)g_pKernel->GetNode("bin\\dbc");
TDAssert(s_pDataBase);
//-------------------------------------------------------------
//从DBC_EFFECT_DEFINE查找具体特效
static const tDataBase* s_pDBCEffect = NULL;
if(!s_pDBCEffect) s_pDBCEffect = s_pDataBase->GetDataBase(DBC_EFFECT_DEFINE);
TDAssert(s_pDBCEffect);
//查找具体特效
const _DBC_EFFECT_DEFINE* pEffect = (const _DBC_EFFECT_DEFINE*)s_pDBCEffect->Search_Index_EQU(idEffect);
//没有找到
if(!pEffect) return NULL;
//生成Effect对象
Ogre::Effect* pEffectIml = Ogre::EffectManager::getSingleton().createEffect(pEffect->pEffectType, pEffect->pParam1);
if(!pEffectIml) return NULL;
//保存
m_listEffectImpl.push_back(pEffectIml);
return (HANDLE)pEffectIml;
#endif
}
//设置详细解释
VOID CObject_Item_StoreMap::SetExtraInfo(const _ITEM * pItemInfo)
{
TDAssert(pItemInfo);
//调用基类函数，保存_ITEM结构
CObject_Item::SetExtraInfo(pItemInfo);
const STORE_MAP_INFO& infoStoreMap = pItemInfo->m_StoreMap;
SetNumber(pItemInfo->GetItemCount());
SetManufacturer(pItemInfo);
}
void CSoundSourceFMod::SetBuffer(tSoundBuffer *buffer)
{
TDAssert(buffer);
if(_Sample)
{
((CSoundBufferFMod*)_Sample)->DecRefrence(this);
}
_Sample = buffer;
((CSoundBufferFMod*)_Sample)->AddRefrence(this);
}
void TDDebuger::Initial(void*)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
if(m_pDlgDebuger) return;
g_pInterface = (tGameInterfaceBase*)g_pKernel->GetNode("bin\\interface");
TDAssert(g_pInterface);
g_pGfxSystem = (tGfxSystem*)g_pKernel->GetNode("bin\\gfx");
TDAssert(g_pGfxSystem);
g_pTimeSystem = (tTimeSystem*)g_pKernel->GetNode("bin\\time");
TDAssert(g_pTimeSystem);
g_pEventSystem = (tEventSystem*)g_pKernel->GetNode("bin\\event");
TDAssert(g_pEventSystem);
g_pVariableSystem = (tVariableSystem*)g_pKernel->GetNode("bin\\var");
TDAssert(g_pVariableSystem);
g_pDBCSystem = (tDataBaseSystem*)g_pKernel->GetNode("bin\\dbc");
TDAssert(g_pDBCSystem);
//´´½¨Debuger´°¿Ú
m_pDlgDebuger = new CDlgDebuger;
m_pDlgDebuger->Create( IDD_DIALOG_DEBUGER, NULL);
}
BOOL CUIWindowMng::IsWindowShow(LPCTSTR szUIName)
{
TDAssert(szUIName);
WINDOWLIST::iterator it;
for( it=m_aWindowList.begin(); it != m_aWindowList.end(); it ++ )
{
if(strcmp((*it)->GetWindowName(), szUIName) == 0)
return (*it)->IsWindowShow();
}
return FALSE;
}
VOID CFairyObject::SetAnimationEndEvent(FUNC_ONANIMATIONEND pFunc, DWORD dwParam)
{
TDAssert(m_pFairyObj);
//确认是人物模型
if(m_pFairyObj->getType() != EOBJ_TYPE_ACTOR) return;
//确认资源已经Load
Fairy::Actor* pActor = ((Fairy::ActorObject*)m_pFairyObj.get())->getActor();
if(!pActor) return;
pActor->getImpl()->SetAnimationEndEventListener((_OnAnimationEnd)pFunc, dwParam);
}
//直接打开一个dbc文件
BOOL CDataBase::Util_OpenDBCFromTxt(LPCTSTR szFileName, DBC::DBCFile* pDBCFile)
{
TDAssert(szFileName && pDBCFile);
char* lpAddress = NULL;
DWORD dwSize = CGameProcedure::s_pResourceProvider->loadResource(szFileName, lpAddress, "General");
if( dwSize > 0 )
{
BOOL bRet = pDBCFile->OpenFromMemory( lpAddress, lpAddress + dwSize + 1);
CGameProcedure::s_pResourceProvider->unloadResource( lpAddress, dwSize );
return bRet;
}
return FALSE;
}
VOID CFairyObject::GetActorObjectProperty(LPCTSTR szName, STRING& szValue)
{
TDAssert(m_pFairyObj);
//确认是人物模型
if(m_pFairyObj->getType() != EOBJ_TYPE_ACTOR) return;
//确认资源已经Load
Fairy::Actor* pActor = ((Fairy::ActorObject*)m_pFairyObj.get())->getActor();
if(!pActor) return;
DWORD dwHits;
pActor->getImpl()->GetObjAttribute(DString(szName), szValue, dwHits);
}
VOID CRenderSystem::Scene_Load(INT nID, const STRING& theSceneDefine)
{
WX::ExpatParser parserExpat(NULL);
if(m_pTerrainGrid)
{
m_pTerrainGrid->destroyRenderable();
}
//卸载现有资源
m_pRenderSystem->resetScene();
//加载场景文件
m_pRenderSystem->loadSceneFromResource(&parserExpat, theSceneDefine.c_str(), "General");
//释放未使用资源
{
Ogre::ResourceGroupManager& resManager = Ogre::ResourceGroupManager::getSingleton();
const Ogre::StringVector& strGroupVec = resManager.getResourceGroups();
for(int i=0; i<(int)strGroupVec.size(); i++)
{
if( strGroupVec[i] != Ogre::ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME &&
strGroupVec[i] != Ogre::ResourceGroupManager::BOOTSTRAP_RESOURCE_GROUP_NAME)
{
resManager.unloadUnreferencedResourcesInGroup(strGroupVec[i]);
}
}
}
//设置LightMap
m_pRenderSystem->getTerrain()->setLightmapQuality(WX::Terrain::LMQ_LOW);
m_pRenderSystem->getTerrain()->buildGeometry(m_pRenderSystem->getBaseSceneNode());
//取得环境特效
WX::SceneInfo::ObjectsByTypeRange objEnviroment =
m_pRenderSystem->getSceneInfo()->findObjectsByType("Enviroment");
if (objEnviroment.first != objEnviroment.second)
{
m_pEnviromentObject = static_cast< WX::EnviromentObject * >(objEnviroment.first->get());
TDAssert(m_pEnviromentObject);
}
else
{
m_pEnviromentObject = NULL;
}
}
CUIWindowItem::CUIWindowItem(const _DBC_UI_LAYOUTDEFINE* pLayoutDef)
{
TDAssert(pLayoutDef);
m_dwID = pLayoutDef->nID;
m_strWindowName = pLayoutDef->szName;
m_strLayoutFileName = pLayoutDef->szLayout;
m_strScriptFileName = pLayoutDef->szScript;
m_nIsCanDemise = pLayoutDef->nDemise;
m_pWindow = NULL;
m_bShow = FALSE;
m_bLayoutLoaded = FALSE;
}
VOID CFairyObject::GetActorLocator(LPCTSTR szName, fVector3& fvPosition)
{
TDAssert(m_pFairyObj);
//确认是人物模型
if(m_pFairyObj->getType() != EOBJ_TYPE_ACTOR) return;
//确认资源已经Load
Fairy::Actor* pActor = ((Fairy::ActorObject*)m_pFairyObj.get())->getActor();
if(!pActor) return;
DObject_NT* pDObj = ((Fairy::ActorObject*)m_pFairyObj.get())->getActor()->getImpl();
Ogre::Matrix4 mx;
pActor->getImpl()->GetLocatorWorldTransform(DString(szName), mx);
fVector3 fvGfx(mx[0][3], mx[1][3], mx[2][3]);
CRenderSystem::GetMe()->Axis_Trans(CRenderSystem::AX_GFX, fvGfx, CRenderSystem::AX_GAME, fvPosition);
}
VOID CActionSystem::UpdateAction_FromPetSkillStudy(const PET_SKILL* pSk)
{
TDAssert(pSk);
//检查时候已经有该操作
CActionItem_PetSkill* pSkillAction = (CActionItem_PetSkill*)GetAction_PetSkillID(pSk->m_nPetNum,pSk->m_pDefine->m_nID);
//AxTrace(0, 0, "Skill:%d", pSkill->m_pDefine->m_dwID);
//如果没有,创建
if(!pSkillAction)
{
pSkillAction = new CActionItem_PetSkill(_CreateID());
pSkillAction->Update_PetSkill(pSk);
//加入
m_mapAllAction[pSkillAction->GetID()] = pSkillAction;
}
else
{
pSkillAction->Update_PetSkill(pSk);
}
}
VOID CActionSystem::UpdateAction_FromLifeAbility(const SCLIENT_LIFEABILITY* pLifeAbility)
{
TDAssert(pLifeAbility);
//如果没有学会的技能，退出
if(pLifeAbility->m_nLevel <= 0) return;
if(pLifeAbility->m_pDefine == NULL)
return;
//检查时候已经有该操作
CActionItem_LifeAbility* pLifeAbilityAction = (CActionItem_LifeAbility*)GetAction_LifeAbilityID(pLifeAbility->m_pDefine->nID);
//如果没有,创建
if(!pLifeAbilityAction)
{
pLifeAbilityAction = new CActionItem_LifeAbility(_CreateID());
pLifeAbilityAction->Update_LifeAbility(pLifeAbility);
//加入
m_mapAllAction[pLifeAbilityAction->GetID()] = pLifeAbilityAction;
// UpdateToolBar();
}
}
VOID WINAPI CUIWindowItem::_OnGameEvent(const EVENT* pEvent, UINT dwOwnerData)
{
TDAssert(pEvent);
//--------------------------------------------------------
//分发
CUIWindowItem* pWinItem = (CUIWindowItem*)(DWORD_PTR)(dwOwnerData);
if(!pWinItem) return;
//加载
if(!(pWinItem->m_bLayoutLoaded))
{
pWinItem->LoadWindow();
}
//--------------------------------------------------------
//参数
for(INT i=0; i<(INT)pEvent->vArg.size(); i++)
{
CHAR szTemp[MAX_PATH];
_snprintf(szTemp, MAX_PATH, "arg%d", i);
g_pScriptSys->GetLuaState()->GetGlobals().SetString(szTemp, pEvent->vArg[i].c_str());
}
//--------------------------------------------------------
//调用脚本
CHAR szFunctionName[MAX_PATH];
_snprintf(szFunctionName, MAX_PATH, "%s_OnEvent",
pWinItem->m_strWindowName.c_str());
CHAR szFunctionParam[MAX_PATH];
_snprintf(szFunctionParam, MAX_PATH, "\"%s\"",
pEvent->pEventDef->szEvent);
pWinItem->m_pScriptEnv->DoFunction(szFunctionName, szFunctionParam);
}
VOID CWXObj_Object::SetWXObjectProperty(const char* szPropertyName, const char* szPropertyValue)
{
TDAssert(m_pWXObject);
m_pWXObject->setPropertyAsString(szPropertyName, szPropertyValue);
}
