GameServer 1.00.90

[guiguijvs]

CViewSkillState have 3 funcs =) 1 - AddEffect for itemddoption ( like cherry and haloween) , 2- to add buffeffect, and 3 - to add cashperiod effect ;)

2- to add buffeffect

[Crazzy]

void CViewSkillState::AddBuffEffect(LPOBJ lpObj, int Effect,int bOption1, int iValue1, int bOption2, int iValue2,int iLeftTime)
{
    if ( lpObj == NULL ) 
    {
        return;
    }

    if ( !OBJMAX_RANGE(lpObj->m_Index))
    {
        return;
    }

    BUFFEFFECT_ITEMDATA *  BuffEffect = this->GetBuffEffect(Effect);

    int iEffect = this->SetSkillState(lpObj,Effect,bOption1,bOption2,iValue1,iValue2,iLeftTime);

    if (iEffect == -1)
    {
        return;
    }

    if ( iEffect > 0 )
    {
        this->GCUseEffect(lpObj, iEffect, 2, BuffEffect->m_Viewport, 0, 0);
    }
    else
    {
        lpObj->m_ViewSkillCount++;
    }

    this->GCUseEffect(lpObj, iEffect, 0, BuffEffect->m_Viewport, bOption1, iLeftTime);
} 

[guiguijvs]

struct PMSG_SEND_BUFF_ICON
{
PBMSG_HEAD h;
BYTE btEffectIndex;
BYTE iEffectUseOption;
WORD wOptionType;
WORD wEffectType;
int iLeftTime;
};

void GCUseEffect(LPOBJ lpObj, BYTE btEffectIndex, BYTE iEffectUseOption, WORD wOptionType, WORD wEffectType, int iLeftTime)
{
PMSG_SEND_BUFF_ICON pMsg;

PHeadSetB((LPBYTE)&pMsg, 0x2D, sizeof(PMSG_SEND_BUFF_ICON));

pMsg.btEffectIndex = btEffectIndex;
pMsg.iEffectUseOption = iEffectUseOption;
pMsg.wOptionType = wOptionType;
pMsg.wEffectType = wEffectType;
pMsg.iLeftTime = iLeftTime;


if ( lpObj->Type == OBJ_USER )
{
DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
}

if(iEffectUseOption == 0)
{
GCStateInfoSend(lpObj, 1, btEffectIndex);
}
else
{
GCStateInfoSend(lpObj, 0, btEffectIndex);
}
}

[Crazzy]

... and ?

---------- Post added at 07:26 PM ---------- Previous post was at 07:02 PM ----------

decompilation process without *.pdb - very hard buisness for me, if anyone have pdb, please help me and community =) if you want a private , send me pm - we perform a deal

[guiguijvs]

releases its: GetBuffEffect, IsEffectIndex to the community ^ ^

[Crazzy]

struct PMSG_SEND_BUFF_ICON
{
PBMSG_HEAD h;
BYTE btEffectIndex;
BYTE iEffectUseOption;
WORD wOptionType;
WORD wEffectType;
int iLeftTime;
};

void GCUseEffect(LPOBJ lpObj, BYTE btEffectIndex, BYTE iEffectUseOption, WORD wOptionType, WORD wEffectType, int iLeftTime)
{
PMSG_SEND_BUFF_ICON pMsg;

PHeadSetB((LPBYTE)&pMsg, 0x2D, sizeof(PMSG_SEND_BUFF_ICON));

pMsg.btEffectIndex = btEffectIndex;
pMsg.iEffectUseOption = iEffectUseOption;
pMsg.wOptionType = wOptionType;
pMsg.wEffectType = wEffectType;
pMsg.iLeftTime = iLeftTime;


if ( lpObj->Type == OBJ_USER )
{
DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
}

if(iEffectUseOption == 0)
{
GCStateInfoSend(lpObj, 1, btEffectIndex);
}
else
{
GCStateInfoSend(lpObj, 0, btEffectIndex);
}
}

struct PMSG_SEND_BUFF_ICON
{
PBMSG_HEAD h;
BYTE btEffectIndex;
BYTE iEffectUseOption;
WORD wOptionType;
int wEffectType;
int iLeftTime
};
its correct ;)

[Alin1337]

Does anyone has a function how Rudolph loots zen? or it is all coded in client side..

I really need it.

Thanks !

[nevS]

Does anyone has a function how Rudolph loots zen? or it is all coded in client side..

I really need it.

Thanks !

It's client side ;)

[zasmqniq]

People do you know Season 6 Have New Protocol or something :?!

[Dudi2]

People do you know Season 6 Have New Protocol or something :?!

- new charset
- new char list packet
- new damage show protocol

[zasmqniq]

THats why it dissconnect me in Create Charachter !

[Crazzy]

hi rz, some people ask me for release decompile of original buffeffect system, i semi-finished this, and can share ;) look this:

BuffEffect.cpp
// ------------------------------
// Decompiled by Crazzy
// Date : 2011-04-16
// ------------------------------
//GS-N 1.00.87 0x0060B6E0 JPN - Completed
//GS-CS 1.00.87 0x0060B6E0 JPN - Completed

#include "stdafx.h"
#include "BuffEffect.h"
#include "logproc.h"


CBuffEffect g_BuffEffect;

CBuffEffect::CBuffEffect(void)
{
}


CBuffEffect::~CBuffEffect(void)
{
}



void CBuffEffect::Reset()
{
    this->m_BuffCount                        = 0;

    for ( int i = 0; i < MAX_BUFF_EFFECT-1; ++i )
    {
        this->m_iBuffData[i].m_Index        = -1;
        this->m_iBuffData[i].m_Type            = 0;
        this->m_iBuffData[i].m_SubType        = 0;    
        this->m_iBuffData[i].m_ClearType    = 0;
    }
}

