jann/m2dev-client-src
1
0
Fork 0
forked from metin-server/m2dev-client-src
Code Pull Requests Activity

MRMJ-1: Messenger & Skills fixes

Browse Source
This commit is contained in:
Mind Rapist
2025-12-14 06:39:06 +02:00
parent 08ed73b29c
commit e3ae5541ba
15 changed files with 6 additions and 352 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
src/GameLib/ActorInstance.h
View File

@@ -362,22 +362,10 @@ class CActorInstance : public IActorInstance, public IFlyTargetableObject
BOOL IsActEmotion(); BOOL IsActEmotion();
DWORD GetComboIndex(); DWORD GetComboIndex();
float GetAttackingElapsedTime(); float GetAttackingElapsedTime();
#ifdef FIX_POS_SYNC
void SetBlendingPosition(const TPixelPosition& c_rPosition, float fBlendingTime = 1.0f);
#else
void SetBlendingPosition(const TPixelPosition & c_rPosition, float fBlendingTime = 1.0f); void SetBlendingPosition(const TPixelPosition & c_rPosition, float fBlendingTime = 1.0f);
#endif
void ResetBlendingPosition(); void ResetBlendingPosition();
void GetBlendingPosition(TPixelPosition * pPosition); void GetBlendingPosition(TPixelPosition * pPosition);
#ifdef FIX_POS_SYNC
struct BlendingPosition {
D3DXVECTOR3 source;
D3DXVECTOR3 dest;
float duration;
};
#endif
BOOL NormalAttack(float fDirRot, float fBlendTime = 0.1f); BOOL NormalAttack(float fDirRot, float fBlendTime = 0.1f);
BOOL ComboAttack(DWORD wMotionIndex, float fDirRot, float fBlendTime = 0.1f); BOOL ComboAttack(DWORD wMotionIndex, float fDirRot, float fBlendTime = 0.1f);
@@ -491,13 +479,6 @@ class CActorInstance : public IActorInstance, public IFlyTargetableObject
void RenderCollisionData(); void RenderCollisionData();
void RenderToShadowMap(); void RenderToShadowMap();
#ifdef FIX_POS_SYNC
void ClientAttack(DWORD dwVID);
void ServerAttack(DWORD dwVID);
bool ProcessingClientAttack(DWORD dwVID);
bool ServerAttackCameFirst(DWORD dwVID);
#endif
protected: protected:
void __AdjustCollisionMovement(const CGraphicObjectInstance * c_pGraphicObjectInstance); void __AdjustCollisionMovement(const CGraphicObjectInstance * c_pGraphicObjectInstance);
@@ -624,10 +605,6 @@ class CActorInstance : public IActorInstance, public IFlyTargetableObject
void __ClearCombo(); void __ClearCombo();
void __OnEndCombo(); void __OnEndCombo();
#ifdef FIX_POS_SYNC
void __Push(const TPixelPosition& c_rkPPosDst, unsigned int unDuration);
#endif
void __ProcessDataAttackSuccess(const NRaceData::TAttackData & c_rAttackData, CActorInstance & rVictim, const D3DXVECTOR3 & c_rv3Position, UINT uiSkill = 0, BOOL isSendPacket = TRUE); void __ProcessDataAttackSuccess(const NRaceData::TAttackData & c_rAttackData, CActorInstance & rVictim, const D3DXVECTOR3 & c_rv3Position, UINT uiSkill = 0, BOOL isSendPacket = TRUE);
void __ProcessMotionEventAttackSuccess(DWORD dwMotionKey, BYTE byEventIndex, CActorInstance & rVictim); void __ProcessMotionEventAttackSuccess(DWORD dwMotionKey, BYTE byEventIndex, CActorInstance & rVictim);
void __ProcessMotionAttackSuccess(DWORD dwMotionKey, CActorInstance & rVictim); void __ProcessMotionAttackSuccess(DWORD dwMotionKey, CActorInstance & rVictim);
@@ -635,11 +612,7 @@ class CActorInstance : public IActorInstance, public IFlyTargetableObject
void __HitStone(CActorInstance& rVictim); void __HitStone(CActorInstance& rVictim);
void __HitGood(CActorInstance& rVictim); void __HitGood(CActorInstance& rVictim);
#ifdef FIX_POS_SYNC
void __HitGreate(CActorInstance& rVictim, UINT uiSkill);
#else
void __HitGreate(CActorInstance& rVictim); void __HitGreate(CActorInstance& rVictim);
#endif
void __PushDirect(CActorInstance & rVictim); void __PushDirect(CActorInstance & rVictim);
void __PushCircle(CActorInstance & rVictim); void __PushCircle(CActorInstance & rVictim);

