// Character.cpp: implementation of the Character class. // ////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include #include <3DEngine/3DTerrain/PathExplorer.h> #include <3DEngine/3DTerrain/3DTerrain.h> #include <3DEngine/3DTerrain/WorldBase.h> #include #include #include #include #include #include #include #include #include #include "Character.h" #include "FieldServer.h" #include "FieldInfo.h" #include "GameField.h" #include "AITypes.h" #include "NPC.h" #include "SyncMerchant.h" #include "SummonedNPCs.h" #include "GameParty.h" #include "GamePartyManager.h" #include "Map.h" #include "StatusManager.h" #include "AbilityStatus.h" #include "SummonManager.h" #include "CharacterFormula.h" #include "AIParamParser.h" #include "EtcStatus.h" #include "StatusManager.h" #include "RecoverStatus.h" #include "Summoned.h" #include "MoveStateControl.h" #include "TargetManager.h" #include "Skill.h" #include "GameCHuntingRoom.h" #include "CHuntingManager.h" #include "ItemManager.h" #include "Player.h" #include "SkillManager.h" #include "MovementChecker.h" #include "GameInstanceDungeon.h" #include "World/ChaosZoneSystem/ChaosZoneManager.h" #include "MovingPlanner.h" #include #include "GameBattleResult.h" //_NA_0_20091118_GAMEROOM_BATTLE_RESULT #include "ExtraNPCManager.h" //_NA_005026_20120527_CHAOS_ZONE_BATTLE_GROUND #include class AIMessageSender { public: AIMessageSender(AI_MSG* message, WORD message_size) : message_(message), message_size_(message_size) { ASSERT(message != NULL); ASSERT(message_size > 0); } bool operator() (Object* const object) { if (object == NULL) { return false; } //#ifdef _NA_004126_20120111_CHANGE_GAME_SERVER_OBJECT_FACTORY if (object->IsDeleted()) { return false; } //#endif if (message_ == NULL) { return false; } if (message_size_ < 1) { return false; } Character* const character = dynamic_cast(object); if (character == NULL) { return false; } character->SendAIMessage(message_, message_size_); return true; } private: AI_MSG* message_; WORD message_size_; }; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// Character::Character() : PlanEvent(m_pPathExplorer, m_pSkillManager, m_pStatusManager), used_fighting_energy_size_(0), team_key_(kChaosZoneTeamNone) { SetObjectType(CHARACTER_OBJECT); Object::_SetPosVector(m_pPathExplorer->GetPosPtr()); WzVector wzVec = { 0, 0, 0 }; SetPos(&wzVec); m_pStatusManager = new StatusManager(this); m_pMoveStateControl = new MoveStateControl; m_pSkillManager = new SkillManager(this); m_dwReserveHP = 0; //적립된 HP m_dwDeadReserveHP = 0; //죽었을시 적립된 HP m_DeadType = eCHAR_DEAD_NOT_DEAD; } Character::~Character() { #ifndef _SUSUNLOVE_DRIVE_NOT_FOUND_ g_pGameServer->m_fnContactTerrain(CT_DELETE_PATH_EXPLORER, m_pPathExplorer); #endif SAFE_DELETE(m_pStatusManager); SAFE_DELETE(m_pMoveStateControl); SAFE_DELETE(m_pSkillManager); m_dwReserveHP = 0; //적립된 HP m_dwDeadReserveHP = 0; //죽었을시 적립된 HP } BOOL Character::Init() { Policyment.SetField(Policyment.PCC_IN_DEF_FIELD); ZeroMemory(m_iEnemySlot, sizeof(int)*MAX_ENEMYSLOT_NUM); m_PartyState.Init(); // 스킬관련 m_iShieldHP = 0; m_iShieldMP = 0; decrease_MP_Ratio = 0; m_fShieldAbsorbRatio = 0; m_sFightingEnergyCount = 0; used_fighting_energy_size_ = 0; // 사망 경험치 손해 m_DeadExp = 0; m_dwSummonerKey = 0; SetGameZone(ePRS_NOT_AT_ZONE, NULL, 0); // 길찾기 초기화 m_pPathExplorer->Clear(); PlanEvent.Init(this); m_dwReserveHP = 0; //적립된 HP m_dwDeadReserveHP = 0; //죽었을시 적립된 HP m_pSkillManager->Init(); // (CHANGES) (f100514.3L) add an initializer because of the status without a 'GetField' check // has somehow corrupted the data integrity. m_pStatusManager->Release(); return Object::Init(); } void Character::Release() { // (WAVERIX) (090607) (BUG-FIX) 쉐도우 잘못된 타입 비교 구문 수정 // // 섀도우는 한 서버안에서는 계속 소환체를 유지한다. // // 따라서 Release시에만 소환체를 삭제한다. //__NA_S00015_20080828_NEW_HOPE_SHADOW // if((GetObjectType() & eCHAR_SHADOW) == eCHAR_SHADOW) // SummonManager::Instance()->LeaveSummonNPCs(this); //#endif m_Observers.RemoveAll(); Object::Release(); PlanEvent.Release(); m_pStatusManager->Release(); m_pSkillManager->Release(); m_dwReserveHP = 0; //적립된 HP m_dwDeadReserveHP = 0; //죽었을시 적립된 HP } BOOL Character::Update(DWORD dwDeltaTick) { if(Object::Update(dwDeltaTick) == false) return false; DWORD curTick = GetTickCount(); m_pStatusManager->Update(curTick); m_pSkillManager->Update(); return true; } void Character::SetField(GameField* pField) { Object::SetField(pField); } void Character::SetPos(const WzVector* pwzVec) { GameField* const pGameField = GetField(); if(!pGameField) return; pGameField->GetMovingPlanner()->PathPlan_Reset(this, pwzVec); } void Character::GetDestPos(WzVector* pWzVecOut) const { *pWzVecOut = m_pPathExplorer->GetCurTargetPos(); } //-------------------------------------------------------------------------------------------------- void Character::SendPacketAround(MSG_BASE_FORWARD* pMsg, WORD wSize, BOOL bSendToMe) { GameField* const pField = GetField(); if(!pField) return; const SECTOR_IDX current_sector_index = GetSectorIndex(); pField->SendPacketAround(current_sector_index, pMsg, wSize, bSendToMe ? 0 : GetObjectKey()); } //-------------------------------------------------------------------------------------------------- void Character::SendExPacketAround(DWORD dwNumberOfMessages, BYTE** pMsg, WORD* pwSize, BOOL bSendToMe) { GameField* const pField = GetField(); if(!pField) return; const SECTOR_IDX current_sector_index = GetSectorIndex(); pField->SendExPacketAround(current_sector_index, dwNumberOfMessages, pMsg, pwSize, bSendToMe ? 0 : GetObjectKey()); } //-------------------------------------------------------------------------------------------------- WzVector Character::GetRandomPosInAround(int iDist, int iLoop) { WzVector vCurPos; GetPos(&vCurPos); if(!GetField()) { SUNLOG(eCRITICAL_LOG, "[Character::GetRandomPosInAround] Field is NULL!"); return vCurPos; } WzVector vDestPos; if(!GetField()->GetRandomPosInAround(&vCurPos, iDist, vDestPos, iLoop)) { // 그렇게 크리티컬하지 않으므로 로그는 뺀다. return vCurPos; } return vDestPos; } // 1차... 좀더 time slicing을 수행해야 하는 구조로 변경해야 한다. // 길찾기 경로 설정 BOOL Character::SetPath(WzVector* pwvCur, WzVector* pwvDest, int* pTileRoute, int iNumTileRoute) { const DWORD ERRCODE_INVALID_STATUS = 100; const DWORD ERRCODE_INVALID_POSITION = 110; ////////////////////////////////////////////////////////////////////////// // FlowControl flow; FLOWCONTROL_START() { GameField* const pGameField = GetField(); IfFailThenBreak(pGameField, ERRCODE_INVALID_STATUS); IfFailThenBreak(WzVector_FiniteCheck(pwvCur) && WzVector_FiniteCheck(pwvDest), ERRCODE_INVALID_POSITION); // TODO(WAVERIX) 이 부분 재 검증할 것. SetPos(pwvCur); // 이전에 존재하던 제약 조건들은 Moving Planner에서 검증하게 될 것이다. nsAI::MovingPlanner* const pMovingPlanner = pGameField->GetMovingPlanner(); return pMovingPlanner->PathPlan_SetPath(this, pwvDest, pTileRoute, iNumTileRoute); } FLOWCONTROL_END; ////////////////////////////////////////////////////////////////////////// // switch(const DWORD errcode = flow.GetErrorCode()) { case ERRCODE_INVALID_POSITION: SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"] Pos is Invalid x:y:z={%f,%f,%f} | x:y:z={%f,%f,%f}" , pwvCur->x, pwvCur->y, pwvCur->z, pwvDest->x, pwvDest->y, pwvDest->z); break; default: SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"] Error %u", errcode); break; } return false; } // 1차... 좀더 time slicing을 수행해야 하는 구조로 변경해야 한다. // 길찾기 수행 BOOL Character::PathProgress(float fMove, ENUM_CHECK_COLLISION CollisionCheck) { //fMove = 거리 = 시간* 속도 GameField* const pGameField = GetField(); const BOOLEAN bRet = pGameField->GetMovingPlanner()->PathPlan_Progress(this, fMove, NULL, CollisionCheck); return bRet; } // 1차... 좀더 time slicing을 수행해야 하는 구조로 변경해야 한다. void Character::StopMoving() { m_pPathExplorer->Stop(); } // 1차... 좀더 time slicing을 수행해야 하는 구조로 변경해야 한다. BOOL Character::IsMoving() { return m_pPathExplorer->IsMoving(); } DWORD Character::IncreaseHP(DWORD dwIncreament) { const DWORD curHP = GetHP(); const DWORD calcedHP = curHP + dwIncreament; const DWORD maxHP = GetMaxHP(); const DWORD hp = min(maxHP, calcedHP); dwIncreament = hp - curHP; SetHP(hp); if(dwIncreament) { m_pStatusManager->ChangeHP(); } return dwIncreament; } DWORD Character::DecreaseHP(DWORD dwDecrement, int fLimitHP) { DWORD curHP = GetHP(); BOOL isDead = false; if (curHP == 0) { return 0; } // removed by __NA_001290_20090525_SHIELD_SYSTEM // 쉴드에 의해 방어되는 HP 수치를 구한다. //ApplyMagicShield(dwDecrement); //__BUG_2572_SPIRIT_SLUG_BUG if(fLimitHP > 0 && fLimitHP > ((int)curHP - (int)dwDecrement)) { if(curHP > (DWORD)fLimitHP) { dwDecrement = curHP - fLimitHP; } else { dwDecrement = 0; } } if(curHP <= dwDecrement) // 남은 HP보다 더 많이 줄어들면 죽는거다~ { dwDecrement = curHP; SetHP(0); OnDead(); isDead = true; } else { DWORD hp = curHP - dwDecrement; SetHP(hp); } m_pStatusManager->ChangeHP(); if(isDead) { #ifdef _JAPAN //일본은 지역점령전에서 스스로 부할을 할수 없다. GameZone* zone = GetGameZonePtr(); if(zone) { const sPOLICY_ZONE& zone_policy = zone->Policyment; if (zone_policy.FIELD & zone_policy.ENABLE_DOMINATION_CONTROL) { return dwDecrement; } } #endif int resurrect = random(0, 100); if(resurrect < GetAttr().GetResurrectionRatio()) { OnResurrection(0, 1.f, 1.f); } } return dwDecrement; } DWORD Character::IncreaseMP(DWORD dwIncreament) { const DWORD curMP = GetMP(); const DWORD calcedMP = curMP + dwIncreament; const DWORD maxMP = GetMaxMP(); DWORD mp = min(maxMP, calcedMP); dwIncreament = mp - curMP; SetMP(mp); return dwIncreament; } DWORD Character::DecreaseMP(DWORD dwDecrement) { DWORD curMP = GetMP(); if (curMP <= dwDecrement) { dwDecrement = curMP; SetMP(0); } else { DWORD mp = curMP - dwDecrement; SetMP(mp); } return dwDecrement; } //{__NA_001290_20090525_SHIELD_SYSTEM DWORD Character::IncreaseSD(DWORD dwIncreament) { const DWORD curSD = GetSD(); const DWORD maxSD = GetMaxSD(); const DWORD calcedSD = curSD + dwIncreament; const DWORD newSD = min(maxSD, calcedSD); const BOOL bAllocStatus = (0==curSD && 0!=newSD); const DWORD dwRealIncreament = newSD-curSD; SetSD(newSD); if(bAllocStatus) { ALLOC_STATUS_PAIR pairBaseStatus = m_pStatusManager->AllocStatus(eCHAR_STATE_ETC_EXIST_SHELD_POINT); if(pairBaseStatus.second) pairBaseStatus.second->SendStatusAddBRD(); } return dwRealIncreament; } DWORD Character::DecreaseSD(DWORD dwDecrement) { const DWORD curSD = GetSD(); if (curSD <= dwDecrement) { dwDecrement = curSD; SetSD(0); m_pStatusManager->Remove(eCHAR_STATE_ETC_EXIST_SHELD_POINT); } else { const DWORD newSD = curSD - dwDecrement; SetSD(newSD); } return dwDecrement; } // 데미지 감소 순서 조정, 소스정리 [8/14/2009 lst1024] DAMAGETYPE Character::_ApplyMagicShield(DAMAGETYPE wDamage) { if((!m_iShieldMP && decrease_MP_Ratio == 0) || !m_iShieldHP) return wDamage; //DWORD character_MaxMP = GetMaxMP(); DWORD decrease_MP = 0; #ifdef _NA_006621_20130408_MAGICSHILD_MP_DECREASE decrease_MP = (DWORD)(wDamage * decrease_MP_Ratio); #else decrease_MP = m_iShieldMP; #endif //_NA_006621_20130408_MAGICSHILD_MP_DECREASE if((int)GetMP() < decrease_MP) // MP가 부족하면 쉴드가 적용 안된다. return wDamage; int iAbsorbDamage = (int)(wDamage * m_fShieldAbsorbRatio); iAbsorbDamage = min(iAbsorbDamage, m_iShieldHP); // 흡수 데미지는 쉴드HP 보다 낮고 iAbsorbDamage = max(iAbsorbDamage, 0); // 0보다 큰 값이다. iAbsorbDamage = min(iAbsorbDamage, (int)wDamage); // 현재 데미지 보다 클수 없다. m_iShieldHP -= iAbsorbDamage; SetMP(GetMP() - decrease_MP); if(0 >= m_iShieldHP) { m_iShieldHP = 0; m_pStatusManager->Remove(eCHAR_STATE_MAGIC_SHIELD); } return wDamage - iAbsorbDamage; // 매직쉴드가 적용된 데미지를 리턴한다. } BYTE Character::AllocEnemySlot(WzVector* pwvEnemyPos, WzVector& wvResultPos, float fAreaRadius) { // pwzVec를 기준으로 가장 근접한 InitSlot를 구해준다. WzVector vCurPos = m_pPathExplorer->GetPos(); WzVector diffVec =* pwvEnemyPos - vCurPos; int CurAngle = Math_GetAngleFromVector2(&diffVec); int UnitAngle = 360 / MAX_ENEMYSLOT_NUM; int InitSlot = (int)(CurAngle / UnitAngle); if(InitSlot >= MAX_ENEMYSLOT_NUM) InitSlot -= MAX_ENEMYSLOT_NUM; int MidAngle = (int)(UnitAngle* (InitSlot + 0.5f)); if(InitSlot < 0 || InitSlot > MAX_ENEMYSLOT_NUM) { SUNLOG(eCRITICAL_LOG, "[AllocEnemySlot] Invalid InitSlot[%d] CurAngle[%d]", InitSlot, CurAngle); InitSlot = 0; } // InitSlot을 기준으로 가장 비어있는 Position을 할당해준다. int MinEnemy = m_iEnemySlot[InitSlot]; int MinSlot, NextSlot, PrevSlot; MinSlot = NextSlot = PrevSlot = InitSlot; for(int i = 0; i < MAX_ENEMYSLOT_NUM/4; i++) { if(CurAngle > MidAngle) { if(++NextSlot >= MAX_ENEMYSLOT_NUM) NextSlot -= MAX_ENEMYSLOT_NUM; if(--PrevSlot < 0) PrevSlot += MAX_ENEMYSLOT_NUM; } else { if(--NextSlot < 0) NextSlot += MAX_ENEMYSLOT_NUM; if(++PrevSlot >= MAX_ENEMYSLOT_NUM) PrevSlot -= MAX_ENEMYSLOT_NUM; } if(MinEnemy > m_iEnemySlot[NextSlot]) { MinSlot = NextSlot; MinEnemy = m_iEnemySlot[MinSlot]; } if(MinEnemy > m_iEnemySlot[PrevSlot]) { MinSlot = PrevSlot; MinEnemy = m_iEnemySlot[MinSlot]; } } if(MinSlot < 0 || MinSlot > MAX_ENEMYSLOT_NUM) { SUNLOG(eCRITICAL_LOG, "[AllocEnemySlot] Invalid MinSlot[%d] InitSlot CurAngle[%d]", MinSlot, InitSlot, CurAngle); MinSlot = 0; } // 사용하게 될 MinSlot의 m_iEnemySlot를 하나 늘려준다. ++m_iEnemySlot[MinSlot]; // 최종적으로 Enemy(몬스터)가 쫓아야할 좌표를 셋팅해준다. WzVector vRelativePos; SetVector(&vRelativePos, g_SinTable.FCOS(UnitAngle*MinSlot), g_SinTable.FSIN(UnitAngle*MinSlot), 0); wvResultPos = vCurPos + (vRelativePos*fAreaRadius); WzVector diffEnemyVec = wvResultPos - *pwvEnemyPos; float fMoveLength2 = Math_Vector2DLength2(&diffEnemyVec); if(fMoveLength2 < (fAreaRadius * 0.2f * fAreaRadius * 0.2f)) wvResultPos = vCurPos; return (BYTE)MinSlot; } void Character::FreeEnemySlot(BYTE bySlot) { if(bySlot == TargetManager::TRACK_SLOT_NONE) return; if(bySlot > MAX_ENEMYSLOT_NUM) return; if(m_iEnemySlot[bySlot] <= 0) return; --m_iEnemySlot[bySlot]; } void Character::SendToObservers(AI_MSG* pMsg, WORD wSize) { AIMessageSender op(pMsg, wSize); m_Observers.Foreach(op); } class RemoveTargetOpr { public: RemoveTargetOpr(Character* pDeadChar) : m_pDeadChar(pDeadChar) {} ~RemoveTargetOpr() {} void operator () (Object* pObject) { if(pObject->IsEqualObjectKind(NPC_OBJECT)) { NPC* pNPC = (NPC*)pObject; pNPC->GetTargetManager()->RemoveBattleRecord(m_pDeadChar->GetObjectKey()); } } private: Character* m_pDeadChar; }; void Character::OnDead() { // 죽은 캐릭터를 타겟에서 제외 RemoveTargetOpr op(this); m_Observers.Foreach(op); StopMoving(); // 죽으면 스킬리스트 초기화 m_pSkillManager->ReleaseDead(); DelFightingEnergy(GetFightingEnergy()); if(Policyment.FIELD & Policyment.PCC_IN_DEF_FIELD) { // 죽으면 모든 Status를 꺼줘야할까? --> 고민을 해보자. ;; // 죽으면 패널티를 적용한다. ApplyPenalty(); if(ePRS_AT_CHUNTING == GetGameZoneState() && GetField()) { Character* pKiller = GetField()->FindCharacter(m_dwKillerObjectKey); if(pKiller) { GameCHuntingRoom* pCHuntingRoom = (GameCHuntingRoom *)GetGameZonePtr(); if(pCHuntingRoom) pCHuntingRoom->GetCHuntingManager()->DeadCharacter(this, pKiller); } } }; //_NA_0_20091118_GAMEROOM_BATTLE_RESULT GameField* game_field = GetField(); GameZone* game_zone = GetGameZonePtr(); if (game_zone && game_field) { MAPCODE mapcode = game_zone->GetMapCode(); GameBattleResult* battle_result = game_zone->GetGameBattleResult(); if (battle_result != NULL) { Character* killer = game_field->FindCharacter(m_dwKillerObjectKey); if (killer != NULL) { eBATTLE_RECORD_TYPE record_type = IsEqualObjectKind(PLAYER_OBJECT) ? BATTLE_RECORD_PLAYER_KILL : BATTLE_RECORD_MONSTER_KILL; #ifdef _NA_006605_VALKYRIES_SUMMONS_BATTLE_RESULT_APPLY if (killer->IsEqualObjectKind(PLAYER_OBJECT)) battle_result->DoRecord(killer, record_type, 0); else if (killer->IsEqualObjectKind(SUMMON_OBJECT)) battle_result->DoRecord(killer->GetPlayerOwner(), record_type, 0); #else battle_result->DoRecord(killer, record_type, 0); #endif // _NA_006605_VALKYRIES_SUMMONS_BATTLE_RESULT_APPLY battle_result->DoRecord(this, BATTLE_RECORD_DEAD, 0); } //_NA_001990_ACSYSTEM_ADD if ((IsEqualObjectKind(SUMMON_OBJECT) == false) || (GetPlayerOwner() == NULL)) { // Player가 소환한 소환수에 대해서는 AC 를 체크하지 않는다. if (killer && killer->IsEqualObjectKind(PLAYER_OBJECT)) { Player* pKiller = static_cast(killer); AchievementManager* pACManager = pKiller->GetACManager(); if(IsEqualObjectKind(PLAYER_OBJECT)) { pACManager->IncConditionValue( ACHIEVEMENT_OBJECT_PC_KILL, mapcode ); pACManager->IncConditionValue( ACHIEVEMENT_OBJECT_PC_KILL_ACCUMULATED, mapcode ); } else { pACManager->IncConditionValue( ACHIEVEMENT_OBJECT_NPC_KILL, mapcode ); pACManager->IncConditionValue( ACHIEVEMENT_OBJECT_NPC_KILL_ACCUMULATED, mapcode ); } pACManager->IncConditionValue( ACHIEVEMENT_OBJECT_KILL, mapcode ); pACManager->IncConditionValue( ACHIEVEMENT_OBJECT_KILL_ACCUMULATED, mapcode ); } } if (this->IsEqualObjectKind(PLAYER_OBJECT)) { Player* pPlayer = static_cast(this); if( game_field->GetMovingPlanner()->CheckAttribute(GetPathExplorer()->GetTile(), PTA_PLAYER_FALLDOWN_TILE) == TRUE ) { pPlayer->GetACManager()->IncConditionValue( ACHIEVEMENT_OBJECT_FALL, mapcode ); } } } #ifdef _NA_003027_20111013_HONOR_SYSTEM ;{ Character* kill = game_field->FindCharacter(m_dwKillerObjectKey); Character* dead = game_field->FindCharacter(GetObjectKey());//(this); if(kill && dead) { if (kill->IsEqualObjectKind(PLAYER_OBJECT)) { Player* kill_user = static_cast(kill); AchievementManager* kill_ac_manager = kill_user->GetACManager(); WORD object_code = (dead->IsEqualObjectKind(PLAYER_OBJECT) ? 2 : 1 ); kill_ac_manager->IncConditionValue( ACHIEVEMENT_OBJECT_KILL_ALL, object_code); kill_ac_manager->IncConditionValue( ACHIEVEMENT_OBJECT_KILL_ALL, 3 ); { #ifdef _NA_008804_20160502_COMBAT_LOG /* 이곳에 추가한 이유는 판별하는 기준이 같아서이다... 단지 명예 시스템이 먼저 들어가야 하는 제한이 걸리지만 작업일자를 봐서는 안들어 갈 수 없기에 이곳에 추가한다. */ // 죽인 캐릭터가 플레이어일 경우에만 전달... MSG_CG_STATUS_DEAD_INFO_SYN sys_packet; if(object_code == 2) { // 플레이어를 죽였을 경우 sys_packet.m_Dead_Type = eCHAR_DEAD_INFO_KILL_PLAYER; sys_packet.m_Data = dead->GetObjectKey(); // 죽인 캐릭터의 오브젝트키 전달 kill->SendPacket(&sys_packet, sizeof(sys_packet)); } else { // 몬스터를 죽였을 경우 sys_packet.m_Dead_Type = eCHAR_DEAD_INFO_KILL_MONSTER; if (dead->IsEqualObjectKind(MONSTER_OBJECT)) { NPC* const monster = dynamic_cast(dead); if(monster) { sys_packet.m_Data = monster->GetBaseInfo()->m_MonsterCode; // 죽인 몬스터의 코드를 전달 } else { sys_packet.m_Dead_Type = eCHAR_DEAD_INFO_NONE; sys_packet.m_Data = 0; } kill->SendPacket(&sys_packet, sizeof(sys_packet)); } } #endif //(_NA_008804_20160502_COMBAT_LOG) } } if (dead->IsEqualObjectKind(PLAYER_OBJECT)) { Player* dead_user = static_cast(dead); AchievementManager* dead_ac_manager = dead_user->GetACManager(); WORD object_code = (kill->IsEqualObjectKind(PLAYER_OBJECT) ? 2 : 1 ); dead_ac_manager->IncConditionValue( ACHIEVEMENT_OBJECT_DEAD_ALL, object_code ); dead_ac_manager->IncConditionValue( ACHIEVEMENT_OBJECT_DEAD_ALL, 3 ); { #ifdef _NA_008804_20160502_COMBAT_LOG /* 이곳에 추가한 이유는 판별하는 기준이 같아서이다... 단지 명예 시스템이 먼저 들어가야 하는 제한이 걸리지만 작업일자를 봐서는 안들어 갈 수 없기에 이곳에 추가한다. */ // 죽은 캐릭터가 플레이어일 경우에만 전달... MSG_CG_STATUS_DEAD_INFO_SYN sys_packet; if(object_code == 2) { // 플레이어에게 죽었을 경우 sys_packet.m_Dead_Type = eCHAR_DEAD_INFO_KILL_TO_PLAYER; sys_packet.m_Data = kill->GetObjectKey(); // 나를 죽인 캐릭터의 오브젝트키 전달 this->SendPacket(&sys_packet, sizeof(sys_packet)); } else { // 몬스터에게 죽었을 경우 sys_packet.m_Dead_Type = eCHAR_DEAD_INFO_KILL_TO_MONSERT; if (kill->IsEqualObjectKind(MONSTER_OBJECT)) { NPC* const monster = dynamic_cast(kill); if(monster) { sys_packet.m_Data = monster->GetBaseInfo()->m_MonsterCode; // 나를 죽인 몬스터의 코드를 전달 } else { sys_packet.m_Dead_Type = eCHAR_DEAD_INFO_NONE; sys_packet.m_Data = 0; } this->SendPacket(&sys_packet, sizeof(sys_packet)); } } #endif //(_NA_008804_20160502_COMBAT_LOG) } } } #ifdef _NA_008804_20160502_COMBAT_LOG // 킬러가 없을 경우는 트리거에 의한 죽음이다. if(kill == NULL || kill->IsDeleted()) { // 트리거에 의해 죽었을 경우 MSG_CG_STATUS_DEAD_INFO_SYN sys_packet; sys_packet.m_Dead_Type = eCHAR_DEAD_INFO_KILL_TO_TRIGGER; sys_packet.m_Data = 0; // 트리거에 의한 죽음은 데이터를 따로 보내지 않는다. this->SendPacket(&sys_packet, sizeof(sys_packet)); } #endif //(_NA_008804_20160502_COMBAT_LOG) }; #endif//_NA_003027_20111013_HONOR_SYSTEM } SetDeadType(eCHAR_DEAD_NORMAL); /* // (CHANGES) (f100329.2L) (WAVERIX) synchronization control flag based on room \ // related to PvP, GvG, and NvN if (game_zone->Policyment.FIELD & game_zone->Policyment.ENABLE_NvN_SYNC) { } else */ // CHANGES: f110303.3L, added rule to support _NA001605_EP2_CHANGE_SKILL_BROADCASTER_ if (SkillExecutionTransaction::kIsTransaction == 0) { MSGSUB_SYNC_CHARACTER_DEAD_BRD msg; msg.m_ObjectKey = GetObjectKey(); SendPacketAroundForSync(&msg, true); } } BOOL Character::OnResurrection(float fRecoverExp, float fRecoverHP, float fRecoverMP, Player* pHealer) { if(IsAlive()) return false; // 손해본 경험치 회복 EXPTYPE RecoverExp = (DWORD)(m_DeadExp * fRecoverExp); AddExp(RecoverExp, 0, 0, false); // HP, MP 회복 const DWORD dwRecoverHP = (DWORD)(GetMaxHP() * fRecoverHP); const DWORD dwRecoverMP = (DWORD)(GetMaxMP() * fRecoverMP); const DWORD dwRecoverSD = (DWORD)GetMaxSD(); SetSD(dwRecoverSD); SetHP(dwRecoverHP); SetMP(dwRecoverMP); return true; } void Character::OnAttack(Character* pTarget, SLOTCODE skillcode, DAMAGETYPE damage) { #ifdef _NA_007667_20141001_WITCHBLADE_SKILL m_pStatusManager->Attack(pTarget, damage); #else m_pStatusManager->Attack(damage); #endif //_NA_007667_20141001_WITCHBLADE_SKILL } void Character::Attacked() { m_pStatusManager->Attacked(); } void Character::_Damaged(DamageArgs* damage_arg) { Character* pAttacker = damage_arg->actor_; // CHANGES: f101124.3L, added a damage rule such as a self damage rule // if a reflect option is checked if (this == pAttacker || damage_arg->option_.is_mirror_) { // 자기가 자신한테 데미지를 입혀 죽을 수 있을 경우 남은 피의 1%만 남겨놓는다. int cur_hp = GetHP(); if (cur_hp <= damage_arg->damage_) { // f101124.3L, changed a comarator '<' to '<=' damage_arg->damage_ = static_cast(cur_hp - (cur_hp * 0.01f)); } } if (pAttacker) { m_KillerType = pAttacker->GetObjectType(); m_dwKillerObjectKey = pAttacker->GetObjectKey(); } else { m_KillerType = MAX_OBJECT; m_dwKillerObjectKey = 0; } if (damage_arg->option_.is_mirror_ == false) { // TODO: f100908.1L, need check #ifdef _NA_006728_20130520_SKILL_BALANCE_MODIFY m_pStatusManager->Damaged(pAttacker, damage_arg); #else DAMAGETYPE result_damage = damage_arg->damage_; m_pStatusManager->Damaged(pAttacker, damage_arg->attack_type_, result_damage); damage_arg->damage_ = result_damage; #endif // _NA_006728_20130520_SKILL_BALANCE_MODIFY } damage_arg->damage_ = _ApplyOptionDecDamage(pAttacker, damage_arg->damage_, damage_arg->attack_regist_kind_); //xiaomi mark 셕炬杰唐�襁┝撮� #ifdef _NA_006680_20130426_ITEM_OPTION_ADD_AND_MODIFY if (this != pAttacker) { const DWORD absorb_sd = damage_arg->damage_ * pAttacker->GetAttr().GetAttackDamageAbsorbSDRatio() / 100; if (absorb_sd > 0) { #ifdef _NA_008731_20160314_HP_SD_ADDITIONAL_CONDITIONS_INCREASE //if(pAttacker->GetDeadType() == eCHAR_DEAD_NOT_DEAD) { pAttacker->IncreaseSD(absorb_sd); MSG_CG_STATUS_CHANGE_SD_CMD cmd_msg; cmd_msg.m_dwSD = pAttacker->GetSD(); pAttacker->SendPacket(&cmd_msg, sizeof(cmd_msg)); } #else pAttacker->IncreaseSD(absorb_sd); MSG_CG_STATUS_CHANGE_SD_CMD cmd_msg; cmd_msg.m_dwSD = pAttacker->GetSD(); pAttacker->SendPacket(&cmd_msg, sizeof(cmd_msg)); #endif //(_NA_008731_20160314_HP_SD_ADDITIONAL_CONDITIONS_INCREASE) } const DWORD absorb_hp = damage_arg->damage_ * (pAttacker->GetAttr().GetAttackDamageAbsorbHPRatio()) / 100; if (absorb_hp > 0) { #ifdef _NA_008731_20160314_HP_SD_ADDITIONAL_CONDITIONS_INCREASE if(pAttacker->GetHP() != 0) { pAttacker->IncreaseHP(absorb_hp); MSG_CG_STATUS_CHANGE_HP_BRD cmd_msg; cmd_msg.m_dwObjectKey = pAttacker->GetObjectKey(); cmd_msg.m_dwTargetHP = pAttacker->GetHP(); cmd_msg.m_dwReserveHP = pAttacker->GetReserveHP(); pAttacker->SendPacket(&cmd_msg, sizeof(cmd_msg)); } #else pAttacker->IncreaseHP(absorb_hp); MSG_CG_STATUS_CHANGE_HP_BRD cmd_msg; cmd_msg.m_dwObjectKey = pAttacker->GetObjectKey(); cmd_msg.m_dwTargetHP = pAttacker->GetHP(); cmd_msg.m_dwReserveHP = pAttacker->GetReserveHP(); pAttacker->SendPacket(&cmd_msg, sizeof(cmd_msg)); #endif //(_NA_008731_20160314_HP_SD_ADDITIONAL_CONDITIONS_INCREASE) } } #endif // _NA_006680_20130426_ITEM_OPTION_ADD_AND_MODIFY // 매직쉴드와 SD에 의해 감소되기 전 피해량 //어시스트포인트는 SD와 매직쉴드에 준 피해도 포함시킨다 damage_arg->damage_first_ = damage_arg->damage_; damage_arg->damage_ = _ApplyMagicShield(damage_arg->damage_); // Shield System damage_arg->damage_ = _ApplyShieldPoint(pAttacker, damage_arg->damage_, damage_arg->sd_apply_); #ifdef _NA_0_20100819_AGGRO_RENEWAL // 캐릭터가 NPC이면 최종 데미지를 BattlePoint로 기록 if (this->IsEqualObjectKind(NPC_OBJECT) && IsAlive()) { NPC* npc = static_cast(this); npc->AddBattlePoint(pAttacker, BATTLE_POINT_DAMAGE, damage_arg->damage_); } #endif //_NA_0_20100819_AGGRO_RENEWAL #ifdef _NA_006633_20130415_ADD_BATTLEGROUND_ASSIST //캐릭터가 플레이어면 어시스트포인트를 증가시킨다 //어시스트포인트는 전장에 한해서만 추가될 것이다. else if (this->IsEqualObjectKind(PLAYER_OBJECT) && IsAlive()) { Player* player = static_cast(this); #ifdef _NA_007065_20140217_CHAOSZONE_GOLDRUSH ChaosZoneType chaoszone_type = player->GetChaosZoneType(); if ( chaoszone_type == kBattleGround || chaoszone_type == eCHAOSZONE_TYPE_GOLDRUSH) { player->GetPlayerAssistMeter()->AddAssistPoint(pAttacker, damage_arg->damage_first_); } #else if ( player->IsThereBattleGroundZone()) { player->GetPlayerAssistMeter()->AddAssistPoint(pAttacker, damage_for_assist_point); } #endif //_NA_007065_20140217_CHAOSZONE_GOLDRUSH } #endif //_NA_006633_20130415_ADD_BATTLEGROUND_ASSIST damage_arg->damage_ = DecreaseHP(damage_arg->damage_, damage_arg->limit_hp_); #ifdef _NA_008132_20150316_MONDSCHEIN_TEXTLOG _WriteMondschienLog(pAttacker, damage_arg->skill_code_, damage_arg->damage_first_); #endif //_NA_008132_20150316_MONDSCHEIN_TEXTLOG #ifdef _NA_008706_20160229_TEXTLOG_PK _WriteBattleMonitorLog(pAttacker, damage_arg->skill_code_, damage_arg->damage_first_); #endif //_NA_008706_20160229_TEXTLOG_PK #ifdef _NA_6260_20100507_BUG_FIX_SPDAMAGED_ABSORB // 데미지 적용 정리 : 상태무적(1301) 적용 -> 데미지 반사(220...) -> 추가(보너스) 데미지(231) // -> 데미지 감소 옵션(전체) -> 데미지 감소 옵션(pvp) -> 데미지 감소 옵션(pvall) // -> 매직 쉴드 적용 -> SP 적용 -> HP 감소 // -> HP데미지 복구(피격자의 hp.mp) -> HP데미지 복구(공격자의 hp.mp) if (damage_arg->option_.is_mirror_ == false) { // 기존 mp,sp의 복구가 초기 데미지에서 -> HP감소 데미지로. // hp에데미지를 입은 이후 다시 eCHAR_STATE_ABSORB(115)에 의해 복구 한다. // 죽어 버렸다면 복구 불가. m_pStatusManager->DamagedAbsorb(damage_arg->damage_); } #endif Attacked(); GetStatusManager()->UpdateExpiredTime(eCHAR_STATE_BATTLE, STATE_BATTLE_TIME); //_NA_0_20091118_GAMEROOM_BATTLE_RESULT GameZone* game_zone = GetGameZonePtr(); if (game_zone) { GameBattleResult* battle_result = game_zone->GetGameBattleResult(); if (battle_result != NULL) { battle_result->DoRecord(this, BATTLE_RECORD_DAMAGE, damage_arg->damage_); #ifdef _NA_008299_20150519_MAX_DAMAGE_LOG WriteMaxDamageLog(pAttacker, damage_arg); #endif // _NA_008299_20150519_MAX_DAMAGE_LOG #ifdef _NA_006605_VALKYRIES_SUMMONS_BATTLE_RESULT_APPLY if (pAttacker->IsEqualObjectKind(PLAYER_OBJECT)) battle_result->DoRecord(pAttacker, BATTLE_RECORD_ATTACK, damage_arg->damage_); else if (pAttacker->IsEqualObjectKind(SUMMON_OBJECT)) battle_result->DoRecord(pAttacker->GetPlayerOwner(), BATTLE_RECORD_ATTACK, damage_arg->damage_); #else battle_result->DoRecord(pAttacker, BATTLE_RECORD_ATTACK, damage_arg->damage_); #endif // _NA_006605_VALKYRIES_SUMMONS_BATTLE_RESULT_APPLY } } #ifdef _NA_008321_20150601_BATTLE_INFO //개발서버나 사내서버일 경우만 eSERVER_MODE server_mode = g_pGameServer->GetMode(); if ((server_mode == eSERVER_DEV || server_mode == eSERVER_INTRAOFFICE) && (pAttacker->IsEqualObjectKind(PLAYER_OBJECT) && this->IsEqualObjectKind(PLAYER_OBJECT))) { MSG_CG_BATTLE_DETAIL_INFORMATION_CMD cmd_packet; cmd_packet.damage = damage_arg->damage_first_; cmd_packet.skill_code = damage_arg->skill_code_; strcpy(cmd_packet.attacker_name, pAttacker->GetCharName()); strcpy(cmd_packet.target_name, this->GetCharName()); this->SendPacket(&cmd_packet, sizeof(cmd_packet)); pAttacker->SendPacket(&cmd_packet, sizeof(cmd_packet)); SUNLOG(eCRITICAL_LOG,"[DamageNotify] [%s] --> [%s] [Damage:%d(%d)]", cmd_packet.attacker_name, cmd_packet.target_name, cmd_packet.damage, cmd_packet.skill_code); } #endif //_NA_008321_20150601_BATTLE_INFO } // 데미지 감소 옵션은 순차적으로 이루어 진다. // AllvAll -> PvP -> PvAll DAMAGETYPE Character::_ApplyOptionDecDamage(Character* pAttacker, DAMAGETYPE damage, eATTACK_RESIST attackKind) { __UNUSED(attackKind); Attributes& rAtt = GetAttr(); int nResistValue = rAtt.GetDecDamage(); int nResistRatio = rAtt.GetRatioDecDamage(); Player* attacker = static_cast(pAttacker); #ifdef _NA_008540_20151027_ADD_ITEMOPTION_ELITE4 if (pAttacker && pAttacker->IsEqualObjectKind(PLAYER_OBJECT) == FALSE) { nResistValue += rAtt.GetDecreaseDamageNPC(); nResistRatio += rAtt.GetRatioDecreaseDamageNPC(); } else if (pAttacker && pAttacker->IsEqualObjectKind(PLAYER_OBJECT) == TRUE) { Attributes& rAttackAtt = attacker->GetPlayerAttr(); eCHAR_TYPE char_class = attacker->GetCharType(); switch(char_class) { case eCHAR_BERSERKER: nResistValue += rAtt.GetDecreaseDamageBerserker(); nResistRatio += rAtt.GetRatioDecreaseDamageBerserker(); break; case eCHAR_DRAGON: nResistValue += rAtt.GetDecreaseDamageDragonKnight(); nResistRatio += rAtt.GetRatioDecreaseDamageDragonKnight(); break; case eCHAR_SHADOW: nResistValue += rAtt.GetDecreaseDamageShadow(); nResistRatio += rAtt.GetRatioDecreaseDamageShadow(); break; case eCHAR_VALKYRIE: nResistValue += rAtt.GetDecreaseDamageValkyrie(); nResistRatio += rAtt.GetRatioDecreaseDamageValkyrie(); break; case eCHAR_ELEMENTALIST: nResistValue += rAtt.GetDecreaseDamageElementalist(); nResistRatio += rAtt.GetRatioDecreaseDamageElementalist(); break; case eCHAR_MYSTIC: nResistValue += rAtt.GetDecreaseDamageMystic(); nResistRatio += rAtt.GetRatioDecreaseDamageMystic(); break; case eCHAR_HELLROID: nResistValue += rAtt.GetDecreaseDamageHellroid(); nResistRatio += rAtt.GetRatioDecreaseDamageHellroid(); break; case eCHAR_WITCHBLADE: nResistValue += rAtt.GetDecreaseDamageWitchBlade(); nResistRatio += rAtt.GetRatioDecreaseDamageWitchBlade(); break; } #ifdef _20220109_ADD_ATTACKDECDAMAGE nResistValue-=rAttackAtt.GetPassDecDamage(); nResistRatio-=rAttackAtt.GetRatioPassDecDamage(); #endif } #endif //_NA_008540_20151027_ADD_ITEMOPTION_ELITE4 damage = CalcDecreaseDamage(damage, nResistValue, nResistRatio); // 전체 데감 //xiaomi wait 警속밞누橄昑 if(pAttacker && pAttacker->IsEqualObjectKind(PLAYER_OBJECT)) { // PVP 데감 _NA_001231_20081216_ADD_OPTION_KIND #ifdef _NA_008486_20150914_TOTAL_BALANCE //DoT 효과는 PvP데미지감소효과를 받지 않도록 한다 if(this->IsEqualObjectKind(PLAYER_OBJECT) && attackKind != eATTACK_RESIST_SKILL_DOT_DAMAGE) { nResistValue += rAtt.GetDecreasePVPDamage(); nResistRatio += rAtt.GetRatioDecreasePVPDamage(); #ifdef _20220109_ADD_ATTACKDECDAMAGE //xiaomi 警속밞누，？ PVP�襁┡始㉣塤╂�.... /* nResistValue-=rAttackAtt.GetPassDecDamage(); nResistRatio-=rAttackAtt.GetRatioPassDecDamage();*/ #endif damage = CalcDecreaseDamage(damage, nResistValue, nResistRatio); } #else if(this->IsEqualObjectKind(PLAYER_OBJECT)) { nResistValue = rAtt.GetDecreasePVPDamage(); nResistRatio = rAtt.GetRatioDecreasePVPDamage(); damage = CalcDecreaseDamage(damage, nResistValue, nResistRatio); } #endif //_NA_008486_20150914_TOTAL_BALANCE } return damage; } // 쉴드 시스템 //_NA_0_20100211_SD_EFFECT_MODIFY DAMAGETYPE Character::_ApplyShieldPoint(Character* pAttacker, DAMAGETYPE damage, eSD_APPLY SDApply) { PAIR_DAMAGE retVal(damage, 0); if (eSD_APPLY_DO == SDApply && IsPCObject(this) && NULL != pAttacker && IsPCObject(pAttacker)) { DAMAGETYPE& damegeHP = retVal.damageHP; DAMAGETYPE& damegeSD = retVal.damageSD; damegeSD = DAMAGETYPE(damegeHP * SD_ABSORB_RATIO); damegeSD = DecreaseSD(damegeSD); // 리턴값 : 실제 차감된 데미지 damegeHP -= damegeSD; //... //_NA_0_20100211_SD_EFFECT_MODIFY // 기획에서 원하는건 SD 감소하는 플레이어의 감소연출이다. // 공격자와 주위 유저들에게는 연출 되지 않는다. // 데미지쪽 모든 패킷에 추가하기엔 패킷 낭비다. // 허나 이펙트에 따라 연출(2타스킬,두개의 데미지어빌리티)이 // 다른 스킬의 처리시 클라에서는 한번에 연출에 대한 정보를 모두 // 받길 원한다. if (damegeSD != 0 && IsEqualObjectKind(PLAYER_OBJECT)) { Player* pPlayer = (Player*)this; pPlayer->NotifyChangedStatus(PlayerStatEvent::eFlag_ChangedSD); } } //_NA_0_20100211_SD_EFFECT_MODIFY return retVal.damageHP; } BOOL Character::CanAttack() const { if(IsDead()) { return false; } // 특정 상태에 걸렸을 경우 공격 불가 return m_pStatusManager->CanAttack(); } BOOL Character::CanMove(eCHAR_STATE_TYPE eException) { // 특정 상태에 걸렸을 경우 이동 불가 return m_pStatusManager->CanMove(eException); } BOOL Character::CanBeAttacked() const { if (IsDead()) { return false; } // 특정 상태에 걸렸을 경우 공격을 받지 않음 return m_pStatusManager->CanBeAttacked(); } float Character::GetDist(Character* pTargetCharacter) const { // 타겟과의 거리 구하기 WzVector vCurPos, vTargetPos; GetPos(&vCurPos); pTargetCharacter->GetPos(&vTargetPos); return VectorLength(&(vTargetPos - vCurPos)); } float Character::GetDist(const WzVector& vTargetPos) const { // 타겟과의 거리 구하기 WzVector vCurPos; GetPos(&vCurPos); return VectorLength(&(vTargetPos - vCurPos)); } float Character::GetDist2(Character* pTargetCharacter) const { // 타겟과의 거리 구하기 WzVector vCurPos, vTargetPos; GetPos(&vCurPos); pTargetCharacter->GetPos(&vTargetPos); return VectorLength2(&(vTargetPos - vCurPos)); } float Character::GetDist2(const WzVector& vTargetPos) const { // 타겟과의 거리 구하기 WzVector vCurPos; GetPos(&vCurPos); return VectorLength2(&(vTargetPos - vCurPos)); } float Character::GetHeightDiff(const WzVector& vTargetPos) const { // 타겟과의 높이차 구하기 WzVector vCurPos; GetPos(&vCurPos); return (vTargetPos.z - vCurPos.z); } BOOL Character::IsStandingOnJumpTile() { GameField* const pGameField = GetField(); if(!pGameField) return false; // 현재 서있는 타일 속성 얻어내기 const int iTileNo = m_pPathExplorer->GetTile(); if(iTileNo < 0) return false; const WORD tile_attribute = pGameField->GetMovingPlanner()->GetAttribute(iTileNo); // 점프 속성이 포함되어 있는지 검사 return !!(tile_attribute & PTA_ONLY_JUMP); } BOOL Character::CheckArea(const WzVector& vTargetPos, const WzVector& vMainTargetPos, BYTE byRangeForm, float fArea) { WzVector vAttackerPos; GetPos(&vAttackerPos); if(byRangeForm == SRF_FOWARD_120) { // 120도 WzVector diffVec = vMainTargetPos - vAttackerPos; if(!Math_IsPositionInFanshapedArea(&vTargetPos, &vAttackerPos, &diffVec, 120)) { return false; } } else if(byRangeForm == SRF_FOWARD_160) { // 160도 WzVector diffVec = vMainTargetPos - vAttackerPos; if(!Math_IsPositionInFanshapedArea(&vTargetPos, &vAttackerPos, &diffVec, 160)) { return false; } } else if(byRangeForm == SRF_PIERCE) { // 관통 if(Math_IsPositionInOBB(&vAttackerPos, &vMainTargetPos, fArea*2, &vTargetPos)) return true; else return false; } AI_COMMON_INFO& stAICommonInfo = AIParamParser::Instance()->GetCommonInfo(); // if(!CheckHeightRange(vTargetPos, fArea)) // _NA001385_20090924_DOMINATION_ETC 이전 루틴에서 이미 체크 했다. (삭제) // return false; // SkillArea를 체크한다.(MainTarget을 중심으로 하는 원영역) ... 관통일 경우는 체크하지 않는다. if(fArea && Math_Vector2DLength(vMainTargetPos, vTargetPos) >= fArea + stAICommonInfo.m_fRANGE_TOLERANCE) { return false; } return true; } BOOL Character::CheckHeightRange(Character* pTarget, const WzVector& vTargetPos, float fBaseRange) { float fHeightDiff = fabs(GetHeightDiff(vTargetPos)); //_NA001385_20090924_DOMINATION_FINDPATH_ATTACK GameZone* pZone = GetGameZonePtr(); if (pZone == NULL) { SUNLOG(eCRITICAL_LOG, "[Character::CheckHeightRange] GetGameZonePtr() returned NULL!"); return false; } if (NULL != pTarget && eZONETYPE_DOMINATION_FIELD == pZone->GetZoneType() && false != this->IsEqualObjectKind(PLAYER_OBJECT) && false != pTarget->IsEqualObjectKind(MAPNPC_OBJECT)) { // 지역 점령전 MAPNCP의 경우 높이 체크를 한다. if(fHeightDiff >= MAX_ATTACK_HEIGHT_IN_DOMINATION) return false; } AI_COMMON_INFO& stAICommonInfo = AIParamParser::Instance()->GetCommonInfo(); // 높이 체크(사거리의 50% 정도를 적용하며 사거리가 짧을 경우에는 허용해준다.) float fZAttackRange = max(4, fBaseRange * stAICommonInfo.m_fATTACK_RANGE_HEIGHT_RATIO); if(fHeightDiff >= fZAttackRange) return false; return true; } //_NA001385_20090924_DOMINATION_FINDPATH_ATTACK BOOL Character::CheckAttackFindPath(const WzVector& vMainTargetPos) { // 지역점령전에서는 벽 안쪽 플레이어는 공격 할 수 없다. // 벽(못가는 타일) 위의 NPC는 공격 할수 있다. // 해당 경우는 3가지가 있다. // 1. 적군이 보이지 않는 경우. (벽 안쪽이나 성문 안쪽) // 2. 적군은 보이지만 적군 위치로는 갈수 없는 경우. (절벽의 반대편) // 3. 캐스팅 시작시 보이지만, 완료시 보이지 않는 경우. (성문이 열렸다, 닫힌경우.) // 이후 기획 변경. : 공격은 가능 하나 타겟팅은 되지 않는다. (클라이언트에서 처리함.) // 이후 언젠가.. // 신규 타일 속성이나, 방식의 변경을 통해 공격 판정이나 취소 miss 에 대한 수정이 필요. // (현재 문 안쪽을 공격 하는 방식이 버그 같지만, 오래 되어 정당한 플레이 방식임.) return true; #if SUN_CODE_BACKUP GameZone* pZone = GetGameZonePtr(); #if SUN_CODE_RENEWAL const sPOLICY_ZONE& ZonePolicy = pZone->Policyment; if ((ZonePolicy.FIELD & ZonePolicy.ENABLE_DOMINATION_CONTROL) == 0) { return true; } #else if (eZONETYPE_DOMINATION_FIELD != pZone->GetZoneType()) return true; #endif GameField* const pGameField = GetField(); const BOOL bPath = pGameField->CorrectMovableDestPath(this, &vMainTargetPos); return bPath; #endif // } BOOL Character::CheckAttackRange(Character* pTarget, WzVector &vTargetPos) { AI_COMMON_INFO& stAICommonInfo = AIParamParser::Instance()->GetCommonInfo(); WzVector vAttackerPos; GetPos(&vAttackerPos); float fAttackRange = GetAttackRange() + stAICommonInfo.m_fRANGE_TOLERANCE; if(!CheckHeightRange(pTarget, vTargetPos, fAttackRange)) return false; if(pTarget) { if (false != this->IsEqualObjectKind(PLAYER_OBJECT) && false == pTarget->IsEqualObjectKind(MAPNPC_OBJECT)) { if (false == CheckAttackFindPath(vTargetPos)) return false; } fAttackRange += pTarget->GetBodyRadius(); } // 공격 사거리 판별(공격자와 타겟과의 거리) const float diff_length = Math_Vector2DLength(vAttackerPos, vTargetPos); if(diff_length >= fAttackRange) { return false; } return true; } // 공격자 기준 BOOL Character::CheckSkillRange(Character* pTarget, const WzVector &vTargetPos, float fSkillRange) { AI_COMMON_INFO& stAICommonInfo = AIParamParser::Instance()->GetCommonInfo(); WzVector vAttackerPos; GetPos(&vAttackerPos); fSkillRange += stAICommonInfo.m_fRANGE_TOLERANCE; // 원거리 스킬인 경우에만 SkillRangeBonus 적용 if(fSkillRange >= 4.f) { float skill_range_ratio_bonus = fSkillRange * (GetAttr().GetRatioSkillRangeBonus()/100.0f); fSkillRange += GetSkillRangeBonus() + skill_range_ratio_bonus; } if(!CheckHeightRange(pTarget, vTargetPos, fSkillRange)) return false; if(pTarget) { if (false != this->IsEqualObjectKind(PLAYER_OBJECT) && false == pTarget->IsEqualObjectKind(MAPNPC_OBJECT)) { if (false == CheckAttackFindPath(vTargetPos)) return false; } fSkillRange += pTarget->GetBodyRadius(); } // 스킬 사거리 판별(공격자와 타겟과의 거리) if(fSkillRange && Math_Vector2DLength(vAttackerPos, vTargetPos) >= fSkillRange) return false; return true; } void Character::PeriodicRecover(eCHAR_STATE_TYPE eStateID, int recoverHP, int recoverMP, int iApplicationTime, int iPeriodicTime) { m_pStatusManager->AllocStatus(eStateID, iApplicationTime, iPeriodicTime, recoverHP, recoverMP); } //_NA_0_20091118_GAMEROOM_BATTLE_RESULT void Character::OnRecover(int recoverHP, int recoverMP, int recoverSD, eRECOVER_TYPE Type, Character* pAttacker) { if(recoverHP > 0) { IncreaseHP(recoverHP); } else if(recoverHP < 0) { DecreaseHP(-recoverHP); } if(recoverMP > 0) { IncreaseMP(recoverMP); } else if(recoverMP < 0) { DecreaseMP(-recoverMP); } if(recoverSD > 0) { IncreaseSD(recoverSD); } else if(recoverSD < 0) { DecreaseSD(-recoverSD); } //_NA_0_20091118_GAMEROOM_BATTLE_RESULT GameZone* game_zone = GetGameZonePtr(); if (game_zone && pAttacker) { GameBattleResult* battle_result = game_zone->GetGameBattleResult(); if (battle_result != NULL) { #ifdef _NA_006605_VALKYRIES_SUMMONS_BATTLE_RESULT_APPLY if (pAttacker->IsEqualObjectKind(PLAYER_OBJECT)) battle_result->DoRecord(pAttacker, BATTLE_RECORD_HEAL, recoverHP); else if (pAttacker->IsEqualObjectKind(SUMMON_OBJECT)) battle_result->DoRecord(pAttacker->GetPlayerOwner(), BATTLE_RECORD_HEAL, recoverHP); #else battle_result->DoRecord(pAttacker, BATTLE_RECORD_HEAL, recoverHP); #endif // _NA_006605_VALKYRIES_SUMMONS_BATTLE_RESULT_APPLY } } } BOOL Character::CheckCondition(BYTE byCondition, WORD wParam) { switch(byCondition) { case 1: return CheckCondition_Under_HP(wParam); case 2: return CheckCondition_Under_MP(wParam); case 3: return CheckCondition_Same_HP(wParam); case 4: return CheckCondition_Same_MP(wParam); case 5: return IsDead(); } return false; } // HP가 특정 퍼센트 이하이면 true를 리턴한다. BOOL Character::CheckCondition_Under_HP(WORD wPercent) { if(GetMaxHP() == 0) { ASSERT(! "MaxHP == 0"); return false; } if(IsDead()) return false; return GetHP() * 100 / GetMaxHP() <= wPercent; } // MP가 특정 퍼센트 이하이면 true를 리턴한다. BOOL Character::CheckCondition_Under_MP(WORD wPercent) { if(GetMaxMP() == 0) { ASSERT(! "MaxMP == 0"); return false; } return GetMP() * 100 / GetMaxMP() <= wPercent; } // HP가 특정 퍼센트와 동일하면 true를 리턴한다. BOOL Character::CheckCondition_Same_HP(WORD wPercent) { if(GetMaxHP() == 0) { ASSERT(! "MaxHP == 0"); return false; } return GetHP() * 100 / GetMaxHP() == wPercent; } // MP가 특정 퍼센트와 동일하면 true를 리턴한다. BOOL Character::CheckCondition_Same_MP(WORD wPercent) { if(GetMaxMP() == 0) { ASSERT(! "MaxMP == 0"); return false; } return GetMP() * 100 / GetMaxMP() == wPercent; } RC::eSKILL_RESULT Character::_CanUseSkill(SLOTCODE SkillCode) { SkillScriptInfo* pBaseSkillInfo = (SkillScriptInfo *)SkillInfoParser::Instance()->GetSkillInfo(SkillCode); if(!pBaseSkillInfo) return RC::RC_SKILL_BASEINFO_NOTEXIST; if(!CanAttack()) return RC::RC_SKILL_STATE_WHERE_CANNOT_ATTACK_ENEMY; // 공격할 수 없는 상황이라면 if(!m_pStatusManager->Status.IsPassConstraint(this, pBaseSkillInfo)) return RC::RC_SKILL_STATE_WHERE_CANNOT_ATTACK_ENEMY; // 필요 MP, HP가 있는지 체크한다. if(false == _ChkNeedHP(pBaseSkillInfo->m_wHPSpend) || false == _ChkNeedMP(pBaseSkillInfo->m_wMPSpend)) return RC::RC_SKILL_HPMP_RUN_SHORT; // 봉인 상태에 걸렸는지 체크 RC::eSKILL_RESULT rcResult = m_pStatusManager->CanUseSkill(); if(rcResult != RC::RC_SKILL_SUCCESS) return rcResult; return RC::RC_SKILL_SUCCESS; } RC::eSKILL_RESULT Character::CanUseSkill(SLOTCODE SkillCode, BOOL bCoolTimerReset) { if(false == CheckCoolTimer(SkillCode)) return RC::RC_SKILL_COOLTIME_ERROR; return _CanUseSkill(SkillCode); } RC::eSKILL_RESULT Character::CanUseSkillItem(SLOTCODE SkillCode) { return _CanUseSkill(SkillCode); } BOOL Character::_ChkNeedMP(WORD wMPSpend) { int iMPSpend = (int)(wMPSpend * (1 + GetMPSpendIncRatio()) + GetMPSpendIncValue()); iMPSpend = max(0, iMPSpend); return GetMP() < (DWORD)iMPSpend ? false:true; } BOOL Character::_ChkNeedHP(WORD wHPSpend) { return GetHP() <= wHPSpend ? false:true; } // CHANGES, f100827.4L, r100827.4L, SCCharacter interfaces related to a cool-timer void Character::SetSkillCoolTime(SLOTCODE skill_code, WORD cool_time_margin) { if (skill_code == 0) { return; }; const SkillInfoParser* skill_parser = SkillInfoParser::Instance(); const SkillScriptInfo* skill_info = NULL; if (const ROOT_SKILLINFO* root_skill_info = skill_parser->GetInfo(skill_code)) { if (root_skill_info->IsStyle()) { return; } skill_info = static_cast(root_skill_info); } else { SUNLOG(eCRITICAL_LOG, _T("|["__FUNCTION__"]|斤口=can't find a skill (%d)|"), skill_code); return; } assert(skill_info->m_bySkillType != SKILL_TYPE_PASSIVE); // util::Timer* timer = GetSkillCoolTimer(skill_code); if (timer) { return; } timer = CoolTimerFactory::Instance()->Alloc(); DWORD interval = skill_info->m_dwCoolTime > cool_time_margin ? skill_info->m_dwCoolTime - cool_time_margin : skill_info->m_dwCoolTime; timer->SetTimer(interval); timer->InitCoolTime(); skill_cool_time_table_[skill_code] = timer; } void Character::FreeSkillCoolTime(SLOTCODE skill_code) { COOL_TIME_TABLE::iterator found = skill_cool_time_table_.find(skill_code); if (found == skill_cool_time_table_.end()) { return; } util::Timer* timer = found->second; CoolTimerFactory::Instance()->Free(timer); skill_cool_time_table_.erase(found); } void Character::FreeAllSkillCoolTime(BOOL pool_use) { FOREACH_CONTAINER(const COOL_TIME_TABLE::value_type& node, skill_cool_time_table_, COOL_TIME_TABLE) { util::Timer* timer = node.second; CoolTimerFactory::Instance()->Free( timer ); }; skill_cool_time_table_.clear(); } void Character::InitializeSkillCoolTime() { FOREACH_CONTAINER(const COOL_TIME_TABLE::value_type& node, skill_cool_time_table_, COOL_TIME_TABLE) { util::Timer* timer = node.second; timer->InitCoolTime(); } } util::Timer* Character::GetSkillCoolTimer(SLOTCODE skill_code) { COOL_TIME_TABLE::const_iterator found = skill_cool_time_table_.find(skill_code); if (found == skill_cool_time_table_.end()) { return NULL; } util::Timer* timer = found->second; return timer; } // 쿨타임을 체크한다. bool Character::CheckCoolTimer(SLOTCODE skill_code) const { COOL_TIME_TABLE::const_iterator found = skill_cool_time_table_.find(skill_code); if (found == skill_cool_time_table_.end()) { return true; }; util::Timer* timer = found->second; if (timer->IsExpired(false) == false) { return false; } return true; } bool Character::CoolTimerReset(SLOTCODE skill_code) { COOL_TIME_TABLE::const_iterator found = skill_cool_time_table_.find(skill_code); if (found == skill_cool_time_table_.end()) { return false; //RC::RC_SKILL_COOLTIME_ERROR }; util::Timer* timer = found->second; // 스킬 쿨타임 증감 적용 const int base_cool_time = timer->GetBaseIntervalTime(); int calculate_cool_time = base_cool_time; if(calculate_cool_time) { const Attributes& attributes = this->GetAttr(); int bonus_cool_time = attributes.GetItemBonusSkillCoolTime(); // CHANGES: f110603.2L float bonus_cool_time_ratio = attributes.GetRatioBonusSkillCoolTime() / 100.f; bonus_cool_time_ratio = max(-1.0f, bonus_cool_time_ratio); calculate_cool_time = calculate_cool_time + bonus_cool_time; calculate_cool_time = max(0, calculate_cool_time); calculate_cool_time = (int)(calculate_cool_time * (1 + bonus_cool_time_ratio)); int bonus_time = calculate_cool_time - base_cool_time; timer->SetBonusIntervalTime(bonus_time); } timer->Reset(); return true; } BOOL Character::finite(WzVector& wvPos) { if(!_finite(wvPos.x) || !_finite(wvPos.y) || !_finite(wvPos.z)) return false; return true; } void Character::SendAttrChange(eATTR_TYPE attrType, DWORD dwValue) { if(Policyment.FIELD & Policyment.PCC_IN_DEF_FIELD) { MSG_CG_STATUS_ATTR_CHANGE_BRD sendMsg; sendMsg.m_dwObjKey = GetObjectKey(); sendMsg.m_AttrType = (BYTE)attrType; sendMsg.m_dwValue = dwValue; SendPacketAround(&sendMsg, sizeof(sendMsg)); }; } //#if !defined(_NA000000_110210_ENHANCED_TARGET_SEARCH_ALGORITHM) BOOL Character::IsCoincidentWithTargetType(Character* pTarget, eSKILL_TARGET_TYPE eTargetType) { switch(eTargetType) { case SKILL_TARGET_ME: case SKILL_TARGET_REACHABLE_ME: { if(GetObjectKey() != pTarget->GetObjectKey()) return false; } break; case SKILL_TARGET_FRIEND: case SKILL_TARGET_REACHABLE_FRIEND: { if(IsFriend(pTarget) != USER_RELATION_FRIEND) return false; } break; case SKILL_TARGET_ENEMY: case SKILL_TARGET_REACHABLE_ENEMY: case SKILL_TARGET_AREA: { if(IsFriend(pTarget) != USER_RELATION_ENEMY) return false; } break; case SKILL_TARGET_FRIEND_CORPSE: { if(IsAlive()) return false; if(IsFriend(pTarget) != USER_RELATION_FRIEND) return false; } break; } return true; } //#endif //_NA000000_110210_ENHANCED_TARGET_SEARCH_ALGORITHM BOOL Character::IsStatus(eCHAR_STATE_TYPE eStateID) { if(m_pStatusManager->FindStatus(eStateID)) return true; else return false; } // TODO, waverix, reserve delete that this routine is a temporay save for a summoned. BOOL Character::ModifyPosition( BOOL bIsPlayer, WzVector &vCurPos, WzVector &vDestPos, WzVector &vResultCurPos, WzVector &vResultDestPos, SLOTCODE SkillCode) { // 현재 좌표가 유효한지 체크 if(!_finite(vCurPos.x) || !_finite(vCurPos.y) || !_finite(vCurPos.z)) { if(bIsPlayer) SECURELOG(SECURELOG_PLAYERINFO((Player*)this, eABUSE_LOGIC_VIOLATION, eABUSE_SUB_LOGIC_VIOLATION_INVALID_POSITION), _T("[ModifyPosition] CurPos is Invalid! x[%f] y[%f] z[%f]"), vCurPos.x, vCurPos.y, vCurPos.z); return false; } // 목적지 좌표가 유효한지 체크 if(!_finite(vDestPos.x) || !_finite(vDestPos.y) || !_finite(vDestPos.z)) { if(bIsPlayer) SECURELOG(SECURELOG_PLAYERINFO((Player*)this, eABUSE_LOGIC_VIOLATION, eABUSE_SUB_LOGIC_VIOLATION_INVALID_POSITION), _T("[ModifyPosition] DestPos is Invalid! x[%f] y[%f] z[%f]"), vDestPos.x, vDestPos.y, vDestPos.z); return false; } SERVER_COMMON_OPTION& stServerOptionInfo = ServerOptionParserEx::Instance()->GetServerOption(); WzVector vServerPos, vPosAfterThrust; GetPos(&vServerPos); float fCurPosDiff = Math_Vector2DLength(vServerPos, vCurPos); // 목적지 좌표가 0인 경우 if(vDestPos.x == 0 && vDestPos.y == 0 && vDestPos.z == 0) { if(bIsPlayer) SECURELOG(SECURELOG_PLAYERINFO((Player*)this, eABUSE_LOGIC_VIOLATION, eABUSE_SUB_LOGIC_VIOLATION_INVALID_POSITION), _T("[ModifyPosition] vDestPos is 0!")); vResultCurPos = vServerPos; vResultDestPos = vServerPos; } // 서버가 알고 있는 플레이어의 좌표와 클라이언트가 보낸 좌표가 10m 이상 차이나는 경우 서버를 기준으로 한다. else if(fCurPosDiff >= stServerOptionInfo.m_byMOVE_SYNC_FAIL_DISTANCE) { if(bIsPlayer) SECURELOG(SECURELOG_PLAYERINFO((Player*)this, eABUSE_LOGIC_VIOLATION, eABUSE_SUB_LOGIC_VIOLATION_NOT_SYNC_POSITION), _T("[ModifyPosition] The Server CurPos is different from the Client CurPos! CurPosDiff[%f]"), fCurPosDiff); vResultCurPos = vServerPos; vResultDestPos = vDestPos; } // 클라를 믿고 플레이어의 cur 위치를 맞춰줌 else { vResultCurPos = vCurPos; vResultDestPos = vDestPos; ROOT_SKILLINFO* pRootInfo = SkillInfoParser::Instance()->GetInfo(SkillCode); if(pRootInfo && pRootInfo->IsSkill()) { SkillScriptInfo* pBaseSkillInfo = (SkillScriptInfo *)pRootInfo; if(pBaseSkillInfo->IsNonStopSkill()) { // 플레이어는 멈추지않고 계속 지나간다. } else { // 플레이어 위치를 클라가 보내준 어택 시작점으로 옮긴다. SetPos(&vCurPos); if(bIsPlayer) { MovementChecker* pCHECKER = ((Player*)this)->GetMovementChecker(); pCHECKER->GetServerPathExpUpdate()->SetupLatestState(pCHECKER, .0f, 0, vCurPos, vCurPos); } } } else { SetPos(&vCurPos); if(bIsPlayer) { MovementChecker* pCHECKER = ((Player*)this)->GetMovementChecker(); pCHECKER->GetServerPathExpUpdate()->SetupLatestState(pCHECKER, .0f, 0, vCurPos, vCurPos); } } } // 목적지로 Thrust if(vResultCurPos != vResultDestPos) { WzVector vDiff = vResultDestPos - vResultCurPos; float fThrustDist = VectorLength(&vDiff); // Thrust 거리가 너무 길면 최대거리(10m)로 보정한다. SERVER_COMMON_OPTION& stServerOptionInfo = ServerOptionParserEx::Instance()->GetServerOption(); if(fThrustDist > stServerOptionInfo.m_byMOVE_SYNC_THRUST_DISTANCE) { if(bIsPlayer) SECURELOG(SECURELOG_PLAYERINFO((Player*)this, eABUSE_LOGIC_VIOLATION, eABUSE_SUB_LOGIC_VIOLATION_ATTACK_RANGE), _T("[ModifyPosition] Skill or Normal Attack fThrustDist[%5.2f] is long!"), fThrustDist); fThrustDist = (float)(stServerOptionInfo.m_byMOVE_SYNC_FAIL_DISTANCE - 1); WzVector vNormal; VectorNormalize(&vNormal, &vDiff); vNormal.z = 0; vResultDestPos = vResultCurPos + vNormal* fThrustDist; } ExecuteThrust(false, &vDiff, vPosAfterThrust, fThrustDist); } return true; } // CHANGES, f100830.4L, replace an arguement block for a skill to a SkillInfo bool Character::ModifyPosition(SkillInfo* preparing_skill_info_data) { // for safe-control. if you want modify a SkillInfo, do access to preparing_skill_info_data. const SkillInfo& skill_info_data = *preparing_skill_info_data; Player* const player_for_logging = skill_info_data.character_->IsEqualObjectKind(PLAYER_OBJECT) ? static_cast(this) : NULL; // WzVector cur_pos = skill_info_data.cur_pos_; const WzVector dest_pos = skill_info_data.dest_pos_; // 현재 좌표가 유효한지 체크 if (WzVector_FiniteCheck(&cur_pos) == false) { if (player_for_logging) { SECURELOG(SECURELOG_PLAYERINFO(player_for_logging, \ eABUSE_LOGIC_VIOLATION, eABUSE_SUB_LOGIC_VIOLATION_INVALID_POSITION), _T("["__FUNCTION__"]|斤口=a current position is invalid ") _T("x:y:z={%4.2f,%4.2f,%4.2f}|"), cur_pos.x, cur_pos.y, cur_pos.z); } return false; }; // 목적지 좌표가 유효한지 체크 if (WzVector_FiniteCheck(&dest_pos) == false) { if (player_for_logging) { SECURELOG(SECURELOG_PLAYERINFO(player_for_logging, \ eABUSE_LOGIC_VIOLATION, eABUSE_SUB_LOGIC_VIOLATION_INVALID_POSITION), _T("["__FUNCTION__"]|斤口=a destination position is invalid ") _T("x:y:z={%4.2f,%4.2f,%4.2f}|"), dest_pos.x, dest_pos.y, dest_pos.z); } return false; }; // const SERVER_COMMON_OPTION& server_option = ServerOptionParserEx::Instance()->GetServerOption(); // const WzVector& cur_pos_by_server = *GetPosPtr(); float difference_between_client_and_server = Math_Vector2DLength(cur_pos_by_server, cur_pos); // // 목적지 좌표가 0인 경우 if (dest_pos.x == 0.0f && dest_pos.y == 0.0f && dest_pos.z == 0.0f) { if (player_for_logging) { SECURELOG(SECURELOG_PLAYERINFO(player_for_logging, \ eABUSE_LOGIC_VIOLATION, eABUSE_SUB_LOGIC_VIOLATION_INVALID_POSITION), _T("["__FUNCTION__"]|斤口=a destination position is empty|Action=modified|")); } preparing_skill_info_data->cur_pos_ = cur_pos_by_server; preparing_skill_info_data->dest_pos_ = cur_pos_by_server; // updated 'cur_pos', 'dest_pos' } // 서버가 알고 있는 플레이어의 좌표와 클라이언트가 보낸 좌표가 10m 이상 차이나는 경우 서버를 기준으로 한다. else if (difference_between_client_and_server >= server_option.m_byMOVE_SYNC_FAIL_DISTANCE) { /*if (player_for_logging) { SECURELOG(SECURELOG_PLAYERINFO(player_for_logging, \ eABUSE_LOGIC_VIOLATION, eABUSE_SUB_LOGIC_VIOLATION_NOT_SYNC_POSITION), _T("["__FUNCTION__"]|斤口=there are a differnce of distance ") _T("between client and server|gap=%4.2f|Action=modified|"), difference_between_client_and_server); }*/ preparing_skill_info_data->cur_pos_ = cur_pos_by_server; preparing_skill_info_data->dest_pos_ = cur_pos_by_server; // updated 'cur_pos', 'dest_pos' cur_pos = cur_pos_by_server; } // 클라를 믿고 플레이어의 cur 위치를 맞춰줌 else { preparing_skill_info_data->cur_pos_ = cur_pos_by_server; preparing_skill_info_data->dest_pos_ = cur_pos_by_server; // updated 'cur_pos', 'dest_pos' if (skill_info_data.root_skill_info_ && skill_info_data.root_skill_info_->IsSkill()) { const SkillScriptInfo* base_skill_info = \ static_cast(skill_info_data.root_skill_info_); if (base_skill_info->IsNonStopSkill() || base_skill_info->IsAuraSkill()) { // 플레이어는 멈추지않고 계속 지나간다. } else { // 플레이어 위치를 클라가 보내준 어택 시작점으로 옮긴다. SetPos(&cur_pos); if (player_for_logging) { // TODO : need more thinking... currently (10083), this operation is meaningless. MovementChecker* movement = player_for_logging->GetMovementChecker(); movement->GetServerPathExpUpdate()->SetupLatestState(movement, .0f, 0, preparing_skill_info_data->cur_pos_, preparing_skill_info_data->cur_pos_); } } } else { SetPos(&cur_pos); if (player_for_logging) { // TODO : need more thinking... currently (10083), this operation is meaningless. MovementChecker* movement = player_for_logging->GetMovementChecker(); movement->GetServerPathExpUpdate()->SetupLatestState(movement, .0f, 0, preparing_skill_info_data->cur_pos_, preparing_skill_info_data->cur_pos_); } } // } // 목적지로 Thrust // 이 로직은 더이상 사용하지 않는다 // dest_pos의 용도변경 --> 돌진스킬이동처리 다른곳에서 처리하도록 변경됨 // 의도치 않은 시작위치 보정의 역할만 진행 -> 상단 코드에서 시작위치 보정작업 진행 // 결국 필요없는 코드 /* if (cur_pos != dest_pos) { WzVector diff = dest_pos; ; diff -= cur_pos; float thrust_distance = VectorLength(&diff); // Thrust 거리가 너무 길면 최대거리(10m)로 보정한다. //SERVER_COMMON_OPTION& server_option = ServerOptionParserEx::Instance()->GetServerOption(); if (thrust_distance > server_option.m_byMOVE_SYNC_THRUST_DISTANCE) { if (player_for_logging) { SECURELOG(SECURELOG_PLAYERINFO(player_for_logging, \ eABUSE_LOGIC_VIOLATION, eABUSE_SUB_LOGIC_VIOLATION_ATTACK_RANGE), _T("["__FUNCTION__"]|斤口=a value for thrusting distance ") _T("by attack request is long|gap=%4.2f|Action=modified|"), thrust_distance); } thrust_distance = static_cast(server_option.m_byMOVE_SYNC_FAIL_DISTANCE - 1); // CHANGES, f100830.5L, a process, clear z axis, is removed. 3D dimentional thrusting. WzVector modified_vector; VectorNormalize(&modified_vector, &diff); ; modified_vector *= thrust_distance; preparing_skill_info_data->dest_pos_ = cur_pos; preparing_skill_info_data->dest_pos_ += modified_vector; } WzVector post_position; ExecuteThrust(false, &diff, post_position, thrust_distance); } */ return true; } void Character::SetMoveState(eCHAR_MOVE_STATE state) { m_pMoveStateControl->SetMoveState(state); } void Character::SetSkillCancel(SLOTCODE SkillCode, BOOL bCancel) { m_pSkillManager->CancelActiveSkill(SkillCode); } void Character::CancelAllSkill() { m_pSkillManager->CancelAllSkill(); } // 새로운 유저가 섹터에 들어오거나, 내가 섹터에 들어갈 때 섹터의 유저들에게 나의 이동정보를 보낸다. void Character::SendMoveInfo(Player* pEnterPlayer, const Sector& IN rSector) { GameField* pField = GetField(); // (WAVERIX) (090225) (BUG-FIX) 새로 등장하거나 사라지는 모든 캐릭터들의 이동 상태가 //불량해지는 문제 수정 if(false == (pField && IsMoving())) return; const WzVector* pwzCurPos = m_pPathExplorer->GetPosPtr(); const WzVector* pwzDestPos = m_pPathExplorer->GetTargetPosPtr(); if(!(pwzCurPos && pwzDestPos)) { SUNLOG(eCRITICAL_LOG, "[SendMoveInfo] PosPtr is NULL"); return; } // 남은 거리가 10m 이상인 경우에만 패킷을 보낸다. SERVER_COMMON_OPTION& stServerOptionInfo = ServerOptionParserEx::Instance()->GetServerOption(); float fDistance = VectorLength2(&(*pwzDestPos - *pwzCurPos)); if(fDistance > stServerOptionInfo.m_byGRID_MOVEINFO_DISTANCE*stServerOptionInfo.m_byGRID_MOVEINFO_DISTANCE) { MSGSUB_SYNC_MOVE_BRD msg; msg.m_dwObjectKey = GetObjectKey(); msg.m_byState = (BYTE)m_pMoveStateControl->GetMoveState(); // RUN or WALK msg.m_ForcedMove = false; msg.m_wvCurPos = *pwzCurPos; msg.m_wvDestPos = *pwzDestPos; pEnterPlayer ? pEnterPlayer->SendPacketForSync(&msg) : pField->SendPacketAroundForSync(this, &msg) ; } } void Character::DelFightingEnergy(short sCount) { m_sFightingEnergyCount = max(0, m_sFightingEnergyCount - sCount); const DWORD playerField = Policyment.FIELD & (Policyment.PCC_IN_SSQ_FIELD_PLAYER|Policyment.PCC_IN_DEF_FIELD_PLAYER); if(playerField) { // (WAVERIX)(080731) 개선 여지가 존재한다. MSG_CG_STATUS_REMOVE_BRD BrdMsg; BrdMsg.m_dwTargetKey = GetObjectKey(); BrdMsg.m_dwStatusCode = eCHAR_STATE_SPCHARGE; switch(playerField) { case Policyment.PCC_IN_DEF_FIELD_PLAYER: { for(short i = 0; i < sCount; i++) SendPacketAround(&BrdMsg, BrdMsg.GetSize()); } return; case Policyment.PCC_IN_SSQ_FIELD_PLAYER: { for(short i = 0; i < sCount; i++) this->SendPacket(&BrdMsg, BrdMsg.GetSize()); } return; } } } void Character::SetGameZone(eZONE_STATE eState, GameZone* pZone, MAPCODE EnterFieldCode, WzID AreaID, WzVector* pwvStartPos) { m_eGameZoneState = eState; m_pGameZone = pZone; m_GameFieldCode = EnterFieldCode; m_GameAreaID = AreaID; memset(&m_GameStartPos, 0, sizeof(WzVector)); if(pwvStartPos) m_GameStartPos =* pwvStartPos; } // 타일의 속성값을 빼온다. // 타일을 구해올수 없을경우 (false) // 타일 인덱스에 변화가 있을시 타일 속성을 새로 구해 온다. BOOL Character::GetTileAtt(OUT WORD* wTileAtt) { GameField* const pGameField = GetField(); if(!pGameField) return false; const nsAI::TileEvent* tile_event = 0; if(PlanEvent->GetTileEvent(&tile_event) == false) return false; *wTileAtt = tile_event->Attr; return true; } void Character::ChangePolicy(GameZone* const pGameZone) { const eZONETYPE ztTYPE = pGameZone->GetZoneType(); const BOOLEAN isPlayer = IsEqualObjectKind(PLAYER_OBJECT); switch(ztTYPE) { case eZONETYPE_LOBBY : case eZONETYPE_VILLAGE : case eZONETYPE_CHARSELECT : case eZONETYPE_MISSION : case eZONETYPE_PVP : case eZONETYPE_HUNTING : case eZONETYPE_CHUNTING : case eZONETYPE_FIELD : case eZONETYPE_TUTORIAL_FIELD : case eZONETYPE_DOMINATION_FIELD : case eZONETYPE_SPA_FIELD : //_NA_008069_20150210_ADD_SPA_SYSTEM { const DWORD addin_field = (isPlayer ? Policyment.PCC_IN_DEF_FIELD_PLAYER : 0); Policyment.SetField( (Policyment.PCC_IN_DEF_FIELD | Policyment.PCC_STATUS_BRD_TO_ALL | Policyment.PCC_BATTLE_RECORD_PRIORITY | addin_field )); //Policyment.SetField( // (Policyment.PCC_IN_SSQ_FIELD // | addin_field // )); } break; case eZONETYPE_INSTANCE : { GameInstanceDungeon* const pGameInstanceDungeon = static_cast(pGameZone); const eINSTANCE_DUNGEON_KIND kindOfDungeon = pGameInstanceDungeon->GetTypeOfIndun(); BOOST_STATIC_ASSERT(INDUN_KIND_MAX == 7); // 추가 타입 존재시 하단 내용 추가할 것 switch(kindOfDungeon) { case INDUN_KIND_TOP_OF_TRIAL : case INDUN_KIND_100LEVEL_QUEST : case INDUN_KIND_EXT_03 : case INDUN_KIND_EXT_04 : case INDUN_KIND_MAYA_SCROLL : { const DWORD addin_field = (isPlayer ? Policyment.PCC_IN_DEF_FIELD_PLAYER : 0); Policyment.SetField( (Policyment.PCC_IN_DEF_FIELD | Policyment.PCC_STATUS_BRD_TO_ALL | Policyment.PCC_BATTLE_RECORD_PRIORITY | addin_field )); } break; case INDUN_KIND_SS_QUEST : { const DWORD addin_field = (isPlayer ? Policyment.PCC_IN_SSQ_FIELD_PLAYER : 0); Policyment.SetField( (Policyment.PCC_IN_SSQ_FIELD | addin_field )); } break; //_NA_005026_20120527_CHAOS_ZONE_BATTLE_GROUND case INDUN_KIND_CHAOS_ZONE : { const DWORD addin_field = (isPlayer ? Policyment.PCC_IN_DEF_FIELD_PLAYER : 0); Policyment.SetField( (Policyment.PCC_IN_DEF_FIELD | Policyment.PCC_STATUS_BRD_TO_ALL | Policyment.PCC_BATTLE_RECORD_PRIORITY | addin_field )); }break; default: FlowControl::FCAssert(!"Unexpected IndunType"); break; } } break; default: FlowControl::FCAssert(!"Unexpected ZoneType"); return; }; //---------------------------------------------------------------------------------------------- // CHANGES: f110704.5L, the character types needed separated configurations. // NOTE: f110704.5L, added iff relations to support the custom map unit. // for detailed subscription, see the NpcExtraInfo.NpcType switch (this->GetObjectType()) { case SYNC_MERCHANT_OBJECT: //__NA_276_20070213_UNIT_TRIGGER if (SyncMerchant* npc = static_cast(this)) { const DWORD unit_id = npc->GetRegenID(); if (unit_id == 0) { break; }; // NOTE: f110704.5L, added the iff filter // for support the custom eNPC_MOVE_SYNC_MERCHANT types. // to extend the above rule set, it needs to modify. if (g_ExtraNPCManager.CheckProtectedNpc(npc) == false) { break; }; Policyment.SetField( (Policyment.FIELD) | (Policyment.PCC_PROTECTED_NPC) ); } break; }; //---------------------------------------------------------------------------------------------- } // (CHANGES) (100205) (WAVERIX) EnterField 이후, Character에 대한 세부사항 제어 필요한 경우 // 추가 룰을 설정하기 위함. 특수 사항만 처리할 것 void Character::ChangePolicyPostEnterField(const sPOLICY_CHARACTER::eFLAG add_flag, const sPOLICY_CHARACTER::eFLAG del_flag, Object* related_object) { assert(this->GetField() != NULL); // (WARNING) 함부로 설정을 변경시킬 때, 예기치 못한 문제가 발생할 수 있다. // 검증된 필요한 것들만 필요에 따라 설정/해제하기 위한 제어 루틴 if (del_flag != Policyment.PCC_DISABLE_ALL) { if (del_flag & Policyment.PCC_CONTINUING_NPC_UPDATE) { Policyment.SetField(Policyment.FIELD & ~Policyment.PCC_CONTINUING_NPC_UPDATE); } } if (add_flag != Policyment.PCC_DISABLE_ALL) { // (NOTE) current rule // related_object->IsEqualObjectKind(PLAYER_OBJECT) && // this->IsEqualObjectKind(SUMMON_OBJECT) --> summon npc by player if (add_flag & Policyment.PCC_CONTINUING_NPC_UPDATE) { Policyment.SetField(Policyment.FIELD | Policyment.PCC_CONTINUING_NPC_UPDATE); } // checked by _NA_002098_20110307_ADD_NPC_CONTROL_TRIGGER_BASE if (add_flag & Policyment.PCC_EXIST_AREA_EVENT_NPC) { Policyment.SetField(Policyment.FIELD | Policyment.PCC_EXIST_AREA_EVENT_NPC); }; } } ChaosZoneManager* Character::GetChaosZoneManager() { if (GetGameZonePtr() && GetGameZonePtr()->GetZoneType() == eZONETYPE_INSTANCE) { const GameInstanceDungeon* instance_dungeon = static_cast(GetGameZonePtr()); if (instance_dungeon && instance_dungeon->GetChaosZoneManager()) { return instance_dungeon->GetChaosZoneManager(); } } return NULL; } #ifdef _NA_008299_20150519_MAX_DAMAGE_LOG void Character::WriteMaxDamageLog(Character* pAttacker, DamageArgs* damage_arg) { if (BATTLE_SERVER != g_pGameServer->GetServerType()) { return; } GameZone* game_zone = GetGameZonePtr(); if (pAttacker == NULL || damage_arg == NULL || game_zone == NULL) { return; } CHARGUID target_char_guid = 257252; // u1은빛포르쉐 Player* attacker_player = NULL; if (damage_arg->damage_ < DAMAGETYPE_MAX / 2) { if (pAttacker->IsEqualObjectKind(PLAYER_OBJECT)) { attacker_player = static_cast(pAttacker); if (attacker_player == NULL || attacker_player->GetCharGuid() != target_char_guid) { return; } } else if(pAttacker->IsEqualObjectKind(SUMMON_OBJECT)) { attacker_player = pAttacker->GetPlayerOwner(); if (attacker_player == NULL || attacker_player->GetCharGuid() != target_char_guid) { return; } } else { return; } } else // if (damage_arg->damage_ >= DAMAGETYPE_MAX / 2) { if (pAttacker->IsEqualObjectKind(PLAYER_OBJECT)) { attacker_player = static_cast(pAttacker); if (attacker_player == NULL) { return; } } else if(pAttacker->IsEqualObjectKind(SUMMON_OBJECT)) { attacker_player = pAttacker->GetPlayerOwner(); if (attacker_player == NULL) { return; } } else { return; } } // 소환수 bool is_summoned = false; int summoned_code = 0; if (pAttacker->IsEqualObjectKind(SUMMON_OBJECT)) { is_summoned = true; Summoned* summoned = static_cast(pAttacker); if (summoned != NULL) { const BASE_NPCINFO* pInfo = summoned->GetBaseInfo(); if (pInfo != NULL) { summoned_code = pInfo->m_MonsterCode; } } } // 피격 NPC int npc_code = 0; if (this->IsEqualObjectKind(NPC_OBJECT)) { NPC* npc = static_cast(this); if (npc != NULL) { const BASE_NPCINFO* pInfo = npc->GetBaseInfo(); if (pInfo != NULL) { npc_code = pInfo->m_MonsterCode; } } } GAMELOG->LogMaxDamage(ACT_MAX_DAMAGE, this, pAttacker, damage_arg); } #endif // _NA_008299_20150519_MAX_DAMAGE_LOG