void CBuffEffect::Load(LPSTR pchFilename)
{
    this->Reset();

    SMDFile = fopen(pchFilename, "r");

    if (SMDFile == NULL)
    {
        return;
    }

    SMDToken    Token;
    BYTE        Number                = 0;
    BYTE        ibtIndexNumber        = 0;
    BYTE        ibtBuffNumber        = 0;
    BYTE        iwItemIndex            = 0;
    BYTE        iwItemType            = 0;
    BYTE        ibtSkillType        = 0;
    BYTE        ibtUseType            = 0;
    BYTE        ibtClearType        = 0;
    char        ibtBuffInfo[100]    = {"\0"};
    char        ibtBuffName[20]        = {"\0"};

    //memset((PBYTE)ibtBuffInfo,0x00,sizeof(ibtBuffInfo));
    //memset((PBYTE)ibtBuffName,0x00,sizeof(ibtBuffName));

    while(true)
    {
        Token = GetToken();
        
        if(Token == END)
            break;

        if(Token == NUMBER)
        {
            Number = TokenNumber;

            while(true)
            {
                 Token = GetToken();

                 if(strcmp("end",TokenString) == 0)
                     break;

                 ibtIndexNumber                = TokenNumber;

                 Token                        = GetToken();
                 ibtBuffNumber                = TokenNumber;

                 Token                        = GetToken();
                 iwItemType                    = TokenNumber;

                 Token                        = GetToken();
                 iwItemIndex                = TokenNumber;

                 Token                        = GetToken();
                 memcpy(ibtBuffName,TokenString,sizeof(ibtBuffName));

                 Token                        = GetToken();
                 ibtSkillType                = TokenNumber;

                 Token                        = GetToken();
                 ibtUseType                    = TokenNumber;

                 Token                        = GetToken();
                 ibtClearType                = TokenNumber;

                 Token                        = GetToken();
                 memcpy(ibtBuffInfo,TokenString,sizeof(ibtBuffInfo));

                 this->SetInfo(ibtIndexNumber,ibtBuffNumber,iwItemType,iwItemIndex,ibtBuffName,ibtSkillType,ibtUseType,ibtClearType,ibtBuffInfo);
            }
        }
    }
    fclose(SMDFile);
}


void CBuffEffect::SetInfo(BYTE IndexNumber,BYTE btBuffNumber,BYTE wItemType,BYTE wItemIndex,char * BuffName,BYTE SkillType,BYTE UseType,BYTE ClearType,char * BuffInfo)
{
    this->m_iBuffData[this->m_BuffCount].m_Index            = IndexNumber;
    this->m_iBuffData[this->m_BuffCount].m_Viewport            = btBuffNumber;
    this->m_iBuffData[this->m_BuffCount].m_ItemType            = wItemType;
    this->m_iBuffData[this->m_BuffCount].m_ItemSubType        = wItemIndex;
    this->m_iBuffData[this->m_BuffCount].m_Type                = SkillType;
    this->m_iBuffData[this->m_BuffCount].m_SubType            = UseType;
    this->m_iBuffData[this->m_BuffCount].m_ClearType        = ClearType;

    strcpy(this->m_iBuffData[this->m_BuffCount].m_EffectInfo,BuffInfo);
    strcpy(this->m_iBuffData[this->m_BuffCount].m_Name,BuffName);

    this->m_BuffCount++;
}


BOOL CBuffEffect::IsEffectIndex(int IndexNumber)
{
    BOOL bResult = FALSE;

    if(IndexNumber >= 0 && IndexNumber <= MAX_BUFF_EFFECT-1)
    {
        bResult = TRUE;
    }

    return bResult;
}



BUFFEFFECT_ITEMDATA* CBuffEffect::GetEffect(int IndexNumber)
{
    if (this->IsEffectIndex(IndexNumber) == TRUE)
    {
        for ( int i = 0; i < MAX_BUFF_EFFECT-1 ; i++ )
        {
            if( this->m_iBuffData[i].m_Index == IndexNumber )
            {
                return &this->m_iBuffData[i];
            }
        }
    }
    return false;
} 

BuffEffect.h
#pragma once

#define MAX_BUFF_EFFECT 255
#define MAX_EFFECT_ON_CHAR 16


struct BUFFEFFECT_ITEMDATA
{
    BYTE            m_Index;//0
    BYTE            m_Viewport;//1
    BYTE            m_ItemType;//2
    BYTE            m_ItemSubType;//3
    char            m_Name[20];//4
    BYTE            m_Type;//24
    BYTE            m_SubType;//25
    BYTE            m_ClearType;//26
    char            m_EffectInfo[100];
};

class CBuffEffect
{
public:

    CBuffEffect(void);
    ~CBuffEffect(void);

    void                        Reset();
    void                        Load(LPSTR pchFilename);
    void                        SetInfo(BYTE IndexNumber,BYTE btBuffNumber,BYTE wItemType,BYTE wItemIndex,char * BuffName,BYTE SkillType,BYTE UseType,BYTE ClearType,char * BuffInfo);


    BUFFEFFECT_ITEMDATA*            GetEffect(int IndexNumber);
    BOOL                        IsEffectIndex(int IndexNumber);

private:
    int                            m_BuffCount;
    BUFFEFFECT_ITEMDATA            m_iBuffData[MAX_BUFF_EFFECT];

};

extern CBuffEffect g_BuffEffect; 

ViewSkillState.cpp

// ------------------------------
// Decompiled by Crazzy
// Date : 2011-04-19
// ------------------------------
//GS-N 1.00.87 0x006096A0 JPN - 95%
//GS-CS 1.00.87 0x006096A0 JPN - 95%

#include "stdafx.h"
#include "ViewSkillState.h"
#include "ViewSkillOption.h"
#include "BuffEffect.h"
#include "..\common\winutil.h"
#include "protocol.h"
#include "ItemAddOption.h"

CViewSkillState g_ViewSkillState;


CViewSkillState::CViewSkillState(void)
{
}


CViewSkillState::~CViewSkillState(void)
{
}

