[FIX] Damage Queue

Tengrist · 22 Eyl 2022

Hey turkmmo!

You summon a lot of monsters, they attack your character and then you kill or purge monsters, but the damage still continues to be shown visually. Is this a familiar situation?
In addition, the damage is shown visually even after the death of the character... I love this game.

Ekli dosyayı görüntüle 61615 Ekli dosyayı görüntüle 61616

I haven't seen a fix for this problem, let's try to fix this sh..

C++:

// game/src/packet.h -> search this:
typedef struct packet_damage_info
{
    BYTE header;
    DWORD dwVID;
    BYTE flag;
    int damage;
} TPacketGCDamageInfo;

// replace with this:
typedef struct packet_damage_info
{
    BYTE header;
    DWORD dwVictimVID;
    DWORD dwAttackerVID;
    BYTE flag;
    int damage;
} TPacketGCDamageInfo;
 

// game/src/char_battle.cpp
//In function void CHARACTER::SendDamagePacket search this:
damageInfo.dwVID = (DWORD)GetVID();

// replace with this:
damageInfo.dwVictimVID = (DWORD)GetVID();
damageInfo.dwAttackerVID = (DWORD)pAttacker->GetVID();


//In function void CHARACTER::Dead(LPCHARACTER pkKiller, bool bImmediateDead) search this:
if (IsRevive() == false && HasReviverInParty() == true)
{
  m_pkDeadEvent = event_create(dead_event, pEventInfo, bImmediateDead ? 1 : PASSES_PER_SEC(3));
}
else
{
  m_pkDeadEvent = event_create(dead_event, pEventInfo, bImmediateDead ? 1 : PASSES_PER_SEC(10));
}

// replace with this:
m_pkDeadEvent = event_create(dead_event, pEventInfo, bImmediateDead ? 1 : PASSES_PER_SEC(1));

C++:

// UserInterface/Packet.h -> search this:
typedef struct packet_damage_info
{
    BYTE header;
    DWORD dwVID;
    BYTE flag;
    int  damage;
} TPacketGCDamageInfo;

// replace with this:
typedef struct packet_damage_info
{
    BYTE header;
    DWORD dwVictimVID;
    DWORD dwAttackerVID;
    BYTE flag;
    int  damage;
} TPacketGCDamageInfo;
 

// UserInterface/InstanceBase.cpp -> search this:
ProcessDamage();

// replace with this:
ProcessRemoveOldDamage();
ProcessDamage();
 

// UserInterface/InstanceBase.h -> search this:
        struct SEffectDamage
        {
            DWORD    damage;
            BYTE    flag;
            BOOL    bSelf;
            BOOL    bTarget;
        };

        typedef std::list<SEffectDamage> CommandDamageQueue;
        CommandDamageQueue m_DamageQueue;

        void ProcessDamage();

    public:
        void AddDamageEffect(DWORD damage, BYTE flag, BOOL bSelf, BOOL bTarget);



//replace
        struct SEffectDamage
        {
            DWORD    damage;
            BYTE    flag;
            BOOL    bSelf;
            BOOL    bTarget;
            DWORD    dwVictimVID;
            DWORD    dwAttackerVID;
        };

        typedef std::list<SEffectDamage> CommandDamageQueue;
        CommandDamageQueue m_DamageQueue;

        void ProcessDamage();
        void ProcessRemoveOldDamage();

    public:
        void AddDamageEffect(DWORD damage, BYTE flag, BOOL bSelf, BOOL bTarget, DWORD dwVictimVID, DWORD dwAttackerVID);
 


 

 

// UserInterface/InstanceBaseEffect.cpp -> add this to include:

#include "PythonPlayer.h" // this is default added so check it

#include "PythonApplication.h"
#include "PythonCharacterManager.h"
 


 

// UserInterface/InstanceBaseEffect.cpp -> search this:
void CInstanceBase::AddDamageEffect(DWORD damage,BYTE flag,BOOL bSelf,BOOL bTarget)
{
    if(CPythonSystem::Instance().IsShowDamage())
    {     
        SEffectDamage sDamage;
        sDamage.bSelf = bSelf;
        sDamage.bTarget = bTarget;
        sDamage.damage = damage;
        sDamage.flag = flag;
        m_DamageQueue.push_back(sDamage);
    }
}