119
src/GameLib/ActorInstanceBattle.cpp
View File

@@ -314,76 +314,6 @@ void CActorInstance::__ClearCombo()
m_pkCurRaceMotionData = NULL; m_pkCurRaceMotionData = NULL;
} }
#ifdef FIX_POS_SYNC
void CActorInstance::__Push(const TPixelPosition& c_rkPPosDst, unsigned int unDuration)
{
DWORD dwVID = GetVirtualID();
Tracenf("VID %d SyncPixelPosition %f %f", dwVID, c_rkPPosDst.x, c_rkPPosDst.y);
if (unDuration == 0)
unDuration = 1000;
const D3DXVECTOR3& c_rv3Src = GetPosition();
const D3DXVECTOR3 c_v3Delta = c_rkPPosDst - c_rv3Src;
SetBlendingPosition(c_rkPPostDst, float(unDuration) / 1000);
if (!IsUsingSkill() && !IsResistFallen())
{
int len = sqrt(c_v3Delta.x * c_v3Delta.x + c_v3Delta.y * c_v3Delta.y);
if (len > 150.0f)
{
InterceptOnceMotion(CRaceMotionData::NAME_DAMAGE_FLYING);
PushOnceMotion(CRaceMotionData::NAME_STAND_UP);
}
}
}
void CActorInstance::ClientAttack(DWORD dwVID)
{
if (m_mapAttackSync.find(dwVID) == m_mapAttackSync.end()) {
m_mapAttackSync.insert(std::make_pair(dwVID, -1));
}
else
{
if (m_mapAttackSync[dwVID] == 1)
{
m_mapAttackSync.erase(dwVID);
return;
}
m_mapAttackSync[dwVID]--;
}
}
// server attack increases
void CActorInstance::ServerAttack(DWORD dwVID)
{
if (m_mapAttackSync.find(dwVID) == m_mapAttackSync.end()) {
m_mapAttackSync.insert(std::make_pair(dwVID, 1));
}
else
{
if (m_mapAttackSync[dwVID] == -1)
{
m_mapAttackSync.erase(dwVID);
return;
}
m_mapAttackSync[dwVID]++;
}
}
bool CActorInstance::ProcessingClientAttack(DWORD dwVID)
{
return m_mapAttackSync.find(dwVID) != m_mapAttackSync.end() && m_mapAttackSync[dwVID] < 0;
}
//
bool CActorInstance::ServerAttackCameFirst(DWORD dwVID)
{
return m_mapAttackSync.find(dwVID) != m_mapAttackSync.end() && m_mapAttackSync[dwVID] > 0;
}
#endif
//////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CActorInstance::isAttacking() BOOL CActorInstance::isAttacking()
@@ -680,33 +610,14 @@ void CActorInstance::__ProcessDataAttackSuccess(const NRaceData::TAttackData & c
InsertDelay(c_rAttackData.fStiffenTime); InsertDelay(c_rAttackData.fStiffenTime);
#ifdef FIX_POS_SYNC
BlendingPosition sBlending;
memset(&sBlending, 0, sizeof(sBlending));
sBlending.source = rVictim.NEW_GetCurPixelPositionRef();
#endif
if (__CanPushDestActor(rVictim) && c_rAttackData.fExternalForce > 0.0f) if (__CanPushDestActor(rVictim) && c_rAttackData.fExternalForce > 0.0f)
{ {
#ifdef FIX_POS_SYNC __PushCircle(rVictim);
const bool bServerAttackAlreadyCame = rVictim.ServerAttackCameFirst(GetVirtualID());
rVictim.ClientAttack(GetVirtualID());
if (!bServerAttackAlreadyCame) // VICTIM_COLLISION_TEST
{ const D3DXVECTOR3& kVictimPos = rVictim.GetPosition();
#endif rVictim.m_PhysicsObject.IncreaseExternalForce(kVictimPos, c_rAttackData.fExternalForce); //*nForceRatio/100.0f);
__PushCircle(rVictim); // VICTIM_COLLISION_TEST_END
// VICTIM_COLLISION_TEST
const D3DXVECTOR3& kVictimPos = rVictim.GetPosition();
rVictim.m_PhysicsObject.IncreaseExternalForce(kVictimPos, c_rAttackData.fExternalForce); //*nForceRatio/100.0f);
// VICTIM_COLLISION_TEST_END
#ifdef FIX_POS_SYNC
rVictim.GetBlendingPosition(&(sBlending.dest));
sBlending.duration = rVictim.m_PhysicsObject.GetRemainingTime();
}
#endif
} }
// Invisible Time // Invisible Time
@@ -778,11 +689,7 @@ void CActorInstance::__ProcessDataAttackSuccess(const NRaceData::TAttackData & c
} }
else if (NRaceData::HIT_TYPE_GREAT == c_rAttackData.iHittingType) else if (NRaceData::HIT_TYPE_GREAT == c_rAttackData.iHittingType)
{ {
#ifdef FIX_POS_SYNC
__HitGreate(rVictim, uiSkill);
#else
__HitGreate(rVictim); __HitGreate(rVictim);
#endif
} }
else else
{ {
@@ -912,18 +819,10 @@ void CActorInstance::__HitGood(CActorInstance& rVictim)
} }
} }
#ifdef FIX_POS_SYNC
void CActorInstance::__HitGreate(CActorInstance& rVictim, UINT uiSkill)
#else
void CActorInstance::__HitGreate(CActorInstance& rVictim) void CActorInstance::__HitGreate(CActorInstance& rVictim)
#endif
{ {
// DISABLE_KNOCKDOWN_ATTACK // DISABLE_KNOCKDOWN_ATTACK
#ifdef FIX_POS_SYNC
if (!uiSkill && rVictim.IsKnockDown())
#else
if (rVictim.IsKnockDown()) if (rVictim.IsKnockDown())
#endif
return; return;
if (rVictim.__IsStandUpMotion()) if (rVictim.__IsStandUpMotion())
return; return;
@@ -1007,24 +906,16 @@ void CActorInstance::GetBlendingPosition(TPixelPosition * pPosition)
{ {
if (m_PhysicsObject.isBlending()) if (m_PhysicsObject.isBlending())
{ {
#ifdef FIX_POS_SYNC
m_PhysicsObject.GetFinalPosition(pPosition);
#else
m_PhysicsObject.GetLastPosition(pPosition); m_PhysicsObject.GetLastPosition(pPosition);
pPosition->x += m_x; pPosition->x += m_x;
pPosition->y += m_y; pPosition->y += m_y;
pPosition->z += m_z; pPosition->z += m_z;
#endif
} }
else else
{ {
#ifdef FIX_POS_SYNC
GetPixelPosition(pPosition);
#else
pPosition->x = m_x; pPosition->x = m_x;
pPosition->y = m_y; pPosition->y = m_y;
pPosition->z = m_z; pPosition->z = m_z;
#endif
} }
} }

27
src/GameLib/PhysicsObject.cpp
View File

@@ -107,32 +107,6 @@ void CPhysicsObject::IncreaseExternalForce(const D3DXVECTOR3 & c_rvBasePosition,
} }
} }
#ifdef FIX_POS_SYNC
void CPhysicsObject::SetLastPosition(const TPixelPosition& c_rPosition, const TPixelPosition& c_rDeltaPosition, float fBlendingTime)
{
m_v3FinalPosition.x = float(c_rPosition.x + c_rDeltaPosition.x);
m_v3FinalPosition.y = float(c_rPosition.y + c_rDeltaPosition.y);
m_v3FinalPosition.z = float(c_rPosition.z + c_rDeltaPosition.z);
m_v3DeltaPosition.x = float(c_rDeltaPosition.x);
m_v3DeltaPosition.y = float(c_rDeltaPosition.y);
m_v3DeltaPosition.z = float(c_rDeltaPosition.z);
m_xPushingPosition.Setup(0.0f, c_rDeltaPosition.x, fBlendingTime);
m_yPushingPosition.Setup(0.0f, c_rDeltaPosition.y, fBlendingTime);
}
void CPhysicsObject::GetFinalPosition(TPixelPosition* pPosition)
{
pPosition->x = (m_v3FinalPosition.x);
pPosition->y = (m_v3FinalPosition.y);
pPosition->z = (m_v3FinalPosition.z);
}
void CPhysicsObject::GetDeltaPosition(TPixelPosition* pPosition)
{
pPosition->x = (m_v3DeltaPosition.x);
pPosition->y = (m_v3DeltaPosition.y);
pPosition->z = (m_v3DeltaPosition.z);
}
#else
void CPhysicsObject::SetLastPosition(const TPixelPosition & c_rPosition, float fBlendingTime) void CPhysicsObject::SetLastPosition(const TPixelPosition & c_rPosition, float fBlendingTime)
{ {
m_v3LastPosition.x = float(c_rPosition.x); m_v3LastPosition.x = float(c_rPosition.x);
@@ -141,7 +115,6 @@ void CPhysicsObject::SetLastPosition(const TPixelPosition & c_rPosition, float f
m_xPushingPosition.Setup(0.0f, c_rPosition.x, fBlendingTime); m_xPushingPosition.Setup(0.0f, c_rPosition.x, fBlendingTime);
m_yPushingPosition.Setup(0.0f, c_rPosition.y, fBlendingTime); m_yPushingPosition.Setup(0.0f, c_rPosition.y, fBlendingTime);
} }
#endif
void CPhysicsObject::GetLastPosition(TPixelPosition * pPosition) void CPhysicsObject::GetLastPosition(TPixelPosition * pPosition)
{ {

11
src/GameLib/PhysicsObject.h
View File

@@ -71,13 +71,7 @@ class CPhysicsObject
void SetDirection(const D3DXVECTOR3 & c_rv3Direction); void SetDirection(const D3DXVECTOR3 & c_rv3Direction);
void IncreaseExternalForce(const D3DXVECTOR3 & c_rvBasePosition, float fForce); void IncreaseExternalForce(const D3DXVECTOR3 & c_rvBasePosition, float fForce);
#ifdef FIX_POS_SYNC
void SetLastPosition(const TPixelPosition& c_rPosition, const TPixelPosition& c_rDeltaPosition, float fBlendingTime);
void GetFinalPosition(TPixelPosition* pPosition);
void GetDeltaPosition(TPixelPosition* pPosition);
#else
void SetLastPosition(const TPixelPosition& c_rPosition, float fBlendingTime); void SetLastPosition(const TPixelPosition& c_rPosition, float fBlendingTime);
#endif
void GetLastPosition(TPixelPosition * pPosition); void GetLastPosition(TPixelPosition * pPosition);
float GetXMovement(); float GetXMovement();
@@ -98,10 +92,7 @@ class CPhysicsObject
D3DXVECTOR3 m_v3Velocity; D3DXVECTOR3 m_v3Velocity;
D3DXVECTOR3 m_v3LastPosition; D3DXVECTOR3 m_v3LastPosition;
#ifdef FIX_POS_SYNC
D3DXVECTOR3 m_v3FinalPosition;
D3DXVECTOR3 m_v3DeltaPosition;
#endif
CEaseOutInterpolation m_xPushingPosition; CEaseOutInterpolation m_xPushingPosition;
CEaseOutInterpolation m_yPushingPosition; CEaseOutInterpolation m_yPushingPosition;

8
src/UserInterface/InstanceBase.cpp
View File

@@ -1560,11 +1560,7 @@ void CInstanceBase::StateProcess()
SetAdvancingRotation(fRotDst); SetAdvancingRotation(fRotDst);
SetRotation(fRotDst); SetRotation(fRotDst);
#ifdef FIX_POS_SYNC
NEW_UseSkill(1, eFunc& FUNC_SKILL - 1, uArg & 0x0f, (uArg >> 4) ? true : false);
#else
NEW_UseSkill(0, eFunc & 0x7f, uArg&0x0f, (uArg>>4) ? true : false); NEW_UseSkill(0, eFunc & 0x7f, uArg&0x0f, (uArg>>4) ? true : false);
#endif
//Tracen("가깝기 때문에 워프 공격"); //Tracen("가깝기 때문에 워프 공격");
} }
} }
@@ -1742,11 +1738,7 @@ void CInstanceBase::MovementProcess()
{ {
SetAdvancingRotation(m_fDstRot); SetAdvancingRotation(m_fDstRot);
BlendRotation(m_fDstRot); BlendRotation(m_fDstRot);
#ifdef FIX_POS_SYNC
NEW_UseSkill(1, m_kMovAfterFunc.eFunc& FUNC_SKILL - 1, m_kMovAfterFunc.uArg & 0x0f, (m_kMovAfterFunc.uArg >> 4) ? true : false);
#else
NEW_UseSkill(0, m_kMovAfterFunc.eFunc & 0x7f, m_kMovAfterFunc.uArg&0x0f, (m_kMovAfterFunc.uArg>>4) ? true : false); NEW_UseSkill(0, m_kMovAfterFunc.eFunc & 0x7f, m_kMovAfterFunc.uArg&0x0f, (m_kMovAfterFunc.uArg>>4) ? true : false);
#endif
} }
else else
{ {

5
src/UserInterface/InstanceBase.h
View File

@@ -633,11 +633,6 @@ class CInstanceBase
bool NEW_AttackToDestInstanceDirection(CInstanceBase& rkInstDst, IFlyEventHandler* pkFlyHandler); bool NEW_AttackToDestInstanceDirection(CInstanceBase& rkInstDst, IFlyEventHandler* pkFlyHandler);
bool NEW_AttackToDestInstanceDirection(CInstanceBase& rkInstDst); bool NEW_AttackToDestInstanceDirection(CInstanceBase& rkInstDst);
#ifdef FIX_POS_SYNC
void ServerAttack(DWORD dwVID);
bool ProcessingClientAttack(DWORD dwVID);
#endif
bool NEW_MoveToDestPixelPositionDirection(const TPixelPosition& c_rkPPosDst); bool NEW_MoveToDestPixelPositionDirection(const TPixelPosition& c_rkPPosDst);
void NEW_MoveToDestInstanceDirection(CInstanceBase& rkInstDst); void NEW_MoveToDestInstanceDirection(CInstanceBase& rkInstDst);
void NEW_MoveToDirection(float fDirRot); void NEW_MoveToDirection(float fDirRot);

12
src/UserInterface/InstanceBaseBattle.cpp
View File

@@ -410,18 +410,6 @@ bool CInstanceBase::NEW_AttackToDestInstanceDirection(CInstanceBase& rkInstDst)
return true; return true;
} }
#ifdef FIX_POS_SYNC
void CInstanceBase::ServerAttack(DWORD dwVID)
{
m_GraphicThingInstance.ServerAttack(dwVID);
}
bool CInstanceBase::ProcessingClientAttack(DWORD dwVID)
{
return m_GraphicThingInstance.ProcessingClientAttack(dwVID);
}
#endif
void CInstanceBase::AttackProcess() void CInstanceBase::AttackProcess()
{ {
if (!m_GraphicThingInstance.CanCheckAttacking()) if (!m_GraphicThingInstance.CanCheckAttacking())

1
src/UserInterface/Locale_inc.h
View File

@@ -13,7 +13,6 @@
#define FIX_SEQ_254 #define FIX_SEQ_254
#define CHAR_SELECT_STATS_IMPROVEMENT // Improve stats values in character select screen #define CHAR_SELECT_STATS_IMPROVEMENT // Improve stats values in character select screen
#define __ENABLE_STEALTH_FIX__ #define __ENABLE_STEALTH_FIX__
//#define FIX_POS_SYNC
// Python-only // Python-only
#define FIX_HORSE_SKILLS_TAB #define FIX_HORSE_SKILLS_TAB

35
src/UserInterface/NetworkActorManager.cpp
View File

@@ -536,41 +536,6 @@ void CNetworkActorManager::MoveActor(const SNetworkMoveActorData& c_rkNetMoveAct
rkNetActorData.m_fRot=c_rkNetMoveActorData.m_fRot; rkNetActorData.m_fRot=c_rkNetMoveActorData.m_fRot;
} }
#ifdef FIX_POS_SYNC
void CNetworkActorManager::AttackActor(DWORD dwVID, DWORD dwAttacakerVID, LONG lDestPosX, LONG lDestPosY, const TPixelPosition& k_pSyncPos, DWORD dwBlendDuration)
{
std::map<DWORD, SNetworkActorData>::iterator f = m_kNetActorDict.find(dwVID);
if (m_kNetActorDict.end() == f)
{
return;
}
SNetworkActorData& rkNetActorData = f->second;
if (k_pSyncPos.x && k_pSyncPos.y) {
CInstanceBase* pkInstFind = __FindActor(rkNetActorData);
if (pkInstFind)
{
const bool bProcessingClientAttack = pkInstFind->ProcessingClientAttack(dwAttacakerVID);
pkInstFind->ServerAttack(dwAttacakerVID);
// if already blending, update
if (bProcessingClientAttack && pkInstFind->IsPushing() && pkInstFind->GetBlendingRemainTime() > 0.15) {
pkInstFind->SetBlendingPosition(k_pSyncPos, pkInstFind->GetBlendingRemainTime());
}
else {
// otherwise sync
//pkInstFind->SCRIPT_SetPixelPosition(k_pSyncPos.x, k_pSyncPos.y);
pkInstFind->NEW_SyncPixelPosition(k_pSyncPos, dwBlendDuration);
}
}
rkNetActorData.SetPosition(long(k_pSyncPos.x), long(k_pSyncPos.y));
}
}
#endif
void CNetworkActorManager::SyncActor(DWORD dwVID, LONG lPosX, LONG lPosY) void CNetworkActorManager::SyncActor(DWORD dwVID, LONG lPosX, LONG lPosY)
{ {
std::map<DWORD, SNetworkActorData>::iterator f=m_kNetActorDict.find(dwVID); std::map<DWORD, SNetworkActorData>::iterator f=m_kNetActorDict.find(dwVID);

4
src/UserInterface/NetworkActorManager.h
View File

@@ -127,10 +127,6 @@ class CNetworkActorManager : public CReferenceObject
void UpdateActor(const SNetworkUpdateActorData& c_rkNetUpdateActorData); void UpdateActor(const SNetworkUpdateActorData& c_rkNetUpdateActorData);
void MoveActor(const SNetworkMoveActorData& c_rkNetMoveActorData); void MoveActor(const SNetworkMoveActorData& c_rkNetMoveActorData);
#ifdef FIX_POS_SYNC
void AttackActor(DWORD dwVID, DWORD dwAttacakerVID, LONG lDestPosX, LONG lDestPosY, const TPixelPosition& k_pSyncPos, DWORD dwBlendDuration);
#endif
void SyncActor(DWORD dwVID, LONG lPosX, LONG lPosY); void SyncActor(DWORD dwVID, LONG lPosX, LONG lPosY);
void SetActorOwner(DWORD dwOwnerVID, DWORD dwVictimVID); void SetActorOwner(DWORD dwOwnerVID, DWORD dwVictimVID);

22
src/UserInterface/Packet.h
View File

@@ -516,18 +516,6 @@ typedef struct command_attack
uint32_t dwVictimVID; // 적 VID uint32_t dwVictimVID; // 적 VID
uint8_t bCRCMagicCubeProcPiece; uint8_t bCRCMagicCubeProcPiece;
uint8_t bCRCMagicCubeFilePiece; uint8_t bCRCMagicCubeFilePiece;
#ifdef FIX_POS_SYNC
BOOL bPacket;
LONG lSX;
LONG lSY;
LONG lX;
LONG lY;
float fSyncDestX;
float fSyncDestY;
DWORD dwBlendDuration;
DWORD dwComboMotion;
DWORD dwTime;
#endif
} TPacketCGAttack; } TPacketCGAttack;
typedef struct command_chat typedef struct command_chat
@@ -1882,16 +1870,6 @@ typedef struct packet_attack
uint32_t dwVID; uint32_t dwVID;
uint32_t dwVictimVID; // 적 VID uint32_t dwVictimVID; // 적 VID
uint8_t bType; // 공격 유형 uint8_t bType; // 공격 유형
#ifdef FIX_POS_SYNC
BOOL bPacket;
LONG lSX;
LONG lSY;
LONG lX;
LONG lY;
float fSyncDestX;
float fSyncDestY;
DWORD dwBlendDuration;
#endif
} TPacketGCAttack; } TPacketGCAttack;
typedef struct packet_c2c typedef struct packet_c2c

