[FIX] Damage Queue

Helia01 · 18 Eyl 2021

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.

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