// replace with this:
void CInstanceBase::AddDamageEffect(DWORD damage,BYTE flag,BOOL bSelf,BOOL bTarget, DWORD dwVictimVID, DWORD dwAttackerVID)
{
    if (CPythonSystem::Instance().IsShowDamage() && !CPythonApplication::Instance().IsMinimizedWnd())
    {     
        SEffectDamage sDamage;
        sDamage.bSelf = bSelf;
        sDamage.bTarget = bTarget;
        sDamage.damage = damage;
        sDamage.flag = flag;
        sDamage.dwVictimVID = dwVictimVID;
        sDamage.dwAttackerVID = dwAttackerVID;
        m_DamageQueue.push_back(sDamage);
    }
}


 
// UserInterface/InstanceBaseEffect.cpp

//add this under void CInstanceBase::ProcessDamage() function
void CInstanceBase::ProcessRemoveOldDamage()
{
    if (m_DamageQueue.empty())
        return;

    m_DamageQueue.remove_if([](CInstanceBase::SEffectDamage sed){ return ((CPythonCharacterManager::instance().IsDeadVID(sed.dwAttackerVID) || CPythonPlayer::Instance().NEW_GetMainActorPtr()->IsDead()) && (sed.flag != DAMAGE_POISON || sed.flag != DAMAGE_BLEEDING || sed.flag != DAMAGE_FIRE) && sed.bSelf); });
}
 

// UserInterface/PythonNetworkStreamPhaseGame.cpp -> search this:
bool CPythonNetworkStream::RecvDamageInfoPacket()
{
    TPacketGCDamageInfo DamageInfoPacket;

    if (!Recv(sizeof(TPacketGCDamageInfo), &DamageInfoPacket))
    {
        Tracen("Recv Target Packet Error");
        return false;
    }
  
    CInstanceBase * pInstTarget = CPythonCharacterManager::Instance().GetInstancePtr(DamageInfoPacket.dwVID);
    bool bSelf = (pInstTarget == CPythonCharacterManager::Instance().GetMainInstancePtr());
    bool bTarget = (pInstTarget==m_pInstTarget);
    if (pInstTarget)
    {
        if(DamageInfoPacket.damage >= 0)
            pInstTarget->AddDamageEffect(DamageInfoPacket.damage,DamageInfoPacket.flag,bSelf,bTarget);
        else
            TraceError("Damage is equal or below 0.");
    }

    return true;
}


// replace with this:
bool CPythonNetworkStream::RecvDamageInfoPacket()
{
    TPacketGCDamageInfo DamageInfoPacket;

    if (!Recv(sizeof(TPacketGCDamageInfo), &DamageInfoPacket))
    {
        Tracen("Recv Target Packet Error");
        return false;
    }
  
    CInstanceBase * pInstTarget = CPythonCharacterManager::Instance().GetInstancePtr(DamageInfoPacket.dwVictimVID);
    bool bSelf = (pInstTarget == CPythonCharacterManager::Instance().GetMainInstancePtr());
    bool bTarget = (pInstTarget==m_pInstTarget);
    if (pInstTarget)
    {
        if(DamageInfoPacket.damage >= 0)
            pInstTarget->AddDamageEffect(DamageInfoPacket.damage, DamageInfoPacket.flag, bSelf, bTarget, DamageInfoPacket.dwVictimVID, DamageInfoPacket.dwAttackerVID);
        else
            TraceError("Damage is equal or below 0.");
    }

    return true;
}
 


 

// UserInterface/PythonApplication.h -> search this:
void RenderGame();

// replace with this:
void RenderGame();
bool IsMinimizedWnd();


 

// UserInterface/PythonApplication.cpp -> search this:
void CPythonApplication::SkipRenderBuffering(DWORD dwSleepMSec)
{
    m_dwBufSleepSkipTime=ELTimer_GetMSec()+dwSleepMSec;
}
 

// replace with this:
void CPythonApplication::SkipRenderBuffering(DWORD dwSleepMSec)
{
    m_dwBufSleepSkipTime=ELTimer_GetMSec()+dwSleepMSec;
}

bool CPythonApplication::IsMinimizedWnd()
{
    return m_isMinimizedWnd;
}

I'm not saying that this is an ideal solution. If you have any ideas, please write comments.

Best regards, Masha

thanks for sharing have you tried this solution in an active server?