11
src/UserInterface/PythonNetworkStream.h
View File

@@ -8,10 +8,6 @@
#include "packet.h" #include "packet.h"
#ifdef FIX_POS_SYNC
#include <GameLib/ActorInstance.h>
#endif
class CInstanceBase; class CInstanceBase;
class CNetworkActorManager; class CNetworkActorManager;
struct SNetworkActorData; struct SNetworkActorData;
@@ -140,11 +136,7 @@ class CPythonNetworkStream : public CNetworkStream, public CSingleton<CPythonNet
bool SendSyncPositionElementPacket(DWORD dwVictimVID, DWORD dwVictimX, DWORD dwVictimY); bool SendSyncPositionElementPacket(DWORD dwVictimVID, DWORD dwVictimX, DWORD dwVictimY);
#ifdef FIX_POS_SYNC
bool SendAttackPacket(UINT uMotAttack, DWORD dwVIDVictim, BOOL bPacket, CActorInstance::BlendingPosition& sBlending);
#else
bool SendAttackPacket(UINT uMotAttack, DWORD dwVIDVictim); bool SendAttackPacket(UINT uMotAttack, DWORD dwVIDVictim);
#endif
bool SendCharacterStatePacket(const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg); bool SendCharacterStatePacket(const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg);
bool SendUseSkillPacket(DWORD dwSkillIndex, DWORD dwTargetVID=0); bool SendUseSkillPacket(DWORD dwSkillIndex, DWORD dwTargetVID=0);
bool SendTargetPacket(DWORD dwVID); bool SendTargetPacket(DWORD dwVID);
@@ -486,9 +478,6 @@ class CPythonNetworkStream : public CNetworkStream, public CSingleton<CPythonNet
bool RecvTargetPacket(); bool RecvTargetPacket();
bool RecvViewEquipPacket(); bool RecvViewEquipPacket();
bool RecvDamageInfoPacket(); bool RecvDamageInfoPacket();
#ifdef FIX_POS_SYNC
bool RecvCharacterAttackPacket();
#endif
// Mount // Mount
bool RecvMountPacket(); bool RecvMountPacket();