//----- (006096A0) --------------------------------------------------------
int CViewSkillState::SetSkillState(LPOBJ lpObj,BYTE btEffect,BYTE btOption1,BYTE btOption2,int iValue1,int iValue2,int iSecond)
{
    int iBuffEffect            = 0;
    int ReturnBuffEffect    = 0;

    int TypeCount            = 0;
    int Count                = 0;


    if ( lpObj == NULL)
    {
        return -1;
    }

    if ( lpObj->Connected < PLAYER_PLAYING)
    {
        return -1;
    }

    if ( !g_BuffEffect.IsEffectIndex(btEffect))
    {
        return -1;
    }

    BUFFEFFECT_ITEMDATA *  lpBuffEffect = g_BuffEffect.GetEffect(btEffect);

    if (lpBuffEffect == NULL)
    {
        return -1;
    }


    for ( int i= 0; ;i++)
    {
        if ( i < 16)
        {
            if( !lpObj->m_ViewSkillState[i].m_BuffEffect)
            {
                continue;
            }

            iBuffEffect = lpObj->m_ViewSkillState[i].m_BuffEffect;

            BUFFEFFECT_ITEMDATA *  lpBuffEffect2 = g_BuffEffect.GetEffect(iBuffEffect);

            if (!lpBuffEffect2)
            {
                continue;
            }

            if(lpBuffEffect2->m_Viewport == lpBuffEffect->m_Viewport)
            {
                this->ClearSkillState(lpObj,lpObj->m_ViewSkillState[i].m_BuffEffect);

                ReturnBuffEffect = lpBuffEffect2->m_Index;
            }

            if (lpBuffEffect2->m_Type)
            {
                if(lpBuffEffect2->m_Type == 1)
                {
                    TypeCount++;
                }
            }
            else
            {
                Count++;
            }
            if ( i <= lpObj->m_ViewSkillCount )
            {
                continue;
            }
        }
        break;
    }
    for ( int i=0;i<MAX_EFFECT_ON_CHAR;i++)
    {
        if(!lpObj->m_ViewSkillState[i].m_BuffEffect)
        {
            lpObj->m_ViewSkillState[i].m_BuffEffect = btEffect;
            lpObj->m_ViewSkillState[i].m_Viewport    = lpBuffEffect->m_Viewport;
            lpObj->m_ViewSkillState[i].m_Option1    = btOption1;
            lpObj->m_ViewSkillState[i].m_Option2    = btOption2;
            lpObj->m_ViewSkillState[i].m_Value1     = iValue1;
            lpObj->m_ViewSkillState[i].m_Value2        = iValue2;
            lpObj->m_ViewSkillState[i].m_Time        = iSecond;
            lpObj->m_ViewSkillState[i].m_TickCount    = GetTickCount();
            
            g_ViewSkillOption.AddOption(lpObj,btOption1,iValue1);
            g_ViewSkillOption.AddOption(lpObj,btOption2,iValue2);

            break;                        
        }
    }

    return ReturnBuffEffect;
}

//----- (006099C0) --------------------------------------------------------
BOOL CViewSkillState::ClearSkillState(LPOBJ lpObj,int iBuffEffect)
{
    BOOL Seached                = FALSE;

    if ( lpObj == NULL)
    {
        return FALSE;
    }

    if ( lpObj->Connected < PLAYER_PLAYING)
    {
        return FALSE;
    }

    if ( !g_BuffEffect.IsEffectIndex(iBuffEffect))
    {
        return FALSE;
    }

    for( int i = 0; i < MAX_EFFECT_ON_CHAR; i++)
    {
        if(Seached == TRUE)
        {
            if ( lpObj->m_ViewSkillState[i].m_BuffEffect)
            {
                if ( i > 0)
                {
                    memcpy(&lpObj->m_ViewSkillState[i-1],&lpObj->m_ViewSkillState[i], 0x14);
                    memset(&lpObj->m_ViewSkillState[i], 0, 0x14);
                }
            }
        }
        
        if(lpObj->m_ViewSkillState[i].m_BuffEffect == iBuffEffect)
        {
            //g_ViewSkillOption.DeleteOption(lpObj,lpObj->m_ViewSkillState[i].m_Option1,lpObj->m_ViewSkillState[i].m_Value1);
            //g_ViewSkillOption.DeleteOption(lpObj,lpObj->m_ViewSkillState[i].m_Option2,lpObj->m_ViewSkillState[i].m_Option2);
            memset(&lpObj->m_ViewSkillState[i], 0, 0x14);
            Seached = TRUE;
        }
    }

    if(Seached == TRUE)
    {
        return TRUE;
    }

    return FALSE;
}

//----- (00609BB0) --------------------------------------------------------
BOOL CViewSkillState::IsEffect(LPOBJ lpObj,int Effect)
{
    BOOL bResult = FALSE;

    if(g_BuffEffect.IsEffectIndex(Effect))
    {
        for ( int i = 0; i < MAX_EFFECT_ON_CHAR; ++i )
        {
            if ( lpObj->m_ViewSkillState[i].m_BuffEffect == Effect)
            {
                bResult = TRUE;
            }
        }    
    }

    return bResult;
}

//----- (00609C30) --------------------------------------------------------
void CViewSkillState::IsIceEffect(LPOBJ lpObj,int iBuffEffect)
{
    if ( iBuffEffect == 56)
    {
        lpObj->DelayActionTime    = 0;
        lpObj->DelayLevel        = 0;
        lpObj->m_IceType        = 0;
    }
}

//----- (00609C90) --------------------------------------------------------
int CViewSkillState::ClearEffect(LPOBJ lpObj,int cleartype)
{
    int CleanedEffects = 0;

    for(int i = 0; i < 16 ; i++)
    {
        if ( this->IsEffect(lpObj,lpObj->m_ViewSkillState[i].m_BuffEffect) == TRUE)
        {
            int iBuffEffect = lpObj->m_ViewSkillState[i].m_BuffEffect;

            BUFFEFFECT_ITEMDATA *  lpBuffEffect = g_BuffEffect.GetEffect(iBuffEffect);

            if (lpBuffEffect)
            {
                if(lpBuffEffect->m_ClearType == cleartype)
                {
                    if (this->ClearSkillState(lpObj, lpObj->m_ViewSkillState[i].m_BuffEffect) == TRUE)
                    {
                        CleanedEffects++;
                        i--;
                    }
                }
                if ( cleartype == 2)
                {
                    if (this->ClearSkillState(lpObj, lpObj->m_ViewSkillState[i].m_BuffEffect) == TRUE)
                    {
                        CleanedEffects++;
                        i--;
                    }
                }
                if ( cleartype == 1)
                {
                    if (this->ClearSkillState(lpObj, lpObj->m_ViewSkillState[i].m_BuffEffect) == TRUE)
                    {
                        CleanedEffects++;
                        i--;
                    }
                }
            }
        }
    }

    return CleanedEffects;
}

