bool ZSurvival::OnNPCDead(MCommand* pCommand)
{
MUID uidPlayer, uidNPC;
pCommand->GetParameter(&uidPlayer, 0, MPT_UID);
pCommand->GetParameter(&uidNPC, 1, MPT_UID);
ZActor* pActor = ZGetObjectManager()->GetNPCObject(uidNPC);
if (pActor)
{
pActor->OnDie();
ZGetObjectManager()->Delete(pActor);
m_GameInfo.IncreaseNPCKilled();
ZCharacter* pCharacter = ZGetCharacterManager()->Find(uidPlayer);
if (pCharacter)
{
ZModule_QuestStatus* pMod = (ZModule_QuestStatus*)pCharacter->GetModule(ZMID_QUESTSTATUS);
if (pMod)
{
pMod->AddKills();
}
}
}
return true;
}
void ZSurvival::UpdateNavMeshWeight(float fDelta)
{
// NavMesh 가중치 업데이트
if ((ZGetGame()->GetTime() - m_fLastWeightTime) >= 1.0f)
{
#ifdef _DEBUG
unsigned long int nLastTime = timeGetTime();
#endif
RNavigationMesh* pNavMesh = ZGetGame()->GetWorld()->GetBsp()->GetNavigationMesh();
if (pNavMesh != NULL)
{
pNavMesh->ClearAllNodeWeight();
ZNPCObjectMap* pNPCObjectMap = ZGetObjectManager()->GetNPCObjectMap();
for(ZNPCObjectMap::iterator i = pNPCObjectMap->begin();i!=pNPCObjectMap->end();i++)
{
ZObject* pNPCObject = i->second;
RNavigationNode* pNode = pNavMesh->FindClosestNode(pNPCObject->GetPosition());
if (pNode)
{
float fWeight = pNode->GetWeight() + 1.0f;
pNode->SetWeight(fWeight);
}
}
}
m_fLastWeightTime = ZGetGame()->GetTime();
}
}
void ZModule_HPAP::OnDamage(MUID uidAttacker,int damage, float fRatio)
{
m_LastAttacker = uidAttacker;
#ifndef _PUBLISH
if (CheckQuestCheet() == true) return;
#endif
if(m_bRealDamage)
{
ZObject* pAttacker = ZGetObjectManager()->GetObject(uidAttacker);
if ((pAttacker) && (!IsPlayerObject(pAttacker)))
{
ZActor* pActor = (ZActor*)pAttacker;
damage = (int)(damage * (pActor->GetQL() * 0.2f + 1));
}
int nHPDamage = (int)((float)damage * fRatio);
int nAPDamage = damage - nHPDamage;
if ((GetAP() - nAPDamage) < 0)
{
nHPDamage += (nAPDamage - GetAP());
nAPDamage -= (nAPDamage - GetAP());
}
SetHP(GetHP() - nHPDamage);
SetAP(GetAP() - nAPDamage);
}
}
bool ZEffectIcon::Draw(unsigned long int nTime)
{
ZObject* pObj = ZGetObjectManager()->GetObject(m_uid);
if(pObj) {
m_Pos = pObj->GetVisualMesh()->GetHeadPosition()+rvector(0,0,60);
return ZEffectAniMesh::Draw(nTime);
}
return false;
}
ZObject* ZBrain::GetTarget()
{
#ifdef _DEBUG
// 혼자서 AI 테스트할 경우
if ( (ZApplication::GetInstance()->GetLaunchMode() == ZApplication::ZLAUNCH_MODE_STANDALONE_QUEST) ||
(ZApplication::GetInstance()->GetLaunchMode() == ZApplication::ZLAUNCH_MODE_STANDALONE_AI))
{
return (ZObject*)ZGetGame()->m_pMyCharacter;
}
#endif
if ( ZGetObjectManager())
{
ZObject* pObject = ZGetObjectManager()->GetObject( m_uidTarget);
return pObject;
}
return NULL;
}
void ZSurvival::MoveToNextSector()
{
ZCharacter *pMyChar = ZGetGame()->m_pMyCharacter;
pMyChar->InitStatus();
// 새로운 월드로 이동!!
ZGetWorldManager()->SetCurrent(m_GameInfo.GetCurrSectorIndex());
// 이번에 이동할 캐릭터의 위치
int nPosIndex = ZGetCharacterManager()->GetCharacterIndex(pMyChar->GetUID(), false);
if (nPosIndex < 0) nPosIndex=0;
ZMapSpawnData* pSpawnData = ZGetWorld()->GetDesc()->GetSpawnManager()->GetSoloData(nPosIndex);
// 새 좌표로 이동
if (pSpawnData!=NULL && pMyChar!=NULL)
{
pMyChar->SetPosition(pSpawnData->m_Pos);
pMyChar->SetDirection(pSpawnData->m_Dir);
ZGetEffectManager()->AddReBirthEffect(pSpawnData->m_Pos);
}
// 유저 캐릭터를 보여주지 않는다
for(ZCharacterManager::iterator i = ZGetCharacterManager()->begin();i!=ZGetCharacterManager()->end();i++)
{
i->second->SetVisible(false);
}
// 현재 npc, 앞으로 생성될 npc, 이펙트, 탄환 전부 숨긴다 (다음 섹터 시작할때까지)
ZGetObjectManager()->GetNPCObjectMap()->SetVisibleAll(false);
ZGetObjectManager()->GetNPCObjectMap()->ForceInvisibleNewNpc(true);
ZGetEffectManager()->EnableDraw(false);
ZGetWorldItemManager()->EnableDraw(false);
ZGetGame()->m_WeaponManager.EnableRender(false);
// ko수 동기화
ZModule_QuestStatus* pMod = (ZModule_QuestStatus*)pMyChar->GetModule(ZMID_QUESTSTATUS);
if (pMod)
{
int nKills = pMod->GetKills();
ZGetScreenEffectManager()->SetKO(nKills);
}
}
bool ZSurvival::OnQuestCombatState(MCommand* pCommand)
{
char nState;
pCommand->GetParameter(&nState, 0, MPT_CHAR);
MQuestCombatState nCombatState = MQuestCombatState(nState);
m_QuestCombatState = nCombatState; // 보관..
switch (nCombatState)
{
case MQUEST_COMBAT_PREPARE:
{
}
break;
case MQUEST_COMBAT_PLAY:
{
ZGetObjectManager()->GetNPCObjectMap()->ForceInvisibleNewNpc(false);
ZGetEffectManager()->Clear();
ZGetEffectManager()->EnableDraw(true);
ZGetGame()->m_WeaponManager.EnableRender(true);
ZGetWorldItemManager()->EnableDraw(true);
}
break;
case MQUEST_COMBAT_COMPLETED:
{
// 서바이벌이므로 마지막 섹터라도 포탈을 찍어야 한다. 그러나 마지막 반복의 막판이라면 포탈을 없게한다
if (!m_GameInfo.IsLastSectorInSurvival())
{
if (ZGetGame())
{
rvector portal_pos;
int nCurrSectorIndex = m_GameInfo.GetCurrSectorIndex();
int nLinkIndex = m_GameInfo.GetMapSectorLink(nCurrSectorIndex);
portal_pos = ZGetGame()->GetMapDesc()->GetQuestSectorLink(nLinkIndex);
ZGetWorldItemManager()->AddQuestPortal(portal_pos);
m_GameInfo.SetPortalPos(portal_pos);
ZChatOutput(MCOLOR(ZCOLOR_CHAT_SYSTEM_GAME), ZMsg(MSG_GAME_OPEN_PORTAL));
m_tRemainedTime = timeGetTime() + PORTAL_MOVING_TIME;
m_bIsRoundClear = true;
}
}
}
break;
};
return true;
}
bool ZEffectLevelUp::Draw(unsigned long int nTime)
{
ZObject* pObj = ZGetObjectManager()->GetObject(m_uid);
if(pObj) {
if(pObj->m_pVMesh) {
// m_Pos = pObj->GetPosition() + m_vAddPos;
m_Pos = pObj->m_pVMesh->GetBipTypePosition(m_type);
m_DirOrg = pObj->m_Direction;
return ZEffectAniMesh::Draw(nTime);
}
}
return false;
}
void ZCharacterManager::Delete(MUID uid)
{
iterator itor = find(uid);
if (itor != end()) {
ZCharacter* pCharacter = (*itor).second;
ZGetObjectManager()->Delete((ZObject*)pCharacter);
ZGetGame()->m_VisualMeshMgr.Del(pCharacter->m_nVMID.Ref());
delete pCharacter; pCharacter = NULL;
erase(itor);
}
}
bool ZSurvival::OnPeerNPCBossHpAp(MCommand* pCommand)
{
MUID uidBoss;
float fHp, fAp;
pCommand->GetParameter(&uidBoss, 0, MPT_UID);
pCommand->GetParameter(&fHp, 1, MPT_FLOAT);
pCommand->GetParameter(&fAp, 2, MPT_FLOAT);
ZActor* pActor = ZGetObjectManager()->GetNPCObject(uidBoss);
if (pActor)
{
pActor->InputBossHpAp(fHp, fAp);
}
return true;
}
bool ZEffectPartsTypePos::Draw(unsigned long int nTime)
{
ZObject* pObj = ZGetObjectManager()->GetObject(m_uid);
if(pObj) {
if(pObj->m_pVMesh) {
if(pObj->IsDie())
return false;
m_Pos = pObj->m_pVMesh->GetBipTypePosition(m_type);
// m_DirOrg = pObj->m_Direction;
return ZEffectAniMesh::Draw(nTime);
}
}
return false;
}
bool ZEffectBerserkerIconLoop::Draw(unsigned long int nTime)
{
ZObject* pObj = ZGetObjectManager()->GetObject(m_uid);
ZCharacter* pChar = MDynamicCast(ZCharacter, pObj);
if( pChar ) {
if(!pChar->IsTagger()) return false;
if(!pChar->IsRendered()) return true;
if( pChar->m_pVMesh ) {
m_Pos = pObj->m_pVMesh->GetBipTypePosition(m_type);
m_DirOrg = -pChar->m_Direction;
ZEffectAniMesh::Draw(nTime);
return true;
}
}
return false;
}
bool ZSurvival::OnPeerNPCSkillExecute(MCommand* pCommand)
{
MUID uidOwner,uidTarget;
int nSkill;
rvector targetPos;
pCommand->GetParameter(&uidOwner, 0, MPT_UID);
pCommand->GetParameter(&nSkill, 1, MPT_INT);
pCommand->GetParameter(&uidTarget, 2, MPT_UID);
pCommand->GetParameter(&targetPos, 3, MPT_POS);
ZActor* pActor = ZGetObjectManager()->GetNPCObject(uidOwner);
if (pActor)
{
ZModule_Skills *pmod = (ZModule_Skills *)pActor->GetModule(ZMID_SKILLS);
pmod->Excute(nSkill,uidTarget,targetPos);
}
return true;
}
bool ZSurvival::OnEntrustNPCControl(MCommand* pCommand)
{
MUID uidChar, uidNPC;
pCommand->GetParameter(&uidChar, 0, MPT_UID);
pCommand->GetParameter(&uidNPC, 1, MPT_UID);
ZActor* pNPC = ZGetObjectManager()->GetNPCObject(uidNPC);
if (pNPC)
{
// uidChar이 내플레이어 UID이면 해당 NPC는 내가 조종하는 것이다.
bool bMyControl = (uidChar == ZGetGameClient()->GetPlayerUID());
pNPC->SetMyControl(bMyControl);
ZCharacter *pOwner = ZGetCharacterManager()->Find(uidChar);
if(pOwner)
pNPC->SetOwner(pOwner->GetUserName());
}
return true;
}
bool ZEffectShot::Draw(unsigned long int nTime)
{
if( m_isMovingPos ) {
ZObject* pObj = ZGetObjectManager()->GetObject(m_uid);
if(pObj) {
// if( MIsDerivedFromClass(ZCharacterObject, pObj )==false) return false;
// ZCharacterObject* pCObj = (ZCharacterObject*)pObj;
ZCharacterObject* pCObj = MDynamicCast(ZCharacterObject, pObj);
if(!pCObj) return false;
if(!pCObj->IsRendered())
return false;
rvector pos;
if(m_isLeftWeapon) {
if(pCObj->GetWeaponTypePos(weapon_dummy_muzzle_flash,&pos,true) ) {
m_Pos = pos;
m_Dir = pCObj->m_Direction;
Normalize(m_Dir);
}
}
else {
if(pCObj->GetWeaponTypePos(weapon_dummy_muzzle_flash,&pos) ) {
m_Pos = pos;
m_Dir = pCObj->m_Direction;
Normalize(m_Dir);
}
}
}
}
return ZEffectAniMesh::Draw(nTime);
}
bool ZEffectWeaponEnchant::Draw(unsigned long int nTime)
{
ZObject* pObj = ZGetObjectManager()->GetObject(m_uid);
if(pObj) {
if(pObj->m_pVMesh) {
// 무기모델이 안그려지면
RVisualMesh* pVMesh = pObj->m_pVMesh->GetSelectWeaponVMesh();//weapon_mesh
if(pVMesh)
if(!pVMesh->m_bIsRender) return false;
rmatrix m = pObj->m_pVMesh->GetCurrentWeaponPositionMatrix();
m_Pos = rvector(m._41,m._42,m._43);
m_DirOrg = rvector(m._21,m._22,m._23);
m_Up = rvector(m._11,m._12,m._13);
bool hr = ZEffectAniMesh::Draw(nTime);
// 양손에 무기에 대한처리
if( pObj->m_pVMesh->IsDoubleWeapon() )
{
m = pObj->m_pVMesh->GetCurrentWeaponPositionMatrix(true);
m_Pos = rvector(m._41,m._42,m._43);
m_DirOrg = rvector(m._21,m._22,m._23);
m_Up = rvector(m._11,m._12,m._13);
hr = ZEffectAniMesh::Draw(nTime);
}
return hr;
}
}
return false;
}
bool ZSurvival::OnPeerNPCDead(MCommand* pCommand)
{
MUID uidKiller, uidNPC;
pCommand->GetParameter(&uidKiller, 0, MPT_UID);
pCommand->GetParameter(&uidNPC, 1, MPT_UID);
ZActor* pActor = ZGetObjectManager()->GetNPCObject(uidNPC);
if (pActor)
{
pActor->OnPeerDie(uidKiller);
if (uidKiller == ZGetMyUID())
{
ZModule_QuestStatus* pMod = (ZModule_QuestStatus*)ZGetGame()->m_pMyCharacter->GetModule(ZMID_QUESTSTATUS);
if (pMod)
{
ZGetScreenEffectManager()->AddKO();
}
}
}
return true;
}
bool ZSurvival::OnNPCSpawn(MCommand* pCommand)
{
if (ZGetGame() == NULL) return false;
MUID uidChar, uidNPC;
unsigned char nNPCType, nPositionIndex;
pCommand->GetParameter(&uidChar, 0, MPT_UID);
pCommand->GetParameter(&uidNPC, 1, MPT_UID);
pCommand->GetParameter(&nNPCType, 2, MPT_UCHAR);
pCommand->GetParameter(&nPositionIndex, 3, MPT_UCHAR);
MQUEST_NPC NPCType = MQUEST_NPC(nNPCType);
ZMapSpawnType nSpawnType = ZMST_NPC_MELEE;
ZMapSpawnManager* pMSM = ZGetGame()->GetMapDesc()->GetSpawnManager();
MQuestNPCInfo* pNPCInfo = GetNPCInfo(NPCType);
if (pNPCInfo == NULL) return false;
switch (pNPCInfo->GetSpawnType())
{
case MNST_MELEE: nSpawnType = ZMST_NPC_MELEE; break;
case MNST_RANGE: nSpawnType = ZMST_NPC_RANGE; break;
case MNST_BOSS: nSpawnType = ZMST_NPC_BOSS; break;
default: _ASSERT(0);
};
ZMapSpawnData* pSpawnData = pMSM->GetSpawnData(nSpawnType, nPositionIndex);
if (pSpawnData == NULL)
{ // 보스 스폰지점이 없는 맵을 서바이벌맵으로 사용한 경우 그냥 밀리용 지점을 사용하자
if (nSpawnType == ZMST_NPC_BOSS)
pSpawnData = pMSM->GetSpawnData(ZMST_NPC_MELEE, nPositionIndex);
}
rvector NPCPos = rvector(0,0,0);
rvector NPCDir = rvector(1,0,0);
if (pSpawnData)
{
NPCPos = pSpawnData->m_Pos;
NPCDir = pSpawnData->m_Dir;
}
// 만약 리소스 로딩을 안했으면 로드 - 이럴일은 테스트빼곤 없어야한다.
// if (ZIsLaunchDevelop())
{
RMesh* pNPCMesh = ZGetNpcMeshMgr()->Get(pNPCInfo->szMeshName);
if (pNPCMesh)
{
if (!pNPCMesh->m_isMeshLoaded)
{
ZGetNpcMeshMgr()->Load(pNPCInfo->szMeshName);
ZGetNpcMeshMgr()->ReloadAllAnimation();
}
}
}
float fTC = m_GameInfo.GetNPC_TC();
////////// 하드코딩.. 특정 맵에서 npc 충돌 반지름을 플레이어의 반지름으로 강제한다 //////
bool bForceCollRadius35 = false;
if (m_GameInfo.GetMapSectorID(m_GameInfo.GetCurrSectorIndex()) == 207) // Prison_hall2
bForceCollRadius35 = true;
//////////////////////////////////////////////////////////////////////////////////////////
ZActor* pNewActor = ZActor::CreateActor(NPCType, fTC, m_GameInfo.GetQuestLevel(), bForceCollRadius35);
if (pNewActor)
{
bool bMyControl = (uidChar == ZGetGameClient()->GetPlayerUID());
pNewActor->SetMyControl(bMyControl);
pNewActor->SetUID(uidNPC);
pNewActor->SetPosition(NPCPos);
pNewActor->SetDirection(NPCDir);
ZCharacter *pOwner = ZGetCharacterManager()->Find(uidChar);
if(pOwner)
pNewActor->SetOwner(pOwner->GetUserName());
if(pNewActor->m_pVMesh) {
D3DCOLORVALUE color;
color.r = pNPCInfo->vColor.x;
color.g = pNPCInfo->vColor.y;
color.b = pNPCInfo->vColor.z;
color.a = 1.f;
pNewActor->m_pVMesh->SetNPCBlendColor(color);//색을 지정한 경우..
}
ZGetObjectManager()->Add(pNewActor);
ZGetEffectManager()->AddReBirthEffect(NPCPos);
if ((pNPCInfo->nGrade == NPC_GRADE_BOSS) || (pNPCInfo->nGrade == NPC_GRADE_LEGENDARY))
{
// 만약 보스급 NPC가 스폰하면 자동적으로 boss 등록
m_GameInfo.GetBosses().push_back(uidNPC);
// 바운딩볼륨이 큰 보스가 벽 근처에서 스폰될때 바운딩이 벽에 일부 묻힌 채로 스폰될 수가 있다
// 이렇게 되면 간혹 벽 뒤로 이동해버리는 경우가 발생 -> 보이지 않으므로 보스를 죽일 수 없다 -> 게임 진행 막힘
// 보스형 몬스터에 한해서 스폰할때 벽과 충돌체크를 해서 초기위치를 조정한다
if (pNewActor->IsMyControl()) {
float radius = bForceCollRadius35 ? 35.f : pNewActor->GetCollRadius();
if (true == ZGetGame()->GetWorld()->GetBsp()->CheckSolid(NPCPos, radius)) { // 맵에 충돌한다면.
OutputDebugString("보스몹 스폰지점 충돌검사 실패...\n");
// 가까운 네비게이션 노드의 중앙으로 옮겨버린다
RNavigationMesh* pNavMesh = ZGetGame()->GetWorld()->GetBsp()->GetNavigationMesh();
if (pNavMesh) {
RNavigationNode* pNavNode = pNavMesh->FindClosestNode(NPCPos);
if (pNavNode) {
pNewActor->SetPosition( pNavNode->CenterVertex());
OutputDebugString("스폰위치조정됨!\n");
}
}
}
}
}
}
return true;
}
void ZModule_HPAP::OnDamage(MUID uidAttacker,float fDamage, float fRatio)
{
_ASSERT(fDamage >= 0);
if (fDamage < 0) fDamage *= -1.f; // 해킹으로 음수대미지를 넣어서 회복할 수 있으므로..
m_LastAttacker = uidAttacker;
// 퀘스트 테스트용 치트 체크
#ifndef _PUBLISH
if (CheckQuestCheet() == true) return;
#endif
//jintriple3 디버그 레지스터 핵 방지 코드
//내 캐릭터가 아니거나 npc가 아니면....
//m_bRealDamage의 경우 내 클라이언트에서 실제로 데미지를 적용하나 안하나를 체크하는 변수.
//MyCharacter 이거나 NPC만 내 클라이언트에서 데미지 적용.
if(!m_bRealDamage.Ref())
PROTECT_DEBUG_REGISTER(!m_bRealDamage_DebugRegister) //이걸 위해 새로운 변수 하나 더 사용.
return;
// NPC의 난이도 조절계수때문에 넣음
ZObject* pAttacker = ZGetObjectManager()->GetObject(uidAttacker);
if ((pAttacker) && (!IsPlayerObject(pAttacker)))
{
ZActor* pActor = (ZActor*)pAttacker;
//fDamage = (int)(fDamage * (pActor->GetTC()));
fDamage = fDamage * (pActor->GetQL() * 0.2f + 1);
}
// 내가 죽기전까지 얻은 데미지를 누적한다(일단 듀얼토너먼트 전용임)
if(IsAccumulationDamage())
{
AccumulateDamage(fDamage);
#ifndef _PUBLISH // 내부빌드에서 누적 대미지 정보 출력
char szAccumulationDamagePrint[256];
sprintf(szAccumulationDamagePrint, "피해 당한 누적대미지[%2.1f]", GetAccumulationDamage());
ZChatOutput(MCOLOR(255, 200, 100), szAccumulationDamagePrint);
#endif
}
float fHPDamage = (float)((float)fDamage * fRatio);
float fAPDamage = fDamage - fHPDamage;
if ((GetAP() - fAPDamage) < 0)
{
fHPDamage += (fAPDamage - GetAP());
fAPDamage -= (fAPDamage - GetAP());
}
SetHP(GetHP() - fHPDamage);
SetAP(GetAP() - fAPDamage);
//jintriple3
/* if(m_bRealDamage)
{
// NPC의 난이도 조절계수때문에 넣음
ZObject* pAttacker = ZGetObjectManager()->GetObject(uidAttacker);
if ((pAttacker) && (!IsPlayerObject(pAttacker)))
{
ZActor* pActor = (ZActor*)pAttacker;
//damage = (int)(damage * (pActor->GetTC()));
damage = (int)(damage * (pActor->GetQL() * 0.2f + 1));
}*/
/*
float fHPDamage = 0, fAPDamage = 0;
fHPDamage = damage * fRatio;
fAPDamage = damage * (1.0f - fRatio);
*/
//jintripl3
/*
int nHPDamage = (int)((float)damage * fRatio);
int nAPDamage = damage - nHPDamage;
if ((GetAP() - nAPDamage) < 0)
{
nHPDamage += (nAPDamage - GetAP());
nAPDamage -= (nAPDamage - GetAP());
}
SetHP(GetHP() - nHPDamage);
SetAP(GetAP() - nAPDamage);
}*/
}
void ZCharacterManager::Add(ZCharacter *pCharacter)
{
insert(value_type(pCharacter->GetUID(), pCharacter));
ZGetObjectManager()->Add((ZObject*)pCharacter);
}
bool ZBrain::GetUseableSkill( int *pnSkill, MUID *puidTarget, rvector *pTargetPosition)
{
// Get skill module
ZModule_Skills *pmod = (ZModule_Skills *)m_pBody->GetModule(ZMID_SKILLS);
if ( !pmod)
return false;
// Set value
if ( puidTarget)
(*puidTarget) = MUID(0,0);
if (pTargetPosition)
(*pTargetPosition) = rvector(0.0f,0.0f,0.0f);
// Check skills
for ( int i = 0; i < pmod->GetSkillCount(); i++)
{
ZSkill *pSkill = pmod->GetSkill( i);
// Check cool time
if ( !pSkill->IsReady())
continue;
// Get skill description
ZSkillDesc *pDesc = pmod->GetSkill( i)->GetDesc();
// 스킬의 적용 대상이 아군인 경우...
if ( pDesc->IsAlliedTarget())
{
// 효과가 있는 대상중 가까이 있는 걸 찾는다.
float fDist = DIST_OUT;
ZObject *pAlliedTarget = NULL;
for ( ZObjectManager::iterator itor = ZGetObjectManager()->begin(); itor != ZGetObjectManager()->end(); ++itor)
{
ZObject *pObject = itor->second;
// 죽은 놈은 넘어간다
if ( pObject->IsDie())
continue;
// 적이면 넘어간다
if ( ZGetGame()->CanAttack(m_pBody,pObject))
continue;
// 자기 자신이면 넘어간다
if ( pObject == m_pBody)
continue;
// Get distance
float dist = MagnitudeSq( pObject->GetPosition() - m_pBody->GetPosition());
if ( pSkill->IsUsable( pObject) && ( dist < fDist))
{
fDist = dist;
pAlliedTarget = pObject;
}
}
// 만약 대상이 없으면 자기 자신한테라도 스킬을 건다.
if ( ( pAlliedTarget == NULL) && ( pSkill->IsUsable( m_pBody)))
pAlliedTarget = m_pBody;
if (pAlliedTarget)
{
if ( pnSkill)
*pnSkill = i;
if ( puidTarget)
*puidTarget = pAlliedTarget->GetUID();
if ( pTargetPosition)
*pTargetPosition = pAlliedTarget->GetCenterPos();
return true;
}
}
// 스킬의 적용 대상이 적군인 경우...
else
{
ZObject* pTarget = GetTarget();
if ( pTarget == NULL)
continue;
// Check useable
if ( !pSkill->IsUsable( pTarget))
continue;
// Get pick info
ZPICKINFO pickinfo;
memset( &pickinfo, 0, sizeof( ZPICKINFO));
// Check picking
rvector pos, tarpos, dir;
// 적과 나의 몸통 실린더에서 가슴 정도의 높이 지점끼리 피킹 쏴본다..
pos = m_pBody->GetPosition() + rvector( 0, 0, m_pBody->GetCollHeight()*0.5f*0.8f); // 가슴께로 낮춰주려고 *0.8
tarpos = pTarget->GetPosition() + rvector( 0, 0, pTarget->GetCollHeight()*0.5f*0.8f);
dir = tarpos - pos;
Normalize( dir);
const DWORD dwPickPassFlag = RM_FLAG_ADDITIVE | RM_FLAG_HIDE | RM_FLAG_PASSROCKET | RM_FLAG_PASSBULLET;
if ( ZGetGame()->Pick( m_pBody, pos, dir, &pickinfo, dwPickPassFlag))
{
if ( pickinfo.pObject)
{
if ( pnSkill)
*pnSkill = i;
if ( puidTarget)
*puidTarget = pTarget->GetUID();
if ( pTargetPosition)
*pTargetPosition = pTarget->GetCenterPos();
return true;
}
}
}
}
return false;
}
bool ZSurvival::OnClearAllNPC(MCommand* pCommand)
{
ZGetObjectManager()->ClearNPC();
return true;
}
bool ZSurvival::OnPeerNPCBasicInfo(MCommand* pCommand)
{
MCommandParameter* pParam = pCommand->GetParameter(0);
if(pParam->GetType()!=MPT_BLOB) return false;
ZACTOR_BASICINFO* ppbi= (ZACTOR_BASICINFO*)pParam->GetPointer();
ZBasicInfo bi;
bi.position = rvector(ppbi->posx,ppbi->posy,ppbi->posz);
bi.velocity = rvector(ppbi->velx,ppbi->vely,ppbi->velz);
bi.direction = 1.f/32000.f * rvector(ppbi->dirx,ppbi->diry,ppbi->dirz);
ZActor* pActor = ZGetObjectManager()->GetNPCObject(ppbi->uidNPC);
if (pActor)
{
pActor->InputBasicInfo(&bi, ppbi->anistate);
}
/*
// 캐릭터의 현재시간을 업데이트한다
// 캐릭터의 현재시간 추정치
float fCurrentLocalTime = pActor->m_fTimeOffset + GetTime();
// 캐릭터가 보내온 시간이 내가 추정한 시간과 3초 이상 차이가 나면 내가 알고있는 시간을 고친다.
float fTimeError = ppbi->fTime - fCurrentLocalTime;
if(fabs(fTimeError)>3.f) {
pCharacter->m_fTimeOffset = ppbi->fTime - GetTime();
pCharacter->m_fAccumulatedTimeError = 0;
pCharacter->m_nTimeErrorCount = 0;
}else
{
// 차이가 3초 이내이고 일정시간 합했다가 조금(차이의 반)씩 조절한다
pCharacter->m_fAccumulatedTimeError += fTimeError;
pCharacter->m_nTimeErrorCount ++;
if(pCharacter->m_nTimeErrorCount > 10) {
pCharacter->m_fTimeOffset += .5f*pCharacter->m_fAccumulatedTimeError/10.f;
pCharacter->m_fAccumulatedTimeError = 0;
pCharacter->m_nTimeErrorCount = 0;
}
}
// 현재시간을 마지막 데이터 받은시간으로 기록.
pCharacter->m_fLastReceivedTime = GetTime();
*/
/*
// 나중에 판정을 위해 histroy 에 보관한다.
if(bAddHistory)
{
ZBasicInfoItem *pitem=new ZBasicInfoItem;
CopyMemory(&pitem->info, &bi, sizeof(ZBasicInfo));
pitem->fReceivedTime=GetTime();
pitem->fSendTime= ppbi->fTime - pCharacter->m_fTimeOffset; // 내 기준으로 변환
pCharacter->m_BasicHistory.push_back(pitem);
while(pCharacter->m_BasicHistory.size()>CHARACTER_HISTROY_COUNT)
{
delete *pCharacter->m_BasicHistory.begin();
pCharacter->m_BasicHistory.erase(pCharacter->m_BasicHistory.begin());
}
}
if(bUpdate)
{
// 리플레이때를 제외하고 내 캐릭터는 모션이나 속도등등을 업데이트 할 필요가 없다.
if(!IsReplay() && pCharacter->IsHero()) return;
((ZNetCharacter*)(pCharacter))->SetNetPosition(bi.position, bi.velocity, bi.direction);
pCharacter->SetAnimationLower((ZC_STATE_LOWER)ppbi->lowerstate);
pCharacter->SetAnimationUpper((ZC_STATE_UPPER)ppbi->upperstate);
// 들고있는 무기가 다르면 바꿔준다
if(pCharacter->GetItems()->GetSelectedWeaponParts()!=ppbi->selweapon) {
pCharacter->ChangeWeapon((MMatchCharItemParts)ppbi->selweapon);
}
}
*/
return true;
}
bool ZEffectAniMesh::Draw(unsigned long int nTime)
{
if(m_VMesh.m_pMesh==NULL)
return false;
AniFrameInfo* pInfo = m_VMesh.GetFrameInfo(ani_mode_lower);
if(pInfo->m_pAniSet==NULL)// m_VMesh.m_pAniSet[0]==NULL
return false;
if(nTime < m_nStartTime + m_nStartAddTime) {
return true;
}
// 그리기가 연기 된경우 지금 상태의 캐릭터 데이터를 참조..
if( m_bDelay && !m_isCheck ) {
ZObject* pObj = ZGetObjectManager()->GetObject(m_uid);
ZCharacterObject* pCObj = MDynamicCast(ZCharacterObject, pObj);
if(pCObj) {
if(!pCObj->IsRendered())
return false;
rvector _vp = pCObj->GetPosition();
rvector _vdir = pCObj->m_Direction;
_vdir.z = 0;
Normalize(_vdir);
/*
int cm = g_pGame->SelectSlashEffectMotion(pObj);//남녀 칼 휘두르는 방향
if(cm==SEM_ManSlash5) {
_vdir.z = 0.f;
_vp += _vdir * 120.f;
_vp.z -= 100.f;
}
else if(cm==SEM_WomanSlash5) {
_vdir.z = 0.f;
_vp += _vdir * 200.f;
_vp.z -= 80.f;
}
*/
m_Pos = _vp;
m_Dir = _vdir;
}
m_isCheck = true;
}
DWORD dwDiff = nTime - m_nStartTime;
// float fSec = (float)dwDiff/1000.0f;
// float fOpacity = (SC_LIFETIME-dwDiff)/(float)SC_LIFETIME;
rvector Dir;
rvector Up=m_Up;
if (m_nAlignType == 0) {
Dir = -RCameraDirection;
}
else if( m_nAlignType == 1 )
{
Dir = m_DirOrg;
}
else if( m_nAlignType == 2 )
{
Dir = rvector( 0,1,0 );
Up = rvector( 0,0,1 );
}
CheckCross(Dir,Up);
rmatrix World;
MakeWorldMatrix(&World, m_Pos, Dir, Up);
rmatrix Rotation;
D3DXMatrixRotationZ(&Rotation,m_fRotateAngleZ);
World = Rotation * World;
D3DXMatrixRotationY(&Rotation,m_fRotateAngleY);
World = Rotation * World;
m_VMesh.SetScale(m_Scale);
m_VMesh.SetWorldMatrix(World);
m_VMesh.Frame(); // 시간은 흘러 가야 한다~
if(m_bRender) {
m_VMesh.Render();
m_bisRendered = m_VMesh.m_bIsRender;
}
else m_bisRendered = false;
if( m_nAutoAddEffect != ZEffectAutoAddType_None ) {
rvector vPos;
RMeshNode* pNode = NULL;
if(m_nAutoAddEffect == ZEffectAutoAddType_Methor ) {
pNode = m_VMesh.m_pMesh->GetMeshData("methor");
vPos.x = pNode->m_mat_result._41;
vPos.y = pNode->m_mat_result._42;
vPos.z = pNode->m_mat_result._43;
// static rmatrix _mrot = RGetRotY(180) * RGetRotX(90);
static rmatrix _mrot = RGetRotX(90);
vPos = vPos * _mrot;
vPos += m_Pos;
if(m_vBackupPos != vPos) {
ZGetEffectManager()->AddTrackMethor(vPos);
m_vBackupPos = vPos;
}
}
}
if( m_nLifeTime != -1 && m_bLoopType ) {// 소멸 시간이 정해져 있고..에니메이션이 루프 타잎인 경우..
if(m_VMesh.isOncePlayDone())
if(nTime > m_nStartTime + m_nLifeTime) {
return false;
}
}
else {
if(m_VMesh.isOncePlayDone()) {
return false;
}
}
return true;
}
bool ZGameInput::OnDebugEvent(MEvent* pEvent)
{
#ifdef _PUBLISH
return false;
#endif
static bool bMusicMute = false;
switch(pEvent->nMessage){
case MWM_KEYDOWN:
{
switch (pEvent->nKey)
{
case VK_END:
{
ZGetGameInterface()->m_bTeenVersion = !ZGetGameInterface()->m_bTeenVersion;
}
return true;
case VK_INSERT:
{
g_debug_render_mode++;
if(g_debug_render_mode > 3)
g_debug_render_mode = 0;
}
return true;
case VK_DELETE:
{
g_bVertex_Soft = !g_bVertex_Soft;
}
return true;
//---------------------------------------------------------------------------------------------------
// VK_F1 부터 VK_F8 까지는 새로운 키맵핑을 위해, Ctrl을 눌렀을 때 동작하도록 수정!
// Added By 홍기주
case VK_F1:
{
if( pEvent->bCtrl ) {
ZGetGame()->m_pMyCharacter->SetVisible( !ZGetGame()->m_pMyCharacter->IsVisible() );
}
return false;
}
case VK_F2:
{
if( pEvent->bCtrl ) {
ZGetGameInterface()->ShowInterface( !ZGetGameInterface()->IsShowInterface() );
}
return false;
}
case VK_F3:
{
if( pEvent->bCtrl ) {
if (ZIsLaunchDevelop()) {
ZApplication::GetGameInterface()->GetScreenDebugger()->SwitchDebugInfo();
return true;
}
}
return false;
}
case VK_F4:
{
if( pEvent->bCtrl ) {
ZGetGame()->m_bShowWireframe=!ZGetGame()->m_bShowWireframe;
return true;
}
return false;
}
case VK_F5:
{
if( pEvent->bCtrl ) {
m_bCTOff = !m_bCTOff;
RMesh::SetTextureRenderOnOff(m_bCTOff);
return true;
}
return false;
}
case VK_F6:
{
if( pEvent->bCtrl ) {
g_debug_rot =!g_debug_rot;
return true;
}
return false;
}
case VK_F7:
{
if( pEvent->bCtrl ) {
// 프로파일링 시작/끝
extern bool g_bProfile;
if(g_bProfile) {
ZPOSTCMD0(ZC_END_PROFILE);
ZChatOutput("Profile saved.");
} else {
ZPOSTCMD0(ZC_BEGIN_PROFILE);
ZChatOutput("Profile started.");
}
return true;
}
return false;
}
case VK_F8:
{
if( pEvent->bCtrl ) {
RSolidBspNode::m_bTracePath = !RSolidBspNode::m_bTracePath;
}
return false;
}
case VK_F9:
{
static int nIndex = 0;
nIndex++; if (nIndex >= 2) nIndex = 0;
if (nIndex == 0)
{
ZGetGameInterface()->m_bViewUI = true;
ZGetGameInterface()->GetGame()->m_pMyCharacter->SetVisible(true);
}
else if (nIndex == 1)
{
ZGetGameInterface()->m_bViewUI = false;
ZGetGame()->m_pMyCharacter->SetVisible(false);
ZGetGameInterface()->GetCombatInterface()->ShowCrossHair(false);
}
}
return false;
case 'U': {
ZC_ENCHANT zctype;
// int Module = 20;
if(ZGetGame() && ZGetGame()->m_pMyCharacter ) {
zctype = ZGetGame()->m_pMyCharacter->GetEnchantType();
// if(zctype==ZC_ENCHANT_FIRE) Module = ZMID_FIREDAMAGE;
// else if(zctype==ZC_ENCHANT_COLD) Module = ZMID_COLDDAMAGE;
// else if(zctype==ZC_ENCHANT_LIGHTNING) Module = ZMID_LIGHTNINGDAMAGE;
// else if(zctype==ZC_ENCHANT_POISON) Module = ZMID_POISONDAMAGE;
if(zctype==ZC_ENCHANT_FIRE) {
ZModule_FireDamage *pModule = (ZModule_FireDamage*)ZGetGame()->m_pMyCharacter->GetModule(ZMID_FIREDAMAGE);
pModule->BeginDamage(ZGetGame()->m_pMyCharacter,5,10);
}
else if(zctype==ZC_ENCHANT_COLD) {
ZModule_ColdDamage *pModule = (ZModule_ColdDamage*)ZGetGame()->m_pMyCharacter->GetModule(ZMID_COLDDAMAGE);
pModule->BeginDamage(10,50);
}
else if(zctype==ZC_ENCHANT_LIGHTNING) {
ZModule_LightningDamage *pModule = (ZModule_LightningDamage*)ZGetGame()->m_pMyCharacter->GetModule(ZMID_LIGHTNINGDAMAGE);
pModule->BeginDamage(ZGetGame()->m_pMyCharacter,5,10);
}
else if(zctype==ZC_ENCHANT_POISON) {
ZModule_PoisonDamage *pModule = (ZModule_PoisonDamage*)ZGetGame()->m_pMyCharacter->GetModule(ZMID_POISONDAMAGE);
pModule->BeginDamage(ZGetGame()->m_pMyCharacter,5,10);
}
}
//g_pGame->m_pMyCharacter->ShotBlocked();
// ZApplication::GetSoundEngine()->StopMusic();
//ZApplication::GetSoundEngine()->load_preset();
}break;
case 'M':
{
if (ZApplication::GetInstance()->GetLaunchMode()==ZApplication::ZLAUNCH_MODE_STANDALONE_GAME)
{
// 혼자테스트할때 되살아나기
if (ZGetGame()->GetMatch()->IsTeamPlay())
{
ZCharacter* pCharacter = ZGetGame()->m_pMyCharacter;
pCharacter->InitStatus();
rvector pos=rvector(0,0,0), dir=rvector(0,1,0);
static int nTeamIndex = 0;
static int nSpawnIndex = 0;
ZMapSpawnData* pSpawnData = ZGetGame()->GetMapDesc()->GetSpawnManager()->GetTeamData(nTeamIndex, nSpawnIndex);
if (pSpawnData != NULL)
{
pos = pSpawnData->m_Pos;
dir = pSpawnData->m_Dir;
}
pCharacter->SetPosition(pos);
pCharacter->SetDirection(dir);
nSpawnIndex++;
if (nSpawnIndex >= 16)
{
nSpawnIndex = 0;
nTeamIndex++;
if (nTeamIndex >= 2) nTeamIndex=0;
}
}
else
{
if(ZGetGame()->m_CharacterManager.size()==1)
ZGetGameInterface()->RespawnMyCharacter();
}
}
}break;
case 'C' : {
// ZModule_Skills *pmod = (ZModule_Skills *)g_pGame->m_pMyCharacter->GetModule(ZMID_SKILLS);
// pmod->Excute(0,MUID(0,0),rvector(0,0,0));
// g_pGame->UpdateCombo(true);
}break;
#ifdef _DEBUG
case 'G' : {
// MNewMemories::Dump();
// g_pGame->m_pMyCharacter->m_bGuardTest=!g_pGame->m_pMyCharacter->m_bGuardTest;
}break;
#endif
// 테스트용..
case 'I' : ZGetGame()->m_pMyCharacter->AddIcon(rand()%5); return true;
// 테스트^^
case 'F' : DumpFontTexture(); return true;
// case 'F' :
// {
// static bool toggle = false;
// if(toggle)
// ZGetInput()->SetDeviceForcesXY(1,1);
// else
// ZGetInput()->SetDeviceForcesXY(0,0);
// toggle=!toggle;
// return true;
// }
case 'L' :
{
// rvector pos = g_pGame->m_pMyCharacter->GetPosition();
// pos.x += 1000.0f;
// ZApplication::GetSoundEngine()->PlayNPCSound(NPC_GOBLIN, NPC_SOUND_WOUND, pos, true);
ZApplication::GetGameInterface()->FinishGame();
// ZGetScreenEffectManager()->AddScreenEffect("teamredwin");
/*
g_pGame->m_pMyCharacter->m_Position = rvector( 2712.99805 , -1691.46191 , 2649.13403 );
g_pGame->m_pMyCharacter->Move(rvector( 2.561 , -7.040 , -6.471 ));
*/
/*
g_pGame->m_pMyCharacter->m_Position = rvector( 2713.05347 , -1691.56250 , 2929.06738 );
g_pGame->m_pMyCharacter->Move(rvector( 0.00000000 , 0.00000000 , -2.07031250 ));
*/
/*
g_pGame->m_pMyCharacter->m_Position = rvector( 1648.73877 ,8691.30176 ,1501.03381 -120);
g_pGame->m_pMyCharacter->Move(rvector( -0.134,0.004, -0.986 ));
g_pGame->m_pMyCharacter->m_Velocity = rvector( -450,0,0);
ZPostLocalMessage(MSG_HACKING_DETECTED);
ZGetEffectManager()->AddShotgunEffect(rvector(0,0,100),rvector(0,0,100),rvector(0,1,0),g_pGame->m_pMyCharacter);
*/
}break;
case 'K':
{
// rvector pos = g_pGame->m_pMyCharacter->GetPosition();
// pos.x += 1000.0f;
// ZApplication::GetSoundEngine()->PlayNPCSound(NPC_GOBLIN, NPC_SOUND_WOUND, pos, false);
// ZGetGameInterface()->GetCamera()->Shock(2000.f, .5f, rvector(0.0f, 0.0f, -1.0f));
ZGetScreenEffectManager()->ShockBossGauge(35.0f);
static int n = 0; n++;
ZGetScreenEffectManager()->AddKO(n);
// g_pGame->m_pMyCharacter->OnBlast(rvector(1,0,0));
// ZGetGameInterface()->GetCamera()->Shock(500.f, .5f, rvector(0.0f, 0.0f, -1.0f));
}break;
case 'B':
{
// test
ZCombatInterface* pCombatInterface = ZGetGameInterface()->GetCombatInterface();
pCombatInterface->SetObserverMode(!pCombatInterface->GetObserver()->IsVisible());
}
return true;
case 'N':
{
ZCombatInterface* pCombatInterface = ZGetGameInterface()->GetCombatInterface();
if(pCombatInterface->GetObserverMode())
pCombatInterface->GetObserver()->ChangeToNextTarget();
}
return true;
case 'P':
{
// test
// g_pGame->m_pMyCharacter->OnKnockback(rvector(1.0f, 0.0f, 0.0f),200.f);
ZGetEffectManager()->AddMethorEffect(rvector(0,0,0) , 1 );
}
return true;
case 'O':
{
if (ZApplication::GetInstance()->GetLaunchMode()==ZApplication::ZLAUNCH_MODE_STANDALONE_AI)
{
ZGetObjectManager()->ClearNPC();
// npc 생성 test
MUID uidNPC = MUID(0,0);
uidNPC.High = rand() % RAND_MAX;
uidNPC.Low = rand() % RAND_MAX;
int nNPCType = rand() % NPC_GOBLIN_KING+1;
nNPCType = NPC_GOBLIN_GUNNER;
rvector ranpos = rvector(0, 0, 0);
MQuestNPCInfo* pNPCInfo = NULL;
if(ZGetQuest())
pNPCInfo = ZGetQuest()->GetNPCInfo(MQUEST_NPC(nNPCType));
ZActor* pNewActor = ZActor::CreateActor(MQUEST_NPC(nNPCType), 1.0f, 0);
if (pNewActor)
{
pNewActor->SetUID(uidNPC);
pNewActor->SetPosition(ranpos);
pNewActor->SetMyControl(true);
if(pNewActor->m_pVMesh && pNPCInfo) {
D3DCOLORVALUE color;
color.r = pNPCInfo->vColor.x;
color.g = pNPCInfo->vColor.y;
color.b = pNPCInfo->vColor.z;
color.a = 1.f;
pNewActor->m_pVMesh->SetNPCBlendColor(color);//색을 지정한 경우..
}
ZGetObjectManager()->Add(pNewActor);
ZGetEffectManager()->AddReBirthEffect(ranpos);
}
}
}
return true;
/*
case VK_HOME:
if(ZGetGameInterface()->GetGame()) {
RFrameTime* ft = &ZGetGameInterface()->GetGame()->m_pMyCharacter->m_pVMesh->m_FrameTime;
if( ft->m_bActive ) {
ft->Stop();
}
else {
ft->Start(20,300);
}
}
return true;
*/
// 앞으로는 NUMPAD는 매크로로 사용될 것이다. 하하!
// 그러므로, NUMPAD1~NUMPAD9는 Return false로 수정!
case VK_NUMPAD0: ZGetGameInterface()->TestToggleCharacter();return true;
case VK_NUMPAD1: ZGetGameInterface()->TestChangeParts(0); return false;
case VK_NUMPAD2: ZGetGameInterface()->TestChangeParts(1); return false;
case VK_NUMPAD3: ZGetGameInterface()->TestChangeParts(2); return false;
case VK_NUMPAD4: ZGetGameInterface()->TestChangeParts(3); return false;
case VK_NUMPAD5: ZGetGameInterface()->TestChangeParts(4); return false;
case VK_NUMPAD6: ZGetGameInterface()->TestChangeParts(5); return false;
case VK_NUMPAD7: ZGetGameInterface()->TestChangeWeapon(); return false;
case VK_NUMPAD9:
bMusicMute = !bMusicMute;
ZGetSoundEngine()->SetMusicMute(bMusicMute);
return false;
/* 이게 뭐꼬 ? -_-
case VK_OEM_3: // `
{
ZGetGameInterface()->SetCursorEnable(
!ZGetGameInterface()->IsCursorEnable());
}
return true;
*/
#ifdef USING_VERTEX_SHADER
case 'V':
{
//RShaderMgr::shader_enabled = !RShaderMgr::shader_enabled;
RShaderMgr::mbUsingShader = !RShaderMgr::mbUsingShader;
}
return false;
#endif
}
}
break;
} // switch
return false;
}