52
src/UserInterface/PythonNetworkStreamPhaseGame.cpp
View File

@@ -2429,30 +2429,6 @@ bool CPythonNetworkStream::RecvDamageInfoPacket()
return true; return true;
} }
#ifdef FIX_POS_SYNC
bool CPythonNetworkStream::RecvCharacterAttackPacket()
{
TPacketGCAttack kPacket;
if (!Recv(sizeof(TPacketGCAttack), &kPacket))
{
Tracen("CPythonNetworkStream::RecvCharacterAttackPacket - PACKET READ ERROR");
return false;
}
if (kPacket.lX && kPacket.lY) {
__GlobalPositionToLocalPosition(kPacket.lX, kPacket.lY);
}
__GlobalPositionToLocalPosition(kPacket.lSX, kPacket.lSY);
TPixelPosition tSyncPosition = TPixelPosition{ kPacket.fSyncDestX, kPacket.fSyncDestY, 0 };
m_rokNetActorMgr->AttackActor(kPacket.dwVID, kPacket.dwVictimVID, kPacket.lX, kPacket.lY, tSyncPosition, kPacket.dwBlendDuration);
return true;
}
#endif
bool CPythonNetworkStream::RecvTargetPacket() bool CPythonNetworkStream::RecvTargetPacket()
{ {
TPacketGCTarget TargetPacket; TPacketGCTarget TargetPacket;
@@ -2544,20 +2520,11 @@ bool CPythonNetworkStream::RecvChangeSpeedPacket()
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
// Recv // Recv
#ifdef FIX_POS_SYNC
bool CPythonNetworkStream::SendAttackPacket(UINT uMotAttack, DWORD dwVIDVictim, BOOL bPacket, CActorInstance::BlendingPosition& sBlending)
#else
bool CPythonNetworkStream::SendAttackPacket(UINT uMotAttack, DWORD dwVIDVictim) bool CPythonNetworkStream::SendAttackPacket(UINT uMotAttack, DWORD dwVIDVictim)
#endif
{ {
if (!__CanActMainInstance()) if (!__CanActMainInstance())
return true; return true;
#ifdef FIX_POS_SYNC
CPythonCharacterManager& rkChrMgr = CPythonCharacterManager::Instance();
CInstanceBase* pkInstMain = rkChrMgr.GetMainInstancePtr();
#endif
#ifdef ATTACK_TIME_LOG #ifdef ATTACK_TIME_LOG
static DWORD prevTime = timeGetTime(); static DWORD prevTime = timeGetTime();
DWORD curTime = timeGetTime(); DWORD curTime = timeGetTime();
@@ -2570,25 +2537,6 @@ bool CPythonNetworkStream::SendAttackPacket(UINT uMotAttack, DWORD dwVIDVictim)
kPacketAtk.header = HEADER_CG_ATTACK; kPacketAtk.header = HEADER_CG_ATTACK;
kPacketAtk.bType = uMotAttack; kPacketAtk.bType = uMotAttack;
kPacketAtk.dwVictimVID = dwVIDVictim; kPacketAtk.dwVictimVID = dwVIDVictim;
#ifdef FIX_POS_SYNC
kPacketAtk.bPacket = bPacket;
kPacketAtk.lX = (long)sBlending.dest.x;
kPacketAtk.lY = (long)sBlending.dest.y;
kPacketAtk.lSX = (long)sBlending.source.x;
kPacketAtk.lSY = (long)sBlending.source.y;
kPacketAtk.fSyncDestX = sBlending.dest.x;
// sources and dest are normalized with both coordinates positive
// since fSync are ment to be broadcasted to other clients, the Y has to preserve the negative coord
kPacketAtk.fSyncDestY = -sBlending.dest.y;
kPacketAtk.dwBlendDuration = (unsigned int)(sBlending.duration * 1000);
kPacketAtk.dwComboMotion = pkInstMain->GetComboMotion();
kPacketAtk.dwTime = ELTimer_GetServerMSec();
if (kPacketAtk.lX && kPacketAtk.lY)
__LocalPositionToGlobalPosition(kPacketAtk.lX, kPacketAtk.lY);
__LocalPositionToGlobalPosition(kPacketAtk.lSX, kPacketAtk.lSY);
#endif
if (!SendSpecial(sizeof(kPacketAtk), &kPacketAtk)) if (!SendSpecial(sizeof(kPacketAtk), &kPacketAtk))
{ {

20
src/UserInterface/PythonPlayerEventHandler.cpp
View File

@@ -132,26 +132,10 @@ void CPythonPlayerEventHandler::OnChangeShape()
CPythonPlayer::Instance().NEW_Stop(); CPythonPlayer::Instance().NEW_Stop();
} }
#ifdef FIX_POS_SYNC
void CPythonPlayerEventHandler::OnHit(UINT uSkill, CActorInstance& rkActorVictim, BOOL isSendPacket, CActorInstance::BlendingPosition* sBlending)
#else
void CPythonPlayerEventHandler::OnHit(UINT uSkill, CActorInstance& rkActorVictim, BOOL isSendPacket) void CPythonPlayerEventHandler::OnHit(UINT uSkill, CActorInstance& rkActorVictim, BOOL isSendPacket)
#endif
{ {
DWORD dwVIDVictim=rkActorVictim.GetVirtualID(); DWORD dwVIDVictim=rkActorVictim.GetVirtualID();
#ifdef FIX_POS_SYNC
CPythonCharacterManager::Instance().AdjustCollisionWithOtherObjects(&rkActorVictim);
CActorInstance::BlendingPosition kBlendingPacket;
memset(&kBlendingPacket, 0, sizeof(kBlendingPacket));
kBlendingPacket.source = rkActorVictim.NEW_GetCurPixelPositionRef();
if (rkActorVictim.IsPushing()) {
kBlendingPacket.dest = rkActorVictim.NEW_GetLastPixelPositionRef();
kBlendingPacket.duration = sBlending->duration;
}
#endif
// Update Target // Update Target
CPythonPlayer::Instance().SetTarget(dwVIDVictim, FALSE); CPythonPlayer::Instance().SetTarget(dwVIDVictim, FALSE);
// Update Target // Update Target
@@ -181,11 +165,7 @@ void CPythonPlayerEventHandler::OnHit(UINT uSkill, CActorInstance& rkActorVictim
s_prevTimed[dwVIDVictim] = curTime; s_prevTimed[dwVIDVictim] = curTime;
#endif #endif
CPythonNetworkStream& rkStream=CPythonNetworkStream::Instance(); CPythonNetworkStream& rkStream=CPythonNetworkStream::Instance();
#ifdef FIX_POS_SYNC
rkStream.SendAttackPacket(uSkill, dwVIDVictim, isSendPacket, kBlendingPacket);
#else
rkStream.SendAttackPacket(uSkill, dwVIDVictim); rkStream.SendAttackPacket(uSkill, dwVIDVictim);
#endif
} }
if (!rkActorVictim.IsPushing()) if (!rkActorVictim.IsPushing())

4
src/UserInterface/PythonPlayerEventHandler.h
View File

@@ -27,11 +27,7 @@ class CPythonPlayerEventHandler : public CActorInstance::IEventHandler
virtual void OnUseSkill(const SState& c_rkState, UINT uMotSkill, UINT uArg); virtual void OnUseSkill(const SState& c_rkState, UINT uMotSkill, UINT uArg);
virtual void OnUpdate(); virtual void OnUpdate();
virtual void OnChangeShape(); virtual void OnChangeShape();
#ifdef FIX_POS_SYNC
virtual void OnHit(UINT uSkill, CActorInstance& rkActorVictim, BOOL isSendPacket, CActorInstance::BlendingPosition* sBlending);
#else
virtual void OnHit(UINT uSkill, CActorInstance& rkActorVictim, BOOL isSendPacket); virtual void OnHit(UINT uSkill, CActorInstance& rkActorVictim, BOOL isSendPacket);
#endif
void FlushVictimList(); void FlushVictimList();