//----- (00609E50) --------------------------------------------------------
BUFFEFFECT_ITEMDATA * CViewSkillState::GetBuffEffect(int Effect)
{
    if (g_BuffEffect.IsEffectIndex(Effect) )
    {
        return g_BuffEffect.GetEffect(Effect);
    }

    return false;
}

//----- (00609F20) --------------------------------------------------------
void CViewSkillState::Proc(LPOBJ lpObj)
{
    if(lpObj == NULL)
    {
        return;
    }

    if(!OBJMAX_RANGE(lpObj->m_Index))
    {
        return;
    }

    if ( lpObj->Type == OBJ_USER && lpObj->Connected == PLAYER_PLAYING || lpObj->Type == OBJ_MONSTER)
    {
        for ( int i = 0; i < MAX_EFFECT_ON_CHAR; i++ )
        {
            if ( lpObj->m_ViewSkillState[i].m_TickCount != 0xF6 )
            {
                if(lpObj->m_ViewSkillState[i].m_BuffEffect)
                {
                    if(lpObj->m_ViewSkillState[i].m_BuffEffect == 55)
                    {
                        if(!lpObj->m_ViewSkillState[i].m_TickCount % 3)
                        {
                            g_ViewSkillOption.Run(lpObj,lpObj->m_ViewSkillState[i].m_Option1,lpObj->m_ViewSkillState[i].m_Value1);
                            g_ViewSkillOption.Run(lpObj,lpObj->m_ViewSkillState[i].m_Option2,lpObj->m_ViewSkillState[i].m_Value2);
                        }
                    }
                    else
                    {
                        g_ViewSkillOption.Run(lpObj,lpObj->m_ViewSkillState[i].m_Option1,lpObj->m_ViewSkillState[i].m_Value1);
                        g_ViewSkillOption.Run(lpObj,lpObj->m_ViewSkillState[i].m_Option2,lpObj->m_ViewSkillState[i].m_Value2);
                    }
                    lpObj->m_ViewSkillState[i].m_Time--;

                    if(lpObj->m_ViewSkillState[i].m_Time <= 0)
                    {
                        g_ViewSkillState.DeleteEffect(lpObj,lpObj->m_ViewSkillState[i].m_BuffEffect);
                    }
                }
            }
        }
    }
}

//----- (0060A1A0) --------------------------------------------------------
void CViewSkillState::AddOptionEffect(LPOBJ lpObj,int Effect)
{
    if ( lpObj == NULL)
    {
        return;
    }

    if(!OBJMAX_RANGE(lpObj->m_Index))
    {
        return;
    }

    BUFFEFFECT_ITEMDATA *  lpBuffEffect = this->GetBuffEffect(Effect);

    if(lpBuffEffect == NULL)
    {
        return;
    }

    int iItemNumber = ITEMGET(lpBuffEffect->m_ItemType,lpBuffEffect->m_ItemSubType);


    if(g_ItemAddOption.IsAddOptionItem(iItemNumber))
    {
        LPITEMEFFECT lpItemEffect = g_ItemAddOption.GetItem(iItemNumber);

        int iEffect = this->SetSkillState(lpObj,Effect,lpItemEffect->wEffectType1,lpItemEffect->wEffectType2,
            lpItemEffect->iEffectValue1,lpItemEffect->iEffectValue2,lpItemEffect->iEffectValidTime);
        
        if(iEffect == -1)
        {
            return;
        }
        else
        {
            if(iEffect <= 0)
            {
                lpObj->m_ViewSkillCount++;
            }
            else
            {
                this->GCUseEffect(lpObj, iEffect, 2, lpItemEffect->wOptionType, 0, 0);
            }

            this->GCUseEffect(lpObj, iEffect, 0, lpItemEffect->wOptionType, lpItemEffect->wEffectType1, lpItemEffect->iEffectValidTime);
        }
    }


    return;
}

//----- (0060A360) --------------------------------------------------------                            
void CViewSkillState::AddBuffEffect(LPOBJ lpObj, BYTE btEffect,BYTE btOption1, int iValue1, BYTE btOption2, int iValue2,int iLeftTime)
{
    if ( lpObj == NULL ) 
    {
        return;
    }

    if ( !OBJMAX_RANGE(lpObj->m_Index))
    {
        return;
    }

    BUFFEFFECT_ITEMDATA *  BuffEffect = this->GetBuffEffect(btEffect);

    int iEffect = this->SetSkillState(lpObj,btEffect,btOption1,btOption2,iValue1,iValue2,iLeftTime);

    if (iEffect == -1)
    {
        return;
    }

    if ( iEffect > 0 )
    {
        this->GCUseEffect(lpObj, iEffect, 2, BuffEffect->m_Viewport, 0, 0);
    }
    else
    {
        lpObj->m_ViewSkillCount++;
    }

    this->GCUseEffect(lpObj, btEffect, 0, BuffEffect->m_Viewport, btOption1, iLeftTime);
}

