993 lines
41 KiB
C++
993 lines
41 KiB
C++
#pragma once
|
|
|
|
#include "DnUnknownRenderObject.h"
|
|
#include "EtMatrixEx.h"
|
|
#include "Timer.h"
|
|
#include "EtOctree.h"
|
|
#include "DnActionBase.h"
|
|
#include "DnActorState.h"
|
|
#include "MATransAction.h"
|
|
#include "MAActorRenderBase.h"
|
|
#include "MADamageBase.h"
|
|
#include "MASkillUser.h"
|
|
#include "DnBlowDef.h"
|
|
#include "MultiRoom.h"
|
|
#include "MAMovementInterface.hpp"
|
|
#ifdef PRE_FIX_GAMESERVER_OPTIMIZE
|
|
#include "FrameSync.h"
|
|
#endif
|
|
|
|
class CDnStateBlow;
|
|
class CDnProjectile;
|
|
class CDNAggroSystem;
|
|
|
|
class CDnStateBlowSignalProcessor;
|
|
|
|
class CDnActor : public CDnUnknownRenderObject< CDnActor, MAX_SESSION_COUNT >,
|
|
public CDnActionBase,
|
|
virtual public CDnActorState,
|
|
public MASkillUser,
|
|
public MATransAction,
|
|
virtual public MADamageBase,
|
|
public MAMovementInterface,
|
|
virtual public MAActorRenderBase
|
|
{
|
|
public:
|
|
|
|
enum eStateBlowAfterProcessType
|
|
{
|
|
eRebirth = 1,
|
|
eDelZombie = (1<<1),
|
|
};
|
|
|
|
CDnActor( CMultiRoom *pRoom, int nClassID );
|
|
virtual ~CDnActor();
|
|
|
|
friend class CDnActorActionStateCache;
|
|
|
|
enum HitCheckTypeEnum {
|
|
BoundingBox,
|
|
Collision,
|
|
};
|
|
|
|
STATIC_DECL( DWORD s_dwUniqueCount );
|
|
static float s_fDieDelta;
|
|
|
|
protected:
|
|
|
|
STATIC_DECL( CEtOctree<DnActorHandle> *s_pOctree );
|
|
typedef std::map<DWORD, DnActorHandle> mapActorSearch;
|
|
STATIC_DECL( mapActorSearch s_dwMapActorSearch );
|
|
|
|
int m_nClassID;
|
|
DWORD m_dwUniqueID;
|
|
MatrixEx m_Cross;
|
|
EtVector3 m_vStaticPosition;
|
|
SHitParam m_HitParam;
|
|
DnWeaponHandle m_hWeapon[2];
|
|
bool m_bSelfDeleteWeapon[2];
|
|
|
|
CDNAggroSystem* m_pAggroSystem;
|
|
CEtOctreeNode<DnActorHandle> *m_pCurrentNode;
|
|
|
|
bool m_bToggleIngnoreHit;
|
|
|
|
int m_nTeam;
|
|
float m_fStiffDelta;
|
|
float m_fDownDelta;
|
|
float m_fDieDelta;
|
|
float m_fMaxDieDelta;
|
|
float m_fLastDownRatio;
|
|
|
|
#ifdef PRE_ADD_GRAVITY_PROPERTY
|
|
float m_fGravityEnd;
|
|
#endif // PRE_ADD_GRAVITY_PROPERTY
|
|
|
|
map<DWORD, LOCAL_TIME> m_mapLastDamageTime;
|
|
int m_nLastDamageHitterActionIndex;
|
|
|
|
LOCAL_TIME m_LastHitSignalTime;
|
|
|
|
// 마찬가지로 발사체에서 사용하는 마지막 hit 시그널의 유니크 아이디를 피격자별로 갖고 있는다.
|
|
// 여러명이 동시에 타격하면 OnDamage 함수에서 -1로 리셋되어 버린다.
|
|
map<DWORD, int> m_mapLastHitUniqueID;
|
|
int m_nLastHitSignalIndex;
|
|
int m_nAirComboCount;
|
|
|
|
bool m_bEnableNormalSuperAmmor;
|
|
int m_nNormalSuperAmmorTime;
|
|
float m_fBreakNormalSuperAmmorDurability;
|
|
|
|
int m_nLastUpdateSkillSuperAmmorValue[4];
|
|
int m_nSkillSuperAmmorValue[4];
|
|
int m_nSkillSuperAmmorTime;
|
|
float m_fSkillSuperAmmorDamageDecreaseProb;
|
|
|
|
float m_fAddHeight;
|
|
HitCheckTypeEnum m_HitCheckType;
|
|
|
|
bool m_bModifyPlaySpeed;
|
|
LOCAL_TIME m_PlaySpeedStartTime;
|
|
DWORD m_dwPlaySpeedTime;
|
|
float m_fPlaySpeed;
|
|
bool m_bShow;
|
|
bool m_bOctreeUpdate;
|
|
DWORD m_dwGenTick;
|
|
|
|
EtVector3 m_vPrevPosition;
|
|
|
|
struct PreStateStruct {
|
|
int nState;
|
|
int nOffset;
|
|
|
|
PreStateStruct( int State, int Offset ) {
|
|
nState = State;
|
|
nOffset = Offset;
|
|
};
|
|
};
|
|
|
|
std::vector<std::vector<PreStateStruct>> m_VecPreActionState;
|
|
std::vector<std::vector<PreStateStruct>> m_VecPreActionCustomState;
|
|
std::vector<std::vector<PreStateStruct>> m_VecPreCanMoveState;
|
|
|
|
DNVector(DnActorHandle) m_hVecLastHitListByRemainTime;
|
|
DNVector(DnActorHandle) m_hVecLastHitList;
|
|
|
|
CDnStateBlow *m_pStateBlow;
|
|
|
|
// 노말 슈퍼 아머를 무시할 것인지
|
|
bool m_bIngnoreNormalSuperArmor;
|
|
|
|
// 시그널로 액션 중간에 스킬 사용 가능 체크를 처리했는지
|
|
bool m_bUseSignalSkillCheck;
|
|
bool m_abSignalSkillCheck[ 3 ]; // 0:Movable 1:Jumpable 2:GroundMovable
|
|
|
|
// 한기 2009.7.27
|
|
// 자신에게 사용하는 효과 적용 시간 관련 (#1911)
|
|
// 서버로 패킷을 보내지 않고 서버/클라 각자 적용되는 상태효과 큐.
|
|
// 스킬 액션에 ApplyStateEffect 시그널이 따로 있을 경우 이 큐에 들어가서
|
|
// 액션툴에 정의된 타이밍에 적용됨.
|
|
struct S_NO_PACKET_SELF_STATEBLOW
|
|
{
|
|
CDnSkill::SkillInfo ParentSkillInfo;
|
|
CDnSkill::StateEffectStruct StateEffect;
|
|
bool bUsed;
|
|
|
|
S_NO_PACKET_SELF_STATEBLOW( const CDnSkill::SkillInfo& SkillInfo, CDnSkill::StateEffectStruct SE ) :
|
|
ParentSkillInfo( SkillInfo ), StateEffect(SE), bUsed( false )
|
|
{
|
|
|
|
};
|
|
|
|
void Used( void ) { bUsed = true; };
|
|
};
|
|
deque<S_NO_PACKET_SELF_STATEBLOW> m_dqApplySelfStateBlowQ;
|
|
//
|
|
|
|
|
|
// Signal Rotate.
|
|
LOCAL_TIME m_dwRotateStartTime;
|
|
LOCAL_TIME m_dwRotateTime;
|
|
bool m_bRotate;
|
|
bool m_bRotLeft; // 회전방향.
|
|
float m_fSpeedRot; // 회전속도.
|
|
float m_fStartSpeed; // 시작속도.
|
|
float m_fEndSpeed; // 종료속도.
|
|
EtVector3 m_vRotAxis; // 회전축좌표.
|
|
|
|
|
|
INT64 m_iLastDamage;
|
|
int m_iLastProcessPressCount;
|
|
|
|
//Die 호출에 필요한 최종 Hit액터 저장.
|
|
DnActorHandle m_hCompleteKillActor;
|
|
bool m_bCompleteKill_AfterProcessStateBlow;
|
|
|
|
#ifdef _SHADOW_TEST
|
|
bool m_bIsShadowActor;
|
|
bool m_bEnableShadowActor;
|
|
#endif
|
|
std::set<std::string> m_setUseActionName;
|
|
|
|
int m_iCantMoveReferenceCount;
|
|
int m_iCantActionReferenceCount;
|
|
int m_iCantUseSkillReferenceCount;
|
|
int m_iCantAttackReferenceCount;
|
|
|
|
int m_iCantXZMoveSE;
|
|
|
|
// 차져 상태효과로 적의 위치에서 시그널을 돌리고 있을 경우.
|
|
bool m_bOnSignalFromChargerSE;
|
|
DnActorHandle m_hChargetDestActor;
|
|
DnBlowHandle m_hChargerBlowCalledOnSignal;
|
|
|
|
// 차져 상태효과 등에서 나간 발사체에서 맞아서 OnDamage 호출될 때는 콤보 카운트 계산을 하지 않기 위한 플래그
|
|
bool m_bAllowCalcCombo;
|
|
|
|
std::list<DnMonsterActorHandle> m_listSummonMonster;
|
|
|
|
// #32426 소환체 컨트롤 기능 추가 관련.
|
|
// STE_Summon 으로 소환된 몬스터에 그룹 ID 가 정의 되어있다면 m_listSummonMonster 로 추가되지 않고, 이쪽으로 분류되어 관리된다.
|
|
// 같은 그룹의 소환체에 대해서 최대 갯수 이상 소환되지 않는다.
|
|
std::map<int, std::list<DnMonsterActorHandle> > m_mapSummonMonsterByGroup;
|
|
|
|
int m_iFrameStopRefCount;
|
|
|
|
vector<DnBlowHandle> m_vlReservedRemoveBlows;
|
|
std::vector<int> m_vTriggerBuff;
|
|
|
|
// #33312 강제로 셋팅한 속성. #36689 여러군데에서 사용될 수 있으므로 스택 개념으로 처리한다.
|
|
DNVector(int) m_vlForceSettedHitElement;
|
|
|
|
#ifdef PRE_FIX_GAMESERVER_OPTIMIZE
|
|
STATIC_DECL( CFrameSkip s_MonsterProcess );
|
|
STATIC_DECL( float s_fMonsterProcessDelta );
|
|
|
|
STATIC_DECL( CFrameSkip s_NpcProcess );
|
|
STATIC_DECL( float s_fNpcProcessDelta );
|
|
#endif
|
|
public:
|
|
|
|
DWORD GetGenTick(){ return m_dwGenTick; }
|
|
bool bIsCanSummonMonster( const SummonMonsterStruct* pSummonMonsterStruct );
|
|
virtual void PushSummonMonster( DnMonsterActorHandle hMonster, const SummonMonsterStruct* pSummonMonsterStruct, bool bReCreateFollowStageMonster = false );
|
|
|
|
// Note: bOnPlayerInit 은 처음에 스테이지가 로딩되면서 캐릭터 생성되고 초기화 될 시에 패시브 스킬 추가할 때 호출되었다느 뜻
|
|
// AddStateBlow 함수 내부에서 IsDie() 체크하는데, 스테이지 로딩될 시에 캐릭터 초기화 될 때
|
|
// HP가 0 이라서 패시브 스킬 상태효과 추가 안되고 넘어가므로 이 플래그로 구분한다
|
|
int AddStateBlow( STATE_BLOW::emBLOW_INDEX emBlowIndex, const CDnSkill::SkillInfo* pParentSkill, int nDurationTime,
|
|
const char *szParam, bool bOnPlayerInit = false, bool bCheckCanBegin = true , bool bEternity = false );
|
|
|
|
void DelStateBlow( STATE_BLOW::emBLOW_INDEX emBlowIndex );
|
|
DnBlowHandle GetStateBlowFromID( int nStateBlowID );
|
|
int RemoveStateBlowByBlowDefineIndex( STATE_BLOW::emBLOW_INDEX emBlowIndex );
|
|
void RemoveStateBlowFromID( int nStateBlowID );
|
|
void RemoveAllBlow();
|
|
void RemoveAllBlowExpectPassiveSkill();
|
|
bool IsShouldRemainBlowWhenDie( DnBlowHandle hBlow );
|
|
int GetNumAppliedStateBlow( void );
|
|
DnBlowHandle GetAppliedStateBlow( int iIndex );
|
|
void GetAllAppliedStateBlow(DNVector(DnBlowHandle)& /*IN OUT*/ out);
|
|
void GatherAppliedStateBlowByBlowIndex( STATE_BLOW::emBLOW_INDEX BlowIndex, /*IN OUT*/ DNVector(DnBlowHandle)& out );
|
|
bool IsAppliedThisStateBlow( STATE_BLOW::emBLOW_INDEX iBlowIndex );
|
|
CDnStateBlow *GetStateBlow() { return m_pStateBlow; }
|
|
|
|
void GetAllAppliedStateBlowBySkillID(int nSkillID, DNVector(DnBlowHandle)& /*IN OUT*/ out);
|
|
|
|
virtual void OnBeginStateBlow( DnBlowHandle hBlow ) {}
|
|
virtual void OnEndStateBlow( DnBlowHandle hBlow );// {}
|
|
|
|
void SetOnSignalFromChargerSE( bool bOnSignalFromChargerSE ) { m_bOnSignalFromChargerSE = bOnSignalFromChargerSE; };
|
|
bool IsOnSignalFromChargerSE( void ) { return m_bOnSignalFromChargerSE; };
|
|
void SetChargerDestActor( DnActorHandle hChargerDestActor ) { m_hChargetDestActor = hChargerDestActor; };
|
|
void SetChargerBlow( DnBlowHandle hBlow ) { m_hChargerBlowCalledOnSignal = hBlow; };
|
|
|
|
// Hit 체크가 되는 놈들이 있을때마다 불려진다. 때리는 놈 입장에서 콜
|
|
virtual void OnHitSuccess( LOCAL_TIME LocalTime, DnActorHandle hActor, HitStruct *pStruct ) {}
|
|
// 한번의 HitSignal 체크가 끝나고 불려진다. 때리는 놈 입장에서 콜
|
|
virtual void OnHitFinish( LOCAL_TIME LocalTime, HitStruct *pStruct );
|
|
// 발사체가 hit 되었을 때 발사체를 쏜 액터 객체로 호출된다.
|
|
virtual void OnHitProjectile( LOCAL_TIME LocalTime, DnActorHandle hHittedTarget, const CDnDamageBase::SHitParam& HitParam ) {};
|
|
// 액션 체크
|
|
virtual bool IsLimitAction( const char* pszActionName ){ return false; }
|
|
virtual bool IsLimitAction( DnSkillHandle hSkill ){ return false; }
|
|
|
|
void Die( DnActorHandle hHitter );
|
|
void RequestKillAfterProcessStateBlow(DnActorHandle hHitter);
|
|
void ExecuteKillAfterProcessStateBlow();
|
|
|
|
virtual void OnStateBlowProcessAfter(){}
|
|
virtual void OnAddStateBlowProcessAfterType( eStateBlowAfterProcessType Type ){}
|
|
virtual void OnDie( DnActorHandle hHitter );
|
|
virtual void OnBreakSkillSuperAmmor( int nIndex, int nOriginalSupperAmmor, int nDescreaseSupperAmmor ) {} // 깨졋을때 때린놈
|
|
virtual void OnBreakSkillSuperAmmor( SHitParam &HitParam ) {} // 꺠졋을때 깨진놈
|
|
virtual void OnAirCombo( int nComboCount ) {}
|
|
|
|
virtual int OnGetJobClassID(){ return 0; }
|
|
void OnRequestHPMPDelta( /*IN OUT*/ INT64& nHPMPDelta, const DWORD dwHitterUniqueID, bool bIsMPDelta = false );
|
|
#ifdef PRE_FIX_77172
|
|
void RequestHPMPDelta( ElementEnum eElement, INT64 nHPMPDelta, const DWORD dwHitterUniqueID, bool bIsMPDelta = false,
|
|
bool bShowValue = true, CDnDamageBase::SHitParam* pHitParam = NULL, bool bKeepJumpMovement = false );
|
|
#else // PRE_FIX_77172
|
|
void RequestHPMPDelta( ElementEnum eElement, INT64 nHPMPDelta, const DWORD dwHitterUniqueID, bool bIsMPDelta = false, bool bShowValue = true, CDnDamageBase::SHitParam* pHitParam = NULL );
|
|
#endif // PRE_FIX_77172
|
|
void RequestSEProbSuccess( int iSkillID, STATE_BLOW::emBLOW_INDEX eBlowIndex );
|
|
void RequestCooltimeReset( int iSkillID );
|
|
#ifdef PRE_ADD_GRAVITY_PROPERTY
|
|
void SetGravityEnd( float fGravityEnd ) { m_fGravityEnd = fGravityEnd; }
|
|
#endif // PRE_ADD_GRAVITY_PROPERTY
|
|
|
|
protected:
|
|
|
|
void RequestDamage( CDnDamageBase *pHitter, int nSeed, INT64 nDamage );
|
|
|
|
virtual void ProcessState( LOCAL_TIME LocalTime, float fDelta );
|
|
virtual void ProcessDown( LOCAL_TIME LocalTime, float fDelta );
|
|
virtual void ProcessDie( LOCAL_TIME LocalTime, float fDelta );
|
|
virtual void ProcessStiff( LOCAL_TIME LocalTime, float fDelta );
|
|
void ProcessPlaySpeed( LOCAL_TIME LocalTime, float fDelta );
|
|
void ProcessRotate( LOCAL_TIME LocalTime, float fDelta ); // Rotate.
|
|
|
|
virtual void ProcessPress();
|
|
void ProcessPress( DnActorHandle hTarget );
|
|
bool CheckPressCircle2Clrcle2( DnActorHandle hActor1, DnActorHandle hActor2, EtVector2 &Dir, float &Dist ); // 2차원원-2차원원
|
|
bool CheckPressCapsule2Capsule2( DnActorHandle hActor1, DnActorHandle hActor2, EtVector2 &Dir, float &Dist ); // 2차원캡슐-2차원캡슐
|
|
bool CheckPressCapsule2Circle2( DnActorHandle hActor1, DnActorHandle hActor2, EtVector2 &Dir, float &Dist ); // 2차원캡슐-2차원원
|
|
|
|
void LinkWeapon( int nEquipIndex );
|
|
|
|
static bool Compare_PreStateOrder( CDnActor::PreStateStruct &a, CDnActor::PreStateStruct &b );
|
|
virtual const char *CheckChangeActionBlow( const char *szActionName );
|
|
|
|
void ApplyStateEffectSignalProcess( const S_NO_PACKET_SELF_STATEBLOW &StateBlowInfo, ApplyStateEffectStruct* pStruct );
|
|
|
|
// Signal Rotate.
|
|
void SetRotate( DWORD dwTime, float fStart, float fEnd, EtVector3 & vPos, bool bLeft );
|
|
|
|
public:
|
|
|
|
// MASkillUser
|
|
virtual void OnSkillProjectile( CDnProjectile *pProjectile );
|
|
|
|
public:
|
|
// Local
|
|
int GetClassID() { return m_nClassID; }
|
|
|
|
// Movement Message
|
|
virtual void OnClash( EtVector3 &vPosition, OnClashFloorCheckType bFloorClash );
|
|
__forceinline MatrixEx *GetMatEx() { return &m_Cross; }
|
|
|
|
__forceinline void SetPosition( const EtVector3 &vPos ) { m_Cross.m_vPosition = vPos; }
|
|
__forceinline EtVector3 *GetPosition() { return &m_Cross.m_vPosition; }
|
|
|
|
__forceinline void SetStaticPosition( const EtVector3 &vPos ) { m_vStaticPosition = vPos; }
|
|
__forceinline EtVector3 *GetStaticPosition() { return &m_vStaticPosition; }
|
|
|
|
__forceinline void SetPrevPosition( EtVector3 &vPos ) { m_vPrevPosition = vPos; }
|
|
__forceinline EtVector3 *GetPrevPosition() { return &m_vPrevPosition; }
|
|
|
|
DWORD GetUniqueID() { return m_dwUniqueID; }
|
|
virtual void SetUniqueID( DWORD dwUniqueID );
|
|
|
|
CDNAggroSystem* GetAggroSystem() const { return m_pAggroSystem; }
|
|
|
|
virtual void SetTeam( int nValue ) { m_nTeam = nValue; }
|
|
int GetTeam() { return m_nTeam; }
|
|
|
|
float GetAddHeight() { return m_fAddHeight; }
|
|
void SetAddHeight( float fValue ) { m_fAddHeight = fValue; }
|
|
|
|
void SetDownRemainDelta( float fDownDelta ) { m_fDownDelta = fDownDelta; };
|
|
float GetDownRemainDelta() { return m_fDownDelta; }
|
|
|
|
LOCAL_TIME GetDamageRemainTime( DWORD dwActorUniqueID );
|
|
void SetDamageRemainTime( DWORD dwActorUniqueID, LOCAL_TIME LastDamageTime, int nCurrentActionIndex = -1 );
|
|
void SetLastDamageHitUniqueID( DWORD dwActorUniqueID, int iLastHitUniqueID );
|
|
int GetLastDamageHitUniqueID( DWORD dwActorUniqueID );
|
|
|
|
void ResetDamageRemainTime();
|
|
void SetStiffDelta( float fStiffDelta ) { m_fStiffDelta = fStiffDelta; };
|
|
float GetStiffDelta() { return m_fStiffDelta; };
|
|
|
|
bool IsModifyPlaySpeed() { return m_bModifyPlaySpeed; }
|
|
void SetPlaySpeed( DWORD dwFrame, float fSpeed );
|
|
void ResetPlaySpeed( void );
|
|
void SetDieDelta(float fDelta) { m_fDieDelta = fDelta; }
|
|
void SetMaxDieDelta(float fDelta) { m_fMaxDieDelta = fDelta; }
|
|
DWORD GetPlaySpeedFrame() { return m_dwPlaySpeedTime; }
|
|
|
|
void SetOctreeUpdate( bool bFlag ){ m_bOctreeUpdate = bFlag; }
|
|
|
|
// 노말 슈퍼아머를 무시할 것인지 true 면 무시한다.
|
|
void SetIgnoreNormalSuperArmor(bool bIgnore) { m_bIngnoreNormalSuperArmor = bIgnore; }
|
|
bool GetIgnoreNormalSuperArmor() { return m_bIngnoreNormalSuperArmor; }
|
|
|
|
void InsertOctreeNode();
|
|
void RemoveOctreeNode();
|
|
|
|
SHitParam *GetHitParam() { return &m_HitParam; }
|
|
HitCheckTypeEnum GetHitCheckType() { return m_HitCheckType; }
|
|
|
|
virtual void ResetActor();
|
|
|
|
virtual bool Initialize() { return true; }
|
|
virtual void Process( LOCAL_TIME LocalTime, float fDelta );
|
|
virtual void ProcessAI( LOCAL_TIME LocalTime, float fDelta ){}
|
|
virtual void ProcessLook( LOCAL_TIME LocalTime, float fDelta ){};
|
|
virtual bool SetActionQueue( const char *szActionName, int nLoopCount = 0, float fBlendFrame = 3.f, float fStartFrame = 0.f, bool bCheck = true, bool bCheckStateEffect = true );
|
|
virtual void SetCustomAction( const char *szActionName, float fFrame );
|
|
|
|
virtual void SyncClassTime( LOCAL_TIME LocalTime );
|
|
|
|
// Octree 를 위한..
|
|
virtual void GetBoundingSphere( SSphere &Sphere, bool bActorSize = false );
|
|
virtual void GetBoundingBox( SAABox &Box );
|
|
|
|
bool IsShow() { return m_bShow; }
|
|
void Show( bool bShow );
|
|
|
|
// ActionBase
|
|
virtual void OnSignal( SignalTypeEnum Type, void *pPtr, LOCAL_TIME LocalTime, LOCAL_TIME SignalStartTime, LOCAL_TIME SignalEndTime, int nSignalIndex );
|
|
virtual bool LoadAction( const char *szFullPathName );
|
|
virtual void FreeAction();
|
|
void OnLoopAction( float fFrame, float fPrevFrame );
|
|
|
|
// Actor Command
|
|
virtual void CmdRefreshHPSP( INT64 nHP, int nSP );
|
|
virtual void CmdAction( const char *szActionName, int nLoopCount = 0, float fBlendFrame = 3.f, bool bCheckOverlapAction = true, bool bFromStateBlow = false, bool bSkillChain = false );
|
|
virtual void CmdMove( EtVector3 &vPos, const char *szActionName, int nLoopCount = 0, float fBlendFrame = 3.f ) {}
|
|
virtual void CmdMove( DnActorHandle hActor, float fMinDistance, const char *szActionName, int nLoopCount = 0, float fBlendFrame = 3.f ) {}
|
|
virtual void CmdMoveNavi( DnActorHandle hActor, float fMinDistance, const char *szActionName, int nLoopCount = 0, float fBlendFrame = 3.f ) {}
|
|
virtual void CmdMoveNavi( EtVector3& vTargetPos, float fMinDistance, const char *szActionName, int nLoopCount = 0, float fBlendFrame = 3.f ) {}
|
|
virtual void CmdMove( EtVector2 &vDir, const char *szActionName, int nLoopCount = 0, float fBlendFrame = 3.f ) {}
|
|
virtual void CmdStop( const char *szActionName, int nLoopCount = 0, float fBlendFrame = 3.f, float fStartFrame = 0.f ) {}
|
|
virtual void CmdLook( EtVector2 &vVec, bool bForce = false ) {}
|
|
virtual void CmdLook( DnActorHandle hActor, bool bLock = true ) {}
|
|
|
|
// Note: bOnPlayerInit 은 처음에 스테이지가 로딩되면서 캐릭터 생성되고 초기화 될 시에 패시브 스킬 추가할 때 호출되었다느 뜻
|
|
// AddStateBlow 함수 내부에서 IsDie() 체크하는데, 스테이지 로딩될 시에 캐릭터 초기화 될 때
|
|
// HP가 0 이라서 패시브 스킬 상태효과 추가 안되고 넘어가므로 이 플래그로 구분한다
|
|
// [2011/03/18 semozz]
|
|
// 접두어 스킬에서 추가되는 상태 효과 생성과 동시에 OnBegin 적용 여부를 패킷으로 처리 해야 할듯..
|
|
virtual int CmdAddStateEffect( const CDnSkill::SkillInfo* pParentSkillInfo, STATE_BLOW::emBLOW_INDEX emBlowIndex, int nDurationTime, const char *szParam, bool bOnPlayerInit = false, bool bCheckCanBegin = true , bool bEternity = false );
|
|
virtual void CmdModifyStateEffect( int iBlowID, STATE_BLOW& StateBlowInfo );
|
|
|
|
virtual void CmdRemoveStateEffect( STATE_BLOW::emBLOW_INDEX emBlowIndex, bool bRemoveFromServerToo = true );
|
|
virtual void SendRemoveStateEffect( STATE_BLOW::emBLOW_INDEX emBlowIndex ) {};
|
|
virtual void CmdRemoveStateEffectFromID( int nID );
|
|
virtual void CmdRemoveStateEffectImmediately( STATE_BLOW::emBLOW_INDEX emBlowIndex );
|
|
|
|
void SendRemoveStateEffectFromID( int nID );
|
|
void SendAddSEFail( int iAddSEResult, STATE_BLOW::emBLOW_INDEX emBlowIndex );
|
|
|
|
virtual void CmdSuicide( bool bDropItem, bool bDropExp ) {}
|
|
virtual void CmdWarp();
|
|
virtual void CmdWarp( EtVector3 &vPos, EtVector2 &vLook, CDNUserSession* pGameSession=NULL, bool bCheckPlayerFollowSummonedMonster=false );
|
|
virtual void CmdMixedAction( const char *szActionBone, const char *szMaintenanceBone, const char *szActionName, float fFrame, float fBlendFrame = 3.f ) { }
|
|
virtual void CmdChangeTeam( int nTeam );
|
|
virtual void CmdForceVelocity( EtVector3 &vVelocity, EtVector3 &vResistance );
|
|
virtual void CmdChatBalloon( LPCWSTR wszMessage );
|
|
#if defined(PRE_ADD_MULTILANGUAGE)
|
|
virtual void CmdChatBalloon( int nUIStringIndex );
|
|
#endif //#if defined(PRE_ADD_MULTILANGUAGE)
|
|
virtual void CmdShowExposureInfo( bool bShow );
|
|
virtual void CmdForceAddSkill( int nSkillID );
|
|
virtual void CmdForceRemoveSkill( int nSkillID );
|
|
|
|
// Actor Message
|
|
void SetAction( const char *szActionName, float fFrame, float fBlendFrame, bool bLoop = false );
|
|
virtual bool CheckDamageAction( DnActorHandle hActor );
|
|
virtual void CheckDamageVelocity( DnActorHandle hActor );
|
|
virtual float PreCalcDamage( CDnDamageBase *pHitter, SHitParam &HitParam, const float fDefenseRate=1.f, float fStateEffectAttackM = -1.0f );
|
|
virtual float CalcDamage( CDnDamageBase *pHitter, SHitParam &HitParam );
|
|
|
|
// CDnDamageBase
|
|
virtual void OnDamage( CDnDamageBase *pHitter, SHitParam &HitParam, HitStruct *pHitStruct );
|
|
|
|
// Weapon
|
|
virtual void AttachWeapon( DnWeaponHandle hWeapon, int nEquipIndex = 0, bool bDelete = false );
|
|
virtual void DetachWeapon( int nEquipIndex = 0 );
|
|
virtual DnWeaponHandle GetWeapon( int nEquipIndex = 0 ) { return m_hWeapon[nEquipIndex]; }
|
|
void ShowWeapon( int nEquipIndex, bool bShow );
|
|
|
|
virtual DnWeaponHandle GetActiveWeapon( int nEquipIndex ) { return m_hWeapon[nEquipIndex]; }
|
|
|
|
// Projectile
|
|
virtual void OnProjectile( CDnProjectile *pProjectile, ProjectileStruct* pStruct, MatrixEx& LocalCross, int nSignalIndex );
|
|
|
|
// Additional Packet Message
|
|
// Damage Packet
|
|
virtual void OnDamageWriteAdditionalPacket( CPacketCompressStream *pStream ) {}
|
|
virtual void OnDamageReadAdditionalPacket( CPacketCompressStream *pStream ) {}
|
|
|
|
// AI
|
|
virtual bool bIsAILook(){ return false; }
|
|
|
|
//
|
|
virtual bool IsGMTrace() const { return false; }
|
|
|
|
// Static 함수들
|
|
static bool InitializeClass( CMultiRoom *pRoom );
|
|
static void ProcessClass( CMultiRoom *pRoom, LOCAL_TIME LocalTime, float fDelta );
|
|
static void ProcessAIClass( CMultiRoom *pRoom, LOCAL_TIME LocalTime, float fDelta );
|
|
static void ReleaseClass( CMultiRoom *pRoom );
|
|
static DnActorHandle FindActorFromUniqueID( CMultiRoom *pRoom, DWORD dwUniqueID );
|
|
static DnActorHandle FindActorFromName( CMultiRoom *pRoom, TCHAR *szName );
|
|
static void InsertUniqueSearchMap( CMultiRoom *pRoom, CDnActor *pActor );
|
|
static void RemoveUniqueSearchMap( CMultiRoom *pRoom, CDnActor *pActor );
|
|
static void InitializeNextStage( CMultiRoom* pRoom );
|
|
|
|
// Range Scan 함수들
|
|
static int ScanActor( CMultiRoom *pRoom, EtVector3 &vPos, float fRadius, DNVector(DnActorHandle) &VecList, bool bInside = false );
|
|
static void GetActorList(CMultiRoom *pRoom, DNVector(DnActorHandle) &VecList);
|
|
static void GetOpponentActorList(CMultiRoom *pRoom, int nTeam, DNVector(DnActorHandle) &VecList, EtVector3* pPos=NULL, float fMaxRange=0.f );
|
|
|
|
static int ScanActorByActorSize( CMultiRoom *pRoom, EtVector3 &vPos, float fRadius, DNVector(DnActorHandle) &VecList, bool bInside = false, bool bActorSize = false );
|
|
|
|
// 게임서버는 속도를 위해 = NULL 로 안하고 함수 자체를 나눕니다.
|
|
__inline int GetState() { return CDnActorState::GetState(); }
|
|
int GetState( const char *szActionName );
|
|
int GetState( int nElementIndex );
|
|
|
|
bool IsStay( const char *szActionName );
|
|
bool IsMove( const char *szActionName );
|
|
bool IsAttack( const char *szActionName );
|
|
bool IsHit( const char *szActionName );
|
|
bool IsAir( const char *szActionName );
|
|
bool IsDown( const char *szActionName );
|
|
bool IsStun( const char *szActionName );
|
|
bool IsStiff( const char *szActionName );
|
|
bool IsFly( const char *szActionName );
|
|
bool IsGround( const char *szActionName );
|
|
bool IsStandHit( const char *szActionName );
|
|
|
|
__inline bool IsStay() { return ( CDnActorState::GetState() & ActorStateEnum::Stay ) ? true : false; }
|
|
__inline bool IsMove() { return ( CDnActorState::GetState() & ActorStateEnum::Move ) ? true : false; }
|
|
__inline bool IsAttack() { return ( CDnActorState::GetState() & ActorStateEnum::Attack ) ? true : false; }
|
|
__inline bool IsHit() { return ( CDnActorState::GetState() & ActorStateEnum::Hit ) ? true : false; }
|
|
__inline bool IsAir() { return ( CDnActorState::GetState() & ActorStateEnum::Air ) ? true : false; }
|
|
__inline bool IsDown() { return ( CDnActorState::GetState() & ActorStateEnum::Down ) ? true : false; }
|
|
__inline bool IsStun() { return ( CDnActorState::GetState() & ActorStateEnum::Stun ) ? true : false; }
|
|
__inline bool IsStiff() { return ( CDnActorState::GetState() & ActorStateEnum::Stiff ) ? true : false; }
|
|
__inline bool IsFly() { return ( CDnActorState::GetCustomState() & ActorCustomStateEnum::Custom_Fly ) ? true : false; }
|
|
__inline bool IsFly2() { return ( CDnActorState::GetCustomState() & ActorCustomStateEnum::Custom_Fly2 ) ? true : false; }
|
|
__inline bool IsGround() { return ( CDnActorState::GetCustomState() & ActorCustomStateEnum::Custom_Ground ) ? true : false; }
|
|
__inline bool IsUnderGround() { return ( CDnActorState::GetCustomState() & ActorCustomStateEnum::Custom_UnderGround ) ? true : false; }
|
|
__inline bool IsStandHit() {
|
|
int nState = CDnActorState::GetState();;
|
|
if( nState == ActorStateEnum::Hit || nState == ( ActorStateEnum::Hit | ActorStateEnum::Stiff ) ) return true;
|
|
return false;
|
|
}
|
|
|
|
virtual bool IsHittable( DnActorHandle hHitter, LOCAL_TIME LocalTime, HitStruct *pHitSignal = NULL, int iHitUniqueID = -1 );
|
|
virtual bool IsHittableSkill( int iSkillIndex , bool &bSendResist );
|
|
|
|
virtual void ProcessCollision( EtVector3 &vMove );
|
|
|
|
virtual bool IsPlayerActor() { return false; }
|
|
virtual bool IsNpcActor(){ return false; }
|
|
virtual bool IsMonsterActor(){ return false; }
|
|
virtual bool IsPartsMonsterActor(){ return false; }
|
|
virtual bool IsVehicleActor() { return false; }
|
|
virtual UINT GetSessionID(){ return 0; }
|
|
virtual int GetSwapSingleSkinActorID() { return -1; }
|
|
virtual int GetMonsterMutationTableID(){ return -1; }
|
|
|
|
virtual bool bIsDestroyParts( const UINT uiTableID ){ return false; }
|
|
virtual bool bIsDestroySetParts( const UINT uiSetID ){ return false; }
|
|
virtual DWORD GetDamageObjectUniqueID() { return GetUniqueID(); }
|
|
|
|
virtual void OnInitializeNextStage( void );
|
|
void OnInitializePVPRoundRestart( void );
|
|
|
|
void AddedCantMoveSE( void ) { ++m_iCantMoveReferenceCount; };
|
|
void RemovedCantMoveSE( void ) { if( m_iCantMoveReferenceCount > 0 ) --m_iCantMoveReferenceCount; };
|
|
int GetCantMoveSEReferenceCount( void ) { return m_iCantMoveReferenceCount; };
|
|
void AddedCantActionSE( void ) { ++m_iCantActionReferenceCount; };
|
|
void RemovedCantActionSE( void ) { if( m_iCantActionReferenceCount > 0 ) --m_iCantActionReferenceCount; };
|
|
int GetCantActionSEReferenceCount( void ) { return m_iCantActionReferenceCount; };
|
|
void AddedCantUseSkillSE( void ) { ++m_iCantUseSkillReferenceCount; };
|
|
void RemovedCantUseSkillSE( void ) { if( m_iCantUseSkillReferenceCount > 0 ) --m_iCantUseSkillReferenceCount; };
|
|
int GetCantUseSkillSEReferenceCount( void ) { return m_iCantUseSkillReferenceCount; };
|
|
void AddedCantAttackSE( void ) { ++m_iCantAttackReferenceCount; };
|
|
void RemovedCantAttackSE( void ) { if( m_iCantAttackReferenceCount > 0 ) --m_iCantAttackReferenceCount; };
|
|
int GetCantAttackSEReferenceCount( void ) { return m_iCantAttackReferenceCount; };
|
|
void AddedCantXZMoveSE( void ) { ++m_iCantXZMoveSE; };
|
|
void RemovedCantXZMoveSE( void ) { if( m_iCantXZMoveSE ) --m_iCantXZMoveSE; };
|
|
int GetCantXZMoveSEReferenceCount( void ) { return m_iCantXZMoveSE; };
|
|
|
|
void ResetStateEffect( int nSkillDurationType );
|
|
void CmdSyncBlow( CDNUserSession* pGameSession );
|
|
|
|
// from CDnDamageBase
|
|
virtual DnActorHandle GetActorHandle( void ) { return GetMySmartPtr(); };
|
|
|
|
bool IsUseSignalSkillCheck( void ) { return m_bUseSignalSkillCheck; };
|
|
bool IsAllowedSkillCheck( int nCheckType )
|
|
{
|
|
if( 0 <= nCheckType && nCheckType < 3 )
|
|
return m_abSignalSkillCheck[ nCheckType ];
|
|
else
|
|
return false;
|
|
}
|
|
void SetSignalSkillCheck( int nCheckType, bool bCheck )
|
|
{
|
|
if( 0 <= nCheckType && nCheckType < 3 )
|
|
m_abSignalSkillCheck[ nCheckType ] = bCheck;
|
|
}
|
|
|
|
void ResetProcessSkill()
|
|
{
|
|
if( IsProcessSkill() )
|
|
{
|
|
if( m_hProcessSkill )
|
|
{
|
|
m_hProcessSkill->OnEnd( CDnActionBase::m_LocalTime, 0.f );
|
|
m_hProcessSkill.Identity();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool bIsObserver();
|
|
static float SquaredDistance( const EtVector3& vPos, const SAABox& BBox, bool bNear = true );
|
|
|
|
// 액션이 바뀌는 시점을 받아와서 스킬 종료시킴. 스킬 중간에 다른 액션 나갈 수 있게 되었으므로
|
|
// 스킬을 종료시켜서 상태효과 적용 종료 시점을 정확하게 맞춘다.
|
|
//virtual void OnChangeAction( const char *szPrevAction );
|
|
|
|
ElementEnum CalcHitElementType( bool bUseSkillApplyWeaponElement, CDnState::ElementEnum eSkillElement = CDnState::ElementEnum_Amount, bool bUsingSkill = false );
|
|
|
|
// 한기 2009.7.27
|
|
// 자신에게 사용하는 효과 적용 시간 관련 (#1911)
|
|
void AddStateEffectQueue( const CDnSkill::SkillInfo& ParentSkillInfo, const CDnSkill::StateEffectStruct& StateEffectInfo );
|
|
void ClearSelfStateSignalBlowQueue( bool bItemSkill = false );
|
|
//
|
|
|
|
#ifdef _SHADOW_TEST
|
|
void EnableShaodowActor( bool bValue ) { m_bEnableShadowActor = bValue; }
|
|
bool IsShadowActor() { return m_bIsShadowActor; }
|
|
bool IsShadowActor() const { return m_bIsShadowActor; }
|
|
#endif
|
|
|
|
void ResetSkillSuperAmmor( void ) { ZeroMemory( m_nSkillSuperAmmorValue, sizeof(m_nSkillSuperAmmorValue) ); };
|
|
void SetSkillSuperAmmor( int iValue ) { m_nSkillSuperAmmorValue[ 0 ] = iValue; };
|
|
|
|
INT64 GetLastDamage( void ) { return m_iLastDamage; };
|
|
|
|
// 상태효과에서 MP 쓰는 순간을 체크하기 위해... 현재 서버에서만 사용한다.
|
|
// MP 소모를 줄이거나 늘이는 상태효과에서 사용하는 부분임.
|
|
// 이 함수를 통해서 소모된 MP 는 서버에서 패킷이 따로 오므로 클라에서 할 일은 없다!
|
|
void UseMP( int iMPDelta );
|
|
|
|
// 소환된 액터라면 주인을 셋팅함.
|
|
// 몬스터 액터에서 오버라이드해서 클라로 패킷을 쏴줌.
|
|
virtual void SlaveOf( DWORD dwSummonerActorUniqueID, bool bSummoned = false, bool bSuicideWhenSummonerDie = false, bool bFollowSummonerStage = false, bool bReCreateFollowStageMonster = false ) {};
|
|
|
|
void SetAllowCombo( bool bAllowCombo ) { m_bAllowCalcCombo = bAllowCombo; };
|
|
bool IsAllowCombo( void ) { return m_bAllowCalcCombo; };
|
|
|
|
void ToggleIgnoreHit(){ m_bToggleIngnoreHit ^= 1; }
|
|
bool bIsIgnoreHit(){ return m_bToggleIngnoreHit; }
|
|
|
|
void AddedFrameStop( void );
|
|
void RemovedFrameStop( void );
|
|
int GetFrameStopRefCount( void ) { return m_iFrameStopRefCount; };
|
|
void UpdateFPS( void );
|
|
|
|
void AddReserveRemoveBlow( DnBlowHandle hBlow ) { m_vlReservedRemoveBlows.push_back( hBlow ); };
|
|
void ProcessReservedRemoveBlows( void );
|
|
|
|
// 상태효과 측에서 데미지를 가하는 경우. 우선 데미지 반사에서만 쓰임. 데미지 값은 양수로 받는다. #23104
|
|
virtual void RequestDamageFromStateBlow( DnBlowHandle hFromBlow, int iDamage, CDnDamageBase::SHitParam* pHitParam = NULL );
|
|
|
|
// 트리거로 추가된 버프 추가, 삭제
|
|
void ClearTriggerBuff();
|
|
void AddTriggerBuff( int nID ) { m_vTriggerBuff.push_back(nID); }
|
|
|
|
void CmdFreezingPrisonDurablity(int nStateBlowID, float fDuabilityRate, bool bShowGauge);
|
|
|
|
virtual void RemoveResetStateBlow();
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// 때리는 녀석 넉백 시키기위한 함수 [2011/01/14 semozz]
|
|
void ForceKnockBack(DnActorHandle hActor, CDnDamageBase::SHitParam& HitParam);
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
//해당 맵에서 허용되지 않은 아이템에 의해서 적용된 상태효과를 제거한다.
|
|
void RemoveNonAvailableStateBlow();
|
|
|
|
// 활성화된 상태효과 제거.
|
|
void RemovedActivatedStateBlow( bool bIgnoreItemSkill = false );
|
|
|
|
|
|
//#if defined(스킬쿨타임비율)
|
|
void FindSkillBySkillType(CDnSkill::SkillTypeEnum eSkillType, DNVector(DnSkillHandle)& vlSkillList);
|
|
//#endif // 스킬쿨타임비율
|
|
|
|
// 현재 엘리멘탈로드의 아이시 프랙션에서만 예외적으로 2가지의 상태효과 필터링을 걸고 있는데
|
|
// 둘 중에 하나만 hit 되길 원하기 때문에 먼저 체크된 것은 다음 필터링에 걸리지 않도록 한다. #28747
|
|
// CDnPlayerActor 에서 상속 받음.
|
|
virtual void OnHitSignalStateEffectFilterException( DWORD dwTargetActorUniqueID, int iBlowIndex ) {};
|
|
virtual bool CheckHitSignalStateEffectFilterException( DWORD dwTargetActorUniqueID, int iBlowIndex ) { return true; };
|
|
|
|
virtual bool IsMyRelicMonster( DnActorHandle hActor ) { return false; };
|
|
|
|
#ifdef PRE_ADD_MONSTER_CATCH
|
|
bool CatchCalcSuperArmor( DnActorHandle hCatcherActor, int iSuperArmorDamage );
|
|
#endif // #ifdef PRE_ADD_MONSTER_CATCH
|
|
|
|
|
|
void CmdUpdateStateBlow(int nBlowID);
|
|
void CmdFinishAuraSkill(DWORD nSkillID);
|
|
|
|
bool IsImmuned(STATE_BLOW::emBLOW_INDEX blowIndex);
|
|
|
|
//접두어 상태효과 강제 OnBegin호출을 위한 함수
|
|
void ForceBeginStateBlow(DnBlowHandle hBlow);
|
|
|
|
protected:
|
|
CDnStateBlowSignalProcessor* m_pStateBlowSignalProcessor;
|
|
|
|
bool CanUsePrefixSkill();
|
|
public:
|
|
void AddStateBlowSignal(DnBlowHandle hBlow);
|
|
void RemoveStateBlowSignal(DnBlowHandle hBlow);
|
|
|
|
virtual bool CheckCollisionHitCondition(const EtVector3& vObjPos, const MatrixEx& objCross, EtVector3 &vTargetPos, float angleAllow);
|
|
|
|
public:
|
|
struct HitLimitCountInfo
|
|
{
|
|
int nHitLimitCount;
|
|
int nHitCount;
|
|
|
|
HitLimitCountInfo(int nLimitCount, int hitCount)
|
|
{
|
|
nHitCount = hitCount;
|
|
nHitLimitCount = nLimitCount;
|
|
}
|
|
};
|
|
typedef std::map<int, HitLimitCountInfo> HIT_LIMIT_COUNT_INFO_LIST;
|
|
HIT_LIMIT_COUNT_INFO_LIST m_HitLimitCountInfoList;
|
|
|
|
protected:
|
|
struct ActorHandleComp
|
|
{
|
|
bool operator()(const DnActorHandle& h1, const DnActorHandle& h2) const
|
|
{
|
|
return (h1.GetHandle() < h2.GetHandle());
|
|
}
|
|
};
|
|
|
|
struct StateBlowInfo
|
|
{
|
|
STATE_BLOW::emBLOW_INDEX blowIndex;
|
|
std::string strValue;
|
|
};
|
|
|
|
typedef std::list<StateBlowInfo> STATE_BLOW_INFO_LIST;
|
|
struct StealMagicBuffInfo
|
|
{
|
|
CDnSkill::SkillInfo skillInfo; //스킬 정보
|
|
int nDurationTime; //상태효과 지속 시간
|
|
|
|
STATE_BLOW_INFO_LIST stateBlowList;
|
|
};
|
|
|
|
typedef std::map<DnActorHandle, StealMagicBuffInfo, ActorHandleComp> STEAL_MAGIC_BUFF_INFO_LIST; //스틸 매직으로 추가할 상태효과 후보 리스트
|
|
typedef std::map<int, std::list<int>> STEAL_MAGIC_BUFF_LIST; //스틸 매직에의해 적용된 상태효과 리스트
|
|
|
|
STEAL_MAGIC_BUFF_INFO_LIST m_StealMagicBuffAddList; //스틸 매직에서 추가할 후보 리스트
|
|
STEAL_MAGIC_BUFF_LIST m_StealMagicBuffList; //실제 적용된 리스트
|
|
|
|
std::map<int, int> m_RemovedStealMagicStateBlowIDList; //OnEndStateBlow에서 제거되는 상태효과가 스틸 매직에 의한 녀석일때 담아 놓는 리스트
|
|
public:
|
|
void ReserveStealMagicBuff(DnActorHandle hActor, CDnSkill::SkillInfo *pSkillInfo, int nDurationTime, STATE_BLOW::emBLOW_INDEX blowIndex, const char* szValue); //스틸 매직으로 추가할 상태효과 정보를 예약한다..
|
|
void UpdateStealMagicBuff(); //예약된 <스킬, 상태효과 리스트> 중 하나를 선택해서 실제 액터에 상태효과 적용
|
|
|
|
protected:
|
|
void AddStealMagicStateBlow(int nSkillID, int nBlowID);
|
|
void RemoveStealMagicStateBlow(int nDeletedBlowID);
|
|
|
|
LOCAL_TIME CheckRemainFrameTime();
|
|
|
|
|
|
protected:
|
|
int m_nOriginalTeam;
|
|
public:
|
|
void SetOriginalTeam(int nTeam) { m_nOriginalTeam = nTeam; }
|
|
int GetOriginalTeam() { return m_nOriginalTeam; }
|
|
|
|
void PushForceHitElement( ElementEnum eElement ) { m_vlForceSettedHitElement.push_back(eElement); };
|
|
void PopForceHitElement( void ) { m_vlForceSettedHitElement.pop_back(); };
|
|
|
|
const std::list<DnMonsterActorHandle>& GetSummonedMonsterList( void );
|
|
const std::map<int, std::list<DnMonsterActorHandle> >& GetGroupingSummonedMonsterList( void );
|
|
|
|
DnMonsterActorHandle FindOldSummonMonster(const SummonMonsterStruct* pSummonMonsterStruct);
|
|
|
|
void RequestActionChange(int nActionIndex);
|
|
|
|
void SendChainAttackProjectile(DnActorHandle hRootAttacker, DWORD dwPrevAttackerActorUniqueID, int iActionIndex, int iProjectileSignalArrayIndex, DnActorHandle hActorToAttack, int iSkillID);
|
|
|
|
#ifdef PRE_FIX_GAMESERVER_PERFOMANCE
|
|
virtual bool IsAllowCallSkillProcess( float fDelta ) { return false; };
|
|
#endif // #ifdef PRE_FIX_GAMESERVER_PERFOMANCE
|
|
|
|
void RemoveStateEffectByHitSignal(HitStruct* pHitStruct);
|
|
|
|
virtual void UpdateMissionByMonsterKillCount(int nCount) {};
|
|
|
|
bool ProcessIgnoreHitSignal();
|
|
bool ProcessIgnoreGravitySignal();
|
|
|
|
//상태효과 CDnApplyStateBlowOnTimeBlow에 의해서 스킬의 상태효과 추가
|
|
protected:
|
|
std::vector<DnSkillHandle> m_ApplySkillStateEffectList;
|
|
public:
|
|
void AddSkillStateEffect(DnSkillHandle hSkill);
|
|
void ApplySkillStateEffect();
|
|
|
|
void SendProbInvincibleSuccess( void );
|
|
|
|
protected:
|
|
std::string m_FindAutoTargetName;
|
|
public:
|
|
void SetFindAutoTargetName(const char* szBipName) { m_FindAutoTargetName = szBipName ? szBipName : ""; }
|
|
std::string& GetFindAutoTargetName() { return m_FindAutoTargetName; }
|
|
|
|
//실제 캐릭터의 위치가 이동 되는 몬스터가 아닌경우 "Bip01"의 위치를 반환하기 위한 함수
|
|
//그린드래곤에서 가이디드샷 문제점. 일단 다른 액터들은 기존의 액터 위치를 반환 한다.
|
|
EtVector3 FindAutoTargetPos();
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// 무기 변경시 장착된 무기의 SelfDelete정보 얻기위한 함수.
|
|
public:
|
|
bool GetWeaponSelfDelete(int nIndex) { return m_bSelfDeleteWeapon[nIndex]; }
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//무기 변경 상태효과에 사용될 Attach/Detach Weapon Lock 함수
|
|
protected:
|
|
bool m_bChangeWeaponLocked;
|
|
bool m_bSkipChangeWeaponAction; //무기 교체 액션 스킵..
|
|
bool m_bSkipOnAttatchDetachWeapon; //무기 교체후 OnAttachWeapon/OnDetachWeapon함수 호출 스킵 설정
|
|
public:
|
|
void SetChangeWeaponLock(bool bLock) { m_bChangeWeaponLocked = bLock; }
|
|
bool IsChangeWeaponLock() { return m_bChangeWeaponLocked; }
|
|
void SetSkipChangeWeaponAction(bool bSkip) { m_bSkipChangeWeaponAction = bSkip; }
|
|
bool IsSkipChangeWeaponAction() { return m_bSkipChangeWeaponAction; }
|
|
void SetSkipOnAttatchDetachWeapon(bool bSkip) { m_bSkipOnAttatchDetachWeapon = bSkip; }
|
|
bool IsSkipOnAttatchDetachWeapon() { return m_bSkipOnAttatchDetachWeapon; }
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
#if defined(PRE_ADD_50917)
|
|
protected:
|
|
int m_ChangeWeaponRefCount;
|
|
|
|
DnWeaponHandle m_hOrigWeaponWhenChangeWeapon; //무기 해제 시점의 원래 무기 정보
|
|
bool m_bOrigWeaponWhenChangeWeaponSelfDelete; //무기 해제 시점의 원래 SelfDelete정보
|
|
|
|
public:
|
|
void AddChangeWeaponRefCount() { ++m_ChangeWeaponRefCount; }
|
|
void RemoveChangeWeaponRefCount() { --m_ChangeWeaponRefCount; }
|
|
int GetChangeWeaponRefCount() { return m_ChangeWeaponRefCount; }
|
|
|
|
void SetOrigWeaponWhenChangeWeapon(DnWeaponHandle hWeapon, bool bSelfDelete) { m_hOrigWeaponWhenDisarmament = hWeapon, m_bOrigWeaponWhenDisarmamentSelfDelete = bSelfDelete; }
|
|
DnWeaponHandle GetOrigWeaponWhenChangeWeapon() { return m_hOrigWeaponWhenDisarmament; }
|
|
bool GetOrigWeaponWhenChangeWeaponSelfDelete() { return m_bOrigWeaponWhenDisarmamentSelfDelete; }
|
|
#endif // PRE_ADD_50917
|
|
|
|
#if defined(PRE_ADD_50907)
|
|
protected:
|
|
int m_DisarmamentRefCount;
|
|
|
|
DnWeaponHandle m_hOrigWeaponWhenDisarmament; //무기 해제 시점의 원래 무기 정보
|
|
bool m_bOrigWeaponWhenDisarmamentSelfDelete; //무기 해제 시점의 원래 SelfDelete정보
|
|
|
|
public:
|
|
void AddDisarmamentRefCount() { ++m_DisarmamentRefCount; }
|
|
void RemoveDisarmamentRefCount() { --m_DisarmamentRefCount; }
|
|
int GetDisarmamentRefCount() { return m_DisarmamentRefCount; }
|
|
|
|
void SetOrigWeaponWhenDisarmament(DnWeaponHandle hWeapon, bool bSelfDelete) { m_hOrigWeaponWhenDisarmament = hWeapon, m_bOrigWeaponWhenDisarmamentSelfDelete = bSelfDelete; }
|
|
DnWeaponHandle GetOrigWeaponWhenDisarmament() { return m_hOrigWeaponWhenDisarmament; }
|
|
bool GetOrigWeaponWhenDisarmamentSelfDelete() { return m_bOrigWeaponWhenDisarmamentSelfDelete; }
|
|
#endif // PRE_ADD_50907
|
|
|
|
#if defined(PRE_FIX_50482)
|
|
protected:
|
|
int m_nChangeTeamRefCount;
|
|
public:
|
|
void AddChangeTeamRefCount() { ++m_nChangeTeamRefCount; }
|
|
void RemoveChangeTeamRefCount() { --m_nChangeTeamRefCount; }
|
|
int GetChangeTeamRefCount() { return m_nChangeTeamRefCount; }
|
|
#endif // PRE_FIX_50482
|
|
|
|
#if defined(PRE_FIX_51048)
|
|
void RemoveDebufAction(LOCAL_TIME LocalTime, float fDelta);
|
|
#endif // PRE_FIX_51048
|
|
|
|
virtual void SetState(ActorStateEnum State);
|
|
virtual void OnAttackChange();
|
|
|
|
void ScanActorByStateIndex(DNVector(DnActorHandle) &Veclist, STATE_BLOW::emBLOW_INDEX blowIndex);
|
|
|
|
#if defined(PRE_FIX_55378)
|
|
//차저 상태효과의 SignalProcess에서 Player액터인 경우 프로젝타일 생성은 서버/클라이언트가 각자 생성 하기때문에 상관 없으나
|
|
//몬스터 액터인 경우 클라이언트에서는 발사체 생성을 하지 않고, 서버에서 패킷을 받아 발사체를 생성하게 되느데,
|
|
//이 시점에서 받는 ActionIndex정보가 일지 하지 않아서 클라이언트쪽에서 발사체 생성이 되지 않는다.
|
|
//차저 상태효과의 SignalProcess에서 DnActor::OnSignal함수 호출 전에 차저 액션을 설정 해 놓고, 끝날때 리셋 시켜 놓는다.
|
|
//발사체 패킷 전송에서 ChargerAction이 설정 되어 있으면 m_nActionIndex 대신 ChargerAction의 액션Index로 바꾸어 패킷 전송한다.
|
|
protected:
|
|
std::string m_ChargerAction;
|
|
|
|
public:
|
|
void SetChargerAction(const char* szActionName) { m_ChargerAction = szActionName ? szActionName : ""; }
|
|
std::string& GetChargerAction() { return m_ChargerAction; }
|
|
#endif // PRE_FIX_55378
|
|
|
|
//#53454 꼭두각시 Hit시그널 처리시 꼭두각시를 소환한 액터와 꼭두각시 2액터가 Hit시그널 처리가 되어
|
|
//데미지가 2배 적용이 되는데, 같은 시그널 처리시에 Hit액터 리스트에서 꼭두각시/꼭두각시 주인 액터를 조사 해서,
|
|
//꼭두각시 주인 액터는 Hit시그널 처리에서 제외 시킨다.
|
|
public:
|
|
static int ExceptionHitList(DNVector(DnActorHandle) &hVecList, MatrixEx& Cross, DnActorHandle hHiterActor, HitStruct* pStruct);
|
|
static int ExceptionHitList2(DNVector(DnActorHandle) &hVecList, MatrixEx& Cross, DnActorHandle hHiterActor, HitStruct* pStruct,
|
|
DNVector(DnActorHandle)& hAddStateEffectActorList,
|
|
int checkType, float fScanLength, EtVector3& vPrePos);
|
|
static void CheckHitAreaActorList(DNVector(DnActorHandle)& hVecList, MatrixEx& Cross, DnActorHandle hHiterActor, HitStruct* pStruct, int checkType, float fScanLength, EtVector3& vPrePos);
|
|
|
|
#if defined(PRE_FIX_59347)
|
|
protected:
|
|
bool m_bApplyPartsDamage;
|
|
|
|
public:
|
|
void SetApplyPartsDamage(bool bEnable) { m_bApplyPartsDamage = bEnable; }
|
|
bool GetApplyPartsDamage() { return m_bApplyPartsDamage; }
|
|
|
|
virtual void ApplyPartsDamage(float& fDamage, DnActorHandle hHitterActor) {}
|
|
#endif // PRE_FIX_59347
|
|
|
|
#if defined(PRE_FIX_61382)
|
|
//꼭두각시 몬스터일 경우 주인 액터 반환.
|
|
static DnActorHandle GetOwnerActorHandle(DnActorHandle hActor);
|
|
#endif // PRE_FIX_61382
|
|
|
|
#if defined(PRE_ADD_65808)
|
|
protected:
|
|
//몬스터에 스킬 문장 여러개 가능..
|
|
std::map<int, std::list<int>> m_SummonMonsterGlyphInfo;
|
|
//몬스터, 스킬문장, 상태효과..
|
|
struct _StateEffectInfo
|
|
{
|
|
int nStateEffectID;
|
|
DWORD dwUniqueID;
|
|
};
|
|
std::map<int, std::map<int, std::list<_StateEffectInfo>>> m_SummonMonsterGlyphStateEffectIDs;
|
|
|
|
public:
|
|
void AddSummonMonsterGlyphInfo(int monsterID, int glyphID);
|
|
void AddSummonMonsterGlyphStateEffectID(int monsterID, int glyphID, DWORD dwMonsterUniqueID, int stateEffectID);
|
|
|
|
//스킬 문장이 제거 될때 호출..
|
|
void RemoveSummonMonsterGlyphInfo(int monsterID, int glyphID);
|
|
void RemoveSummonMonsterStateEffectByGlyph(DnMonsterActorHandle hMonsterActor, int monsterID, int glyphID);
|
|
|
|
//몬스터가 죽은 경우 이펙트 ID등록 해놓은거 전부 제거..
|
|
void RemoveSummonMonsterGlyphStateEffects(int monsterID);
|
|
|
|
bool GetSummonMonsterGlyphInfo(int monsterID, std::list<int>& glyphIDs);
|
|
|
|
//monsterID가 같은 소환 몬스터들을 찾는다.
|
|
void FindSummonMonster(int monsterID, std::list<DnMonsterActorHandle>& monsterActorList);
|
|
#endif // PRE_ADD_65808
|
|
|
|
|
|
#if defined(PRE_FIX_68898)
|
|
public:
|
|
void SetSkipEndAction(bool isSkipEndAction);
|
|
#endif // PRE_FIX_68898
|
|
};
|
|
|
|
class CDnActorActionStateCache:public CSingleton<CDnActorActionStateCache>
|
|
{
|
|
public:
|
|
|
|
void LoadAction( CDnActor* pActor, const char* szFullPathName, std::vector<CEtActionBase::ActionElementStruct*>* pVecActionElementList, \
|
|
std::vector<std::vector<CDnActor::PreStateStruct>>& ActionState, \
|
|
std::vector<std::vector<CDnActor::PreStateStruct>>& ActionCustomState, \
|
|
std::vector<std::vector<CDnActor::PreStateStruct>>& CanMoveState );
|
|
|
|
private:
|
|
|
|
typedef struct tagData
|
|
{
|
|
std::vector<std::vector<CDnActor::PreStateStruct>> VecPreActionState;
|
|
std::vector<std::vector<CDnActor::PreStateStruct>> VecPreActionCustomState;
|
|
std::vector<std::vector<CDnActor::PreStateStruct>> VecPreCanMoveState;
|
|
}SData;
|
|
|
|
CSyncLock m_Lock;
|
|
std::map<std::string,SData> m_mRepository;
|
|
};
|