//----- (0060A490) --------------------------------------------------------
BOOL CViewSkillState::AddCashShopPeriodEffect(LPOBJ lpObj, int Effect,int iLeftTime)
{
    if ( lpObj == NULL)
    {
        return FALSE;
    }

    if(!OBJMAX_RANGE(lpObj->m_Index))
    {
        return FALSE;
    }

    BUFFEFFECT_ITEMDATA *  lpBuffEffect = this->GetBuffEffect(Effect);

    if(lpBuffEffect == NULL)
    {
        return FALSE;
    }

    int iItemNumber = ITEMGET(lpBuffEffect->m_ItemType,lpBuffEffect->m_ItemSubType);


    if(g_ItemAddOption.IsAddOptionItem(iItemNumber))
    {
        LPITEMEFFECT lpItemEffect = g_ItemAddOption.GetItem(iItemNumber);

        int iEffect = this->SetSkillState(lpObj,Effect,lpItemEffect->wEffectType1,lpItemEffect->wEffectType2,
            lpItemEffect->iEffectValue1,lpItemEffect->iEffectValue2,iLeftTime);
        
        if(iEffect == -1)
        {
            return FALSE;
        }
        else
        {
            if(iEffect <= 0)
            {
                lpObj->m_ViewSkillCount++;
            }
            else
            {
                this->GCUseEffect(lpObj, iEffect, 2, lpItemEffect->wOptionType, 0, 0);
            }

            this->GCUseEffect(lpObj, iEffect, 0, lpItemEffect->wOptionType, lpItemEffect->wEffectType1, iLeftTime);
            return TRUE;
        }
    }
    return FALSE;
}

//----- (0060A640) --------------------------------------------------------
BOOL CViewSkillState::DeleteEffect(LPOBJ lpObj,int iEffect)
{
    if ( lpObj == NULL ) 
    {
        return FALSE;
    }

    if ( !OBJMAX_RANGE(lpObj->m_Index))
    {
        return FALSE;
    }

    BUFFEFFECT_ITEMDATA *  lpBuffEffect = this->GetBuffEffect(iEffect);

    if(lpBuffEffect == NULL)
    {
        return FALSE;
    }

    if(this->ClearSkillState(lpObj,iEffect) == TRUE)
    {
        this->IsIceEffect(lpObj,iEffect);
        lpObj->m_ViewSkillCount--;
        //this->GCUseEffect(lpObj, iEffect, 1, 0, lpBuffEffect->m_Viewport, 0);
        this->GCUseEffect(lpObj, iEffect, 1, lpBuffEffect->m_Viewport, 0, 0);
        return TRUE;
    }
  
    return FALSE;
}

//----- (0060A740) --------------------------------------------------------
void CViewSkillState::SetOption(LPOBJ lpObj,int iOption)
{
    if ( lpObj == NULL ) 
    {
        return;
    }

    if ( !OBJMAX_RANGE(lpObj->m_Index))
    {
        return;
    }

    int v9 = 0;

    switch ( iOption )
    {
    case 2:
        for ( int i=0;i < MAX_EFFECT_ON_CHAR; i++)
        {
            if( this->DeleteEffect(lpObj,lpObj->m_ViewSkillState[i].m_BuffEffect) == TRUE)
            {
                v9++;
                i--;
            }
        }
        lpObj->m_ViewSkillCount = 0;
        break;

    case 5:
        for ( int i=0;i < MAX_EFFECT_ON_CHAR; i++)
        {
            if(lpObj->m_ViewSkillState[i].m_BuffEffect >= 29 && lpObj->m_ViewSkillState[i].m_BuffEffect <= 31 || lpObj->m_ViewSkillState[i].m_BuffEffect == 104)
            {
                if( this->DeleteEffect(lpObj,lpObj->m_ViewSkillState[i].m_BuffEffect) == TRUE)
                {
                    v9++;
                    i--;
                }
            }
        }
    case 6:
        for ( int i=0;i < MAX_EFFECT_ON_CHAR; i++)
        {
            switch ( lpObj->m_ViewSkillState[i].m_BuffEffect )
            {
            case 0x1D:
            case 0x1E:
            case 0x1F:
            case 0x28:
            case 0x29:
            case 0x2A:
            case 0x2B:
            case 0x2C:
            case 0x2D:
            case 0x2E:
            case 0x2F:
            case 0x30:
            case 0x31:
            case 0x32:
            case 0x33:
            case 0x34:
            case 0x35:
            case 0x36:
            case 0x57:
            case 0x58:
            case 0x59:
            case 0x5A:
            case 0x63:
            case 0x64:
            case 0x65:
            case 0x66:
            case 0x68:
                continue;
            default:
                if ( this->DeleteEffect(lpObj, lpObj->m_ViewSkillState[i].m_BuffEffect) == 1 )
                {
                    v9++;
                    i--;
                }
                break;
            }
        }
    case 7:
        for ( int i=0;i < MAX_EFFECT_ON_CHAR; i++)
        {
            if(lpObj->m_ViewSkillState[i].m_BuffEffect >= 14 && lpObj->m_ViewSkillState[i].m_BuffEffect <= 17 )
            {
                if( this->DeleteEffect(lpObj,lpObj->m_ViewSkillState[i].m_BuffEffect) == TRUE)
                {
                    v9++;
                    i--;
                }
            }
        }
        break;
    default:
          this->ClearEffect(lpObj,iOption);
          break;
    }
    if ( lpObj->m_ViewSkillCount > 16 )
    {
        lpObj->m_ViewSkillCount = 0;
    }
    this->SendAllState(lpObj);
}

//----- (0060AB20) --------------------------------------------------------
BOOL CViewSkillState::IsEffectEnable(LPOBJ lpObj,int Effect)
{
    if(lpObj == NULL)
    {
        return FALSE;
    }

    if(OBJMAX_RANGE(lpObj->m_Index))
    {
        return this->IsEffect(lpObj,Effect);
    }
    return FALSE;
}

//----- (0060AB80) --------------------------------------------------------
void CViewSkillState::UpdateEffect(LPOBJ lpObj,int iEffect,int iTimeAdd)
{
    int i                = 0;

    if (lpObj == NULL)
    {
        return;
    }
    
    if (lpObj->Connected >= PLAYER_PLAYING)
    {
        for ( i = 0 ; ; i++)
        {
            if( i >= 16 )
                return;
            if ( i > lpObj->m_ViewSkillCount)
            {
                return;
            }
            if ( lpObj->m_ViewSkillState[i].m_BuffEffect == iEffect)
            {
                break;
            }
        }
        lpObj->m_ViewSkillState[i].m_Time += iTimeAdd;
        //lpObj->m_ViewSkillState[i].m_TickCount = GetTickCount(); // I don't understand this, but webzen it no uses
        if ( lpObj->m_ViewSkillState[i].m_Time < 0 )
        {
            this->DeleteEffect(lpObj, iEffect);
        }
    }

}

//----- (0060AD60) --------------------------------------------------------
BYTE CViewSkillState::List(LPOBJ lpObj, BYTE *btEffect)
{
    BYTE iEffectCount = 0;

    if(lpObj == NULL)
    {
        return -1;
    }

    if(lpObj->Connected >= PLAYER_PLAYING)
    {
        for ( int i =0; i < 16 && iEffectCount < 16 && iEffectCount < lpObj->m_ViewSkillCount; i++)
        {
            if( lpObj->m_ViewSkillState[i].m_BuffEffect)
            {
                btEffect[iEffectCount++] = lpObj->m_ViewSkillState[i].m_BuffEffect;
                continue;
            }
            btEffect[i] = 0;
        }
        return iEffectCount;
    }
    return -1;
}

//----- (0060AE60) --------------------------------------------------------
BOOL CViewSkillState::IsValue2(LPOBJ lpObj,int iEffect,int Value1,int Value2)
{
    if(lpObj == NULL)
    {
        return FALSE;
    }

    if(lpObj->Connected >= PLAYER_PLAYING)
    {
        for ( int i = 0; i < MAX_EFFECT_ON_CHAR; i++)
        {
            if(lpObj->m_ViewSkillState[i].m_BuffEffect == iEffect)
            {
                if ( lpObj->m_ViewSkillState[i].m_Value1 > Value1 )
                {
                    return TRUE;
                }
                if ( lpObj->m_ViewSkillState[i].m_Value2 > Value2 )
                {
                    return TRUE;
                }
            }
        }
    }
    return FALSE;
}
//----- (0060AF10) --------------------------------------------------------
int CViewSkillState::GetSkillOption(LPOBJ lpObj,int iOption)
{
    int iGetOption        = 0;

    if(lpObj == NULL)
    {
        return 0;
    }

    if(lpObj->Connected >= PLAYER_PLAYING)
    {
        for ( int i = 0; i < MAX_EFFECT_ON_CHAR; i++)
        {
            if(lpObj->m_ViewSkillState[i].m_BuffEffect)
            {
                if(lpObj->m_ViewSkillState[i].m_Option1 == iOption)
                {
                    iGetOption += lpObj->m_ViewSkillState[i].m_Value1;
                }
                if(lpObj->m_ViewSkillState[i].m_Option2 == iOption)
                {
                    iGetOption += lpObj->m_ViewSkillState[i].m_Value2;
                }
            }
        }
        return iGetOption;
    }

    return 0;
}

//----- (0060B010) --------------------------------------------------------
void CViewSkillState::GetSkillOption2(LPOBJ lpObj,int iEffect,int * iValue1, int * iValue2)
{
    int i        = 0;

    if(lpObj == NULL)
    {
        return;
    }

    if(lpObj->Connected >= PLAYER_PLAYING)
    {
        for (i = 0; ; i++)
        {
            if( i >= 16)
            {
                return;
            }
            if(lpObj->m_ViewSkillState[i].m_BuffEffect == iEffect)
                break;
        }

        *iValue1 = lpObj->m_ViewSkillState[i].m_Value1; 
        if (iValue2)
            *iValue2 = lpObj->m_ViewSkillState[i].m_Value2;
    }
}

//----- (0060B0D0) --------------------------------------------------------
void CViewSkillState::GCUseEffect(LPOBJ lpObj,BYTE btEffect,BYTE btState,WORD wViewport, WORD wOption1, int iLeftTime)
{
    PMSG_USEEFFECTITEM pMsg;

    PHeadSetB((LPBYTE)&pMsg, 0x2D, sizeof(pMsg));

    pMsg.iSkillState = btEffect;
    pMsg.byEffectOption = btState;
    pMsg.wEffectType = wOption1;
    pMsg.wOptionType = wViewport;
    pMsg.iLeftTime = iLeftTime;

    if ( lpObj->Type == OBJ_USER )
        DataSend(lpObj->m_Index, (UCHAR*)&pMsg, pMsg.h.size);

    if ( btState )
    {
        GCStateInfoSend(lpObj, 0, btEffect);
    }
    else
    {
        GCStateInfoSend(lpObj, 1, btEffect);
    }
}

//----- (0060B1A0) --------------------------------------------------------
void CViewSkillState::SendAllState(LPOBJ lpObj)
{
    if ( lpObj == NULL ) 
    {
        return;
    }

    if ( lpObj->Type != OBJ_USER )
    {
        return;
    }

    if ( lpObj->m_ViewSkillCount <= 0)
    {
        return;
    }

    for ( int i = 0; i < MAX_EFFECT_ON_CHAR; i++ )
    {
        if(lpObj->m_ViewSkillState[i].m_BuffEffect)
        {
            GCStateInfoSend(lpObj,1,lpObj->m_ViewSkillState[i].m_BuffEffect);
        }
    }
}

//----- (0060B250) -------------------------------------------------------- // this is for XMasAtatck event winners
void CViewSkillState::AddRewardBuff(LPOBJ lpObj,int Dis, int *Count, int iEffect, int iOption1, int iValue1, int iOption2, int iValue2, int iTime)
{
    if ( lpObj == NULL ) 
    {
        return;
    }

    LPOBJ lpRewardObj;

    for(int i = OBJ_STARTUSERINDEX; i < OBJMAX; i++)
    {
        lpRewardObj = &gObj[i];

        if( lpRewardObj->Type = OBJ_USER)
        {
            if(gObjIsConnected(i))
            {
                if(lpRewardObj->MapNumber == lpObj->MapNumber)
                {
                    if ( gObjCalDistance(lpObj,lpRewardObj) < Dis )
                    {
                        this->AddBuffEffect(lpRewardObj, iEffect, iOption1, iValue1, iOption2, iValue2, iTime);
                        *Count++;
                    }
                }
            }
        }
    }
}

//----- (0060B360) -------------------------------------------------------- // not complete 
int __cdecl CViewSkillState_AddExp(LPOBJ lpObj, int *iAddExp, int a3); 

ViewSkillState.h
#pragma once

#include "user.h"


class CViewSkillState
{
public:
    int SetSkillState(LPOBJ lpObj,BYTE btEffect,BYTE btOption1,BYTE btOption2,int iValue1,int iValue2,int iSecond);//sub_402112 - Complete <- public
    BOOL ClearSkillState(LPOBJ lpObj,int iBuffEffect);//sub_406F0A - Complete <- private
    BOOL IsEffect(LPOBJ lpObj,int Effect);//sub_402BF8 - Complete <- private
    void IsIceEffect(LPOBJ lpObj,int iBuffEffect);//sub_405155 - Complete <- private
    int ClearEffect(LPOBJ lpObj,int cleartype);//sub_401AC3 - Complete <- private
    BUFFEFFECT_ITEMDATA * GetBuffEffect(int Effect);//sub_406140 - Complete <- private
    void Proc(LPOBJ lpObj);//sub_407720 - Complete <- public
    void AddOptionEffect(LPOBJ lpObj,int Effect);//sub_40199C -90%(lack of cherry buffs) <- public
    void AddBuffEffect(LPOBJ lpObj, BYTE btEffect,BYTE btOption1, int iValue1, BYTE btOption2, int iValue2,int iLeftTime);//sub_4051E6 SemiFinished- <-Public
    BOOL AddCashShopPeriodEffect(LPOBJ lpObj, int Effect,int iLeftTime);//sub_4050D3() Lack of CashItemPeriodSystem one call <- Public
    BOOL DeleteEffect(LPOBJ lpObj,int iEffect);//sub_402301 SemiFinished <- public
    void SetOption(LPOBJ lpObj,int iOption); //sub_404769 - complete <- public
    BOOL IsEffectEnable(LPOBJ lpObj,int Effect);//sub_407199 MonsterHerdLackSymbols//for this->AddExp//And some suncs ~ 90% finished <- public
    void UpdateEffect(LPOBJ lpObj,int iEffect,int iTimeAdd);//sub_406E33 - finished <- public
    
    
    BYTE List(LPOBJ lpObj, BYTE *btEffect);//sub_40767B -Complete <- public
    BOOL IsValue2(LPOBJ lpObj,int iEffect,int Value1,int Value2);//sub_405D85 - Not Finished (ObjUseSkill and MasterSystem) <- public
    int GetSkillOption(LPOBJ lpObj,int iOption);//sub_402F77
    void GetSkillOption2(LPOBJ lpObj,int iEffect,int *iValue1, int *iValue2);
    


    void GCUseEffect(LPOBJ lpObj,BYTE btEffect,BYTE btState,WORD wViewport, WORD wOption1, int iLeftTime);
    //void GCUseEffect(LPOBJ lpObj,int iEffect,int iState,int iViewport, int bOption1, int iLeftTime);
    void SendAllState(LPOBJ lpObj);
    void AddRewardBuff(LPOBJ lpObj,int Dis, int *Count, int iEffect, int iOption1, int iValue1, int iOption2, int iValue2, int iTime);
    int AddExp(LPOBJ lpObj,int * iAddExp,int iValue);

    CViewSkillState(void);
    ~CViewSkillState(void);
};

extern CViewSkillState g_ViewSkillState; 

and for OBJECTSTRUCT adds:

struct VIEW_SKILL_STATE
{
    BYTE        m_BuffEffect;//528
    BYTE        m_Viewport;//529
    BYTE        m_Option1;//530
    BYTE        m_Option2;//531
    int            m_Value1;//532
    int            m_Value2;//536
    int            m_TickCount;//540
    int            m_Time;//544 
};


struct OBJECTSTRUCT
{
        ...
        BYTE m_ViewState;
    BYTE m_ViewSkillCount;
    VIEW_SKILL_STATE m_ViewSkillState[MAX_EFFECT_ON_CHAR];
        ... 

ViewSkillOption class is not finished, bcoz it have new summoner effects and etc..


Credits:
WebZen
me(decompile)
Endi(CzF)(func names)

Please respect credits!!

[jc97]

- new charset
- new char list packet
- new damage show protocol

Could you share it?
Because i Added the fix for rage fighter creation but when I login and create a character it disconnects me.

[zasmqniq]

Yup,if its not a problem it would be nice to share this :)!

[duracel]

From what i heared, you'll also need to fix the dataservers..

[guiguijvs]

Crazzy release also ItemAddOption.cpp and (.h) and GCStateInfoSend func.

[zasmqniq]

hmm yeah duracel same here need to fix the database but there is no one to explain this how it work :)!

[Crazzy]

Crazzy release also ItemAddOption.cpp and (.h) and GCStateInfoSend func.

no .. sorry..

[guiguijvs]

News func. ItemAddOption


BOOL CItemAddOption::GetItemGroup(int iItemNumber)
{// 0x0054AC10

LPITEMEFFECT lpItemEffect = NULL;

lpItemEffect = this->_SearchItemEffect(iItemNumber);

if ( lpItemEffect == NULL )
return -1;

return lpItemEffect;
}

bool CItemAddOption::IsItemGroup(int iItemNumber)
{//0x0054AC70

if ( this->_SearchItemEffect(iItemNumber) )
{
return true;
}
else
{
return false;
}
}

LPITEMEFFECT CItemAddOption::GetItem(int iItemNumber)
{//- 0x0054ACB0
return this->_SearchItemEffect(iItemNumber);
}


has some more functions in cpp (2 or 3) after I post here

[zasmqniq]

hmm ok gyiz can you help with this

- new charset
- new char list packet
- new damage show protocol

duracel can you help with this and maybe explain the database :?
It will be very usefull for a lot people thanks again :)

---------- Post added at 02:50 PM ---------- Previous post was at 02:49 PM ----------

hmm ok gyiz can you help with this

- new charset
- new char list packet
- new damage show protocol

duracel can you help with this and maybe explain the database :?
It will be very usefull for a lot people thanks again :)
Not everybody is smart

[duracel]

Can't help you cause i don't know how to fix, if i did i would have posted, i just know that the struct PMSG_CHARLISTCOUNT has 2 new vars and i wrote that it need dataserver fix not database.

[zasmqniq]

Yeah DataServer lapsus :D

is this what we need!

protocol.h

void CheckLoginCharacterRecv(int aIndex, LPBYTE aRecv, DWORD aLen);
void CheckCreateCharacterRecv(int aIndex, LPBYTE aRecv);

protocolo.cpp

                case 0xF1:
			CheckLoginCharacterRecv(aIndex,aRecv, aLen);
			break;
		case 0xF3:
			//CheckCreateCharacterRecv(aIndex,aRecv);
			break;

void CheckLoginCharacterRecv(int aIndex, LPBYTE aRecv, DWORD aLen)
{
	OBJECTSTRUCT *gObj = (OBJECTSTRUCT*)OBJECT_POINTER(aIndex);

	if(aRecv[3] == 0x01)
	{
		if(!FirewallC.CheckIP(aIndex))
			return;
	}

	if(config.CUSCFG.cProtocol != JAPAN)
	{
		aRecv[1] -= 0x02;
		aLen = aRecv[1];
		for (int i = 24; i<50; i++)
		aRecv[i] = aRecv[i+2];
	}
}

void CheckCreateCharacterRecv(int aIndex, LPBYTE aRecv)
{
	OBJECTSTRUCT *gObj = (OBJECTSTRUCT*)OBJECT_POINTER(aIndex);
}

NewCharachter.h

#ifndef NEWCHARACTER_H
#define NEWCHARACTER_H

__declspec() void CreateNewChar();
__declspec() void SelectNewChar();

void FixRFHP_MN_Calculation(DWORD PlayerID);

class NewCharacter
{
public:
	NewCharacter();
	~NewCharacter();
	void NewCharacterHooks();
};
extern NewCharacter NewChar;

#endif

NewCharachter.cpp

#include "StdAfx.h"

NewCharacter NewChar;
// --------------------------------------------------------------------------------
__declspec(naked) void CreateNewChar()
{
	_asm
	{
		cmp edx, 0x10;
		je CreateChar;

		cmp edx, 0x20;
		je CreateChar;

		cmp edx, 0x30;
		je CreateChar;

		cmp edx, 0x40;
		je CreateChar;

		cmp edx, 0x50;
		je CreateChar;

		cmp edx, 0x60;
		je CreateChar;

		mov edi, 0x0043B52A;
		jmp edi;

CreateChar:
		mov edi, 0x0043B528;
		jmp edi;
	}
}
// --------------------------------------------------------------------------------
__declspec(naked) void SelectNewChar()
{
	_asm
	{
		cmp edx, 0x01;
		je ClassAllowed;

		cmp edx, 0x03;
		je ClassAllowed;

		cmp edx, 0x10;
		je ClassAllowed;

		cmp edx, 0x11;
		je ClassAllowed;

		cmp edx, 0x13;
		je ClassAllowed;

		cmp edx, 0x20;
		je ClassAllowed;

		cmp edx, 0x21;
		je ClassAllowed;

		cmp edx, 0x23;
		je ClassAllowed;

		cmp edx, 0x30;
		je ClassAllowed;

		cmp edx, 0x32;
		je ClassAllowed;

		cmp edx, 0x40;
		je ClassAllowed;

		cmp edx, 0x42;
		je ClassAllowed;

		cmp edx, 0x50;
		je ClassAllowed;

		cmp edx, 0x51;
		je ClassAllowed;

		cmp edx, 0x53;
		je ClassAllowed;

		cmp edx, 0x60;
		je ClassAllowed;

		cmp edx, 0x62;
		je ClassAllowed;

		mov edi, 0x005030E0;
		jmp edi;

ClassAllowed:
		mov edi, 0x005030DE;
		jmp edi;
	}
}

/*__declspec(naked) void FixSkillNewChar()
{
	_asm
	{
		PUSH 0x48;
		je SkillAllowed;

		mov edi, 0x00504ADA;
		jmp edi;

		SkillAllowed:
		mov edi, 0x00504AD5;
		jmp edi;
	}
}*/
// --------------------------------------------------------------------------------
NewCharacter::NewCharacter()
{
	// ----
}
// --------------------------------------------------------------------------------
NewCharacter::~NewCharacter()
{
	// ----
}
// --------------------------------------------------------------------------------
void NewCharacter::NewCharacterHooks()
{
	// -- New Character Created
	memset((PBYTE)0x0043B4EF,0xE9,1);
	HookThis((DWORD)&CreateNewChar,0x0043B4EF);

	// --- New Character Login
	memset((PBYTE)0x0050300F,0xE9,1);
	HookThis((DWORD)&SelectNewChar,0x0050300F);

	// --- New Character Skills
	//memset((PBYTE)0x00504A30,0xE9,1);
	//HookThis((DWORD)&FixSkillNewChar,0x00504A30);

	//BYTE CreatNewCharChangeOffset[]					=	{0xFF, 0x25, 0x00, 0xC0, 0x71, 0x00, 0x90};
	//memcpy((DWORD*)0x0043B523,				CreatNewCharChangeOffset,				sizeof(CreatNewCharChangeOffset)); // New Character Support
	//*(unsigned int*)0x0071C000								= (unsigned int)CreateNewChar; // New Character Support
}
// --------------------------------------------------------------------------------

		/*JE 0x0043B528
		MOV EAX,DWORD PTR SS:[EBP+0x08]
		XOR ECX,ECX
		MOV CL,BYTE PTR DS:[EAX+0x0E]*/
/*
void __declspec(naked) CharacterCreate_Add()
{
	_asm
	{
		CMP ECX,0x50
		JE Allow
		JMP GoTo

GoTo:
		CMP ECX,0x60
		JE Allow
		JMP Exit

Allow:
		MOV EDI,0x0043B542
		JMP EDI

Exit:
		MOV EDI,0x0043B52A
		JMP EDI

	}
}

*/

The problem is in DataServer how to fix it :?!

[Mulegend]

U try with dataserver from some Season 6 files?

[zasmqniq]

Nop but i want to teach my self how to do this :)

[Mulegend]

Yes, u are right, but only for test... u can use eDataserver source :)