Weapon Merge problems...

Hello,

I am still having problems with the weapon merge system... and unfortunately I can't find a fix for it...

I am using the Virtuos v19 files (non-4th jobs).. The weapon merge system works properly but when I close the server and start it again the weapon loses its merged stats and it adds like +1341321 attack.

Any idea on how this problem could be solved? Because it seems that it should be working fine... but it's not...

Any help would be really, really appreciated! <3

Havent touched this in ages since I won't be using it, lol.

MsgHdr.h

Spoiler:

Code:

---

#ifdef __WEAPON_MERGE
#define        PACKETTYPE_WEAPONMERGE                                                                (DWORD)0x88100251
#define PACKETTYPE_WEAPONMERGE_CANCEL                                                (DWORD)0x88100252
#endif

---

DbManagerfun.cpp

Spoiler:

CDbManager::LoadPiercingInfo

Code:

---

#ifdef __WEAPON_MERGE
        if (itemElem.isMerged())
        {
                itemElem.SetMergedPierceSize(GetIntPaFromStr(szPirecingInven, pLocation));
                for (int i = 0; i < itemElem.GetMergedPeirceSize(); ++i)
                        itemElem.SetMergedPierceItem(i, (DWORD)GetIntPaFromStr(szPirecingInven, pLocation));
        }
#endif

---

CDbManager::GetOneItem

Code:

---

#ifdef __WEAPON_MERGE
        pItemElem->SetMergedWeaponATK(GetIntPaFromStr(pstrItem, pLocation));
        pItemElem->SetMergedDsts(GetInt64PaFromStr(pstrItem, pLocation));
#ifdef __5LAWAKES
        pItemElem->SetMergedAdjs(GetInt64PaFromStr(pstrItem, pLocation));
#endif
#endif

---

DbManagerSave.cpp

Spoiler:

CDbManager::SaveOneItem

Code:

---

#ifdef __WEAPON_MERGE
                                ",%d,%I64d"
#ifdef __5LAWAKES
                                ",%I64d"
#endif
#endif

---

Code:

---

#ifdef __WEAPON_MERGE
                                , pItemElem->GetMergedWeaponATK()
                                , pItemElem->GetMergedDsts()
#ifdef __5LAWAKES
                                , pItemElem->GetMergedAdjs()
#endif
#endif

---

Code:

---

#endif
#ifdef __WEAPON_MERGE
                if (pItemElem->isMerged())
                {
                        sprintf(szPiercing, ",%d", pItemElem->GetMergedPeirceSize());
                        strncat(pItemStruct->szPiercing, szPiercing, sizeof(szPiercing));

                        for (int nPirecing = 0; nPirecing < pItemElem->GetMergedPeirceSize(); ++nPirecing)
                        {
                                sprintf(szPiercing, ",%d", pItemElem->GetMergedPierceItem(nPirecing));
                                strncat(pItemStruct->szPiercing, szPiercing, sizeof(szPiercing));
                        }
                }

#endif

---

Obj.cpp

Spoiler:

CItemElem::CItemElem()

Code:

---

#ifdef __WEAPON_MERGE
        m_nMergedAtk = 0;
        m_nMergedDsts = 0;
#ifdef __5LAWAKES
        m_nMergedAdjs = 0;
#endif
#endif

---

CItemElem& CItemElem::operator =( CItemElem & ie )

Code:

---

#ifdef __WEAPON_MERGE
        m_nMergedAtk = ie.GetMergedWeaponATK();
        m_nMergedDsts = ie.GetMergedDsts();
#ifdef __5LAWAKES
        m_nMergedAdjs = ie.GetMergedAdjs();
#endif
#endif

---

obj.h

Spoiler:

class CItemElem : public CItemBase

Code:

---

        enum { expired = 0x01, binds = 0x02,
#ifdef __WEAPON_MERGE
                merged = 0x04,
#endif

---

Code:

---

#ifdef __WEAPON_MERGE
private:
        int        m_nMergedAtk;
        __int64 m_nMergedDsts;
#ifdef __5LAWAKES
        __int64        m_nMergedAdjs;
#endif
public:
        bool isMerged(){ return (IsFlag(merged)); }
        void SetMergedWeaponATK(int nATK) { m_nMergedAtk = nATK; }
        int        GetMergedWeaponATK() { return m_nMergedAtk; }
        void SetMergedDsts(__int64 iID) { m_nMergedDsts = iID; }
        __int64 GetMergedDsts(){ return m_nMergedDsts; }
#ifdef __5LAWAKES
        __int64 GetMergedAdjs(){ return m_nMergedAdjs; }
        void SetMergedAdjs(__int64 nAdj){ m_nMergedAdjs = nAdj; }
#endif
        void SetMergedPierceSize(int i){ m_piercing.SetMergedPiercingSize(i); }
        void SetMergedPierceItem(int ati, DWORD nItem){ m_piercing.SetMergedPiercingItem(ati, nItem); }
        int GetMergedPeirceSize(){ return m_piercing.GetMergedPiercingSize(); }
        DWORD GetMergedPierceItem(int ati){ return m_piercing.GetMergedPiercingItem(ati); }

        std::vector<DWORD> GetPierceVector(){ return m_piercing.GetPiercingVec(); }
        void PiercetoMerged(std::vector<DWORD> wew){ m_piercing.SetMergedPierceVec(wew); }
#endif

---

objserialize.cpp

Spoiler:

CItemElem::Serialize( CAr & ar )

Code:

---

#ifdef __WEAPON_MERGE
                ar << m_nMergedAtk;
                ar << m_nMergedDsts;
#ifdef __5LAWAKES
                ar << m_nMergedAdjs;
#endif
#endif

---

Code:

---

#ifdef __WEAPON_MERGE
                ar >> m_nMergedAtk;
                ar >> m_nMergedDsts;
#ifdef __5LAWAKES
                ar >> m_nMergedAdjs;
#endif
#endif

---

Piercing.cpp

Spoiler:

CPiercing& CPiercing::operator=( const CPiercing & piercing )

Code:

---

#ifdef __WEAPON_MERGE
        m_vMergedPiercing.assign( piercing.m_vMergedPiercing.begin(), piercing.m_vMergedPiercing.end() );
#endif

---

CPiercing::Clear

Code:

---

#ifdef __WEAPON_MERGE
        m_vMergedPiercing.clear();
#endif

---

CPiercing::Serialize

Code:

---

#ifdef __WEAPON_MERGE
                ar << GetMergedPiercingSize();
                for (int i = 0; i < (int)(GetMergedPiercingSize()); ++i)
                        ar << GetMergedPiercingItem(i);
#endif

---

Code:

---

#ifdef __WEAPON_MERGE
                ar >> nSize;
                SetMergedPiercingSize(nSize);
                for (size_t i = 0; i < nSize; ++i)
                {
                        DWORD dwItem;
                        ar >> dwItem;
                        SetMergedPiercingItem(i, dwItem);
                }
#endif

---

Code:

---


#ifdef __WEAPON_MERGE
void CPiercing::SetMergedPiercingSize( int nSize )
{
        if (nSize > MAX_PIERCING_WEAPON){ return; }
        m_vMergedPiercing.resize( nSize, 0 );
}
int        CPiercing::GetMergedPiercingSize()
{
        return m_vMergedPiercing.size();
}
void CPiercing::SetMergedPiercingItem( int nth, DWORD dwItem )
{
        if (nth >= GetMergedPiercingSize() || nth < 0){ return; }
        m_vMergedPiercing[nth] = dwItem;
}
DWORD CPiercing::GetMergedPiercingItem( int nth )
{
        if (nth >= GetMergedPiercingSize() || nth < 0){ return NULL; }
        return m_vMergedPiercing[nth];
}
#endif

---

Piercing.h

Spoiler:

class CPiercing

Code:

---

#ifdef __WEAPON_MERGE
        void SetMergedPiercingSize(int nSize);
        int GetMergedPiercingSize();
        void SetMergedPiercingItem(int nth, DWORD dwItem);
        DWORD GetMergedPiercingItem(int nth);
        std::vector<DWORD> GetPiercingVec(){ return m_vPiercing; }
        void SetMergedPierceVec(std::vector<DWORD> wew){ m_vMergedPiercing = wew; }
private:
        std::vector<DWORD> m_vMergedPiercing;
#endif

---

wndgold.cpp

Spoiler:

Code:

---

#ifdef __WEAPON_MERGE
#include "randomoption.h"
#endif

---

Code:

---


#ifdef __WEAPON_MERGE

/*        Weapon Merge Main Window
 *        Window Id:        APP_WEAPONMERGE
 *        Controls:        WIDC_STATIC4        =        Weapon Output Render Target
 *                                WIDC_STATIC5        =        Weapon Output Stats Target
 *                                WIDC_PICTURE1        =        Weapon Input Picture Destination
 *                                WIDC_PICTURE2        =        Weapon Input Picture Source
 *                                WIDC_PICTURE3        =        Protection Scroll Input Picture OPTIONAL
 *                                //Buttons Start
 *                                WIDC_BUTTON1        =        Start Merge Process
 *                                WIDC_BUTTON2        =        Destroy
 *        Class:                CWndWeaponMerge
 *        Implementation by WurstbrotQT
 */
CWndWeaponMerge::CWndWeaponMerge()
{
        for (int i = 0; i < 3; ++i){ pItemElem[i] = NULL; }
        m_pDestModel = NULL;
        pButtonStart = NULL;
        m_nStatus = 0;
        m_nDelay = 25;
        m_fRotate = 0.0f;
        m_fAddRot = 2.0f;
        m_nEyeYPos = 0.0f;
        m_nCount = 0;
}

void CWndWeaponMerge::OnDestroy()
{
        Clear(true);
}

BOOL CWndWeaponMerge::Initialize(CWndBase *pWndParent, DWORD dwWndId)
{
        return CWndNeuz::InitDialog(g_Neuz.GetSafeHwnd(), APP_WEAPONMERGE, 0, CPoint(0,0), pWndParent);
}

void CWndWeaponMerge::OnInitialUpdate()
{
        CWndNeuz::OnInitialUpdate();

        wndCtrl[0] = GetWndCtrl(WIDC_PICTURE1);
        wndCtrl[1] = GetWndCtrl(WIDC_PICTURE2);
        wndCtrl[2] = GetWndCtrl(WIDC_PICTURE3);

        m_CtrlRenderWeapon = GetWndCtrl(WIDC_STATIC4);
        m_CtrlOutputStats = GetWndCtrl(WIDC_STATIC5);

        pButtonStart = (CWndButton*)GetDlgItem(WIDC_BUTTON1);
        pButtonStart->EnableWindow(TRUE);

        //m_editSwordOption.Init(m_pFont,&m_CtrlOutputStats->rect);
        MoveParentCenter();
}

int CWndWeaponMerge::RegisterWeapon(CItemElem *pItem, CItemElem *pOther)
{
        ItemProp* pItemProp = pItem->GetProp();
        if (g_pPlayer->m_vtInfo.IsTrading(pItem)){ return -2; }
        if (pItem->IsFlag(pItem->merged)){ return TID_MMI_TWOHANDEDWEAPONMERGE_ERRORTEXT01; }
        if (pItem->IsExpiring()){ return TID_MMI_TWOHANDEDWEAPONMERGE_ERRORTEXT02; }
        if (!pItemProp || pItemProp->dwHanded != HD_TWO){ return TID_MMI_TWOHANDEDWEAPONMERGE_ERRORTEXT03; }
        if (pItemProp->IsBaruna()){ return TID_MMI_TWOHANDEDWEAPONMERGE_ERRORTEXT04; }
        if( pOther )
        {
                ItemProp *pPropOther = pOther->GetProp();
                if (pPropOther){
                        if (pPropOther->dwItemKind3 != pItemProp->dwItemKind3){ return TID_MMI_TWOHANDEDWEAPONMERGE_ERRORTEXT05; }
                }
        }
        if (pItem->IsBinds()){ return TID_MMI_TWOHANDEDWEAPONMERGE_ERRORTEXT06; }
        if (g_xRandomOptionProperty->IsCheckedSafeFlag(pItem->GetRandomOptItemId())){ return TID_MMI_TWOHANDEDWEAPONMERGE_ERRORTEXT13; }
        return -1;
}

void CWndWeaponMerge::OnRButtonUp(UINT nFlags, CPoint point)
{
        for (int i = 0; i < 3; ++i)
        {
                if (wndCtrl[i]->rect.PtInRect(point) && pItemElem[i])
                {
                        pItemElem[i]->SetExtra(0);
                        pItemElem[i] = NULL;
                }
        }
        CWndNeuz::OnRButtonUp(nFlags, point);
}

bool CWndWeaponMerge::CompareItemLevel(ItemProp *pPropSource, ItemProp *pPropDest)
{
        return true;
}

BOOL CWndWeaponMerge::OnDropIcon(LPSHORTCUT pShortcut, CPoint point)
{
        CItemElem *pItem = NULL;
        pItem = (CItemElem*)g_pPlayer->GetItemId(pShortcut->m_dwId);
        if (!pItem){ return false; }
        if (g_pPlayer->m_vtInfo.IsTrading(pItem)){ return false; }

        for (int i = 0; i < 3; ++i)
        {
                if (wndCtrl[i]->rect.PtInRect(point))
                {
                        CItemElem* pOther = (i == 0 ? (pItemElem[1] ? pItemElem[1] : NULL) : (pItemElem[0] ? pItemElem[0] : NULL));
                        ItemProp *pItemProp = pItem->GetProp();
                        int nMsg = 0;
                        if (pItemProp && pItemProp->dwID == II_SYS_SYS_BX_MAGICGRINDSTONE){ nMsg = -1; }
                        else{ nMsg = RegisterWeapon(pItem, pOther); }
                        if (nMsg != -1){ g_WndMng.PutString(prj.GetText(nMsg), NULL, prj.GetTextColor(nMsg)); }

                        if (pItemElem[i] != NULL){ pItemElem[i]->SetExtra(0); SAFE_DELETE(pItemElem[i]); }
                        pItemElem[i] = pItem;
                        pItem->SetExtra(1);
                        return true;
                        /*if (i == 0)
                        {
                                if (m_pDestModel){ m_pDestModel->DeleteDeviceObjects(); SAFE_DELETE(m_pDestModel); }
                                m_pDestModel = (CModelObject*)prj.m_modelMng.LoadModel(g_Neuz.m_pd3dDevice, OT_ITEM, pItemElem[0]->m_dwItemId);
                                m_pDestModel->InitDeviceObjects(g_Neuz.GetDevice());
                        }*/
                        //WeaponMergeText(pItemElem[i], &m_editSwordOption, i);
                }
        }
        return CWndNeuz::OnDropIcon(pShortcut, point);
}

void CWndWeaponMerge::WeaponMergeText(CItemElem* pItemElem, CEditString* pEdit, int i)
{
}

void CWndWeaponMerge::OnMouseWndSurface(CPoint point)
{
        for (int i = 0; i < 3; ++i){
                if (wndCtrl[i]->rect.PtInRect(point) && pItemElem[i]){ PUT_TOOL_TIP(wndCtrl[i]->rect, point, pItemElem[i]);}
        }
        CWndNeuz::OnMouseWndSurface(point);
}

BOOL CWndWeaponMerge::Process()
{
        if (m_nStatus == 1)
        {
                if (m_nCount > m_nDelay)
                {
                        m_fAddRot += 4.0f;
                        if (m_nDelay < 10){ m_nEyeYPos -= 0.05f; }
                        m_nDelay -= 1;
                        if (m_nDelay < 0)
                        {
                                m_nStatus = 0;
                                m_nDelay = 25;
                                m_fRotate = 0.0f;
                                m_fAddRot = 2.0f;
                                m_nEyeYPos = 0.0f;

                                if (pItemElem[0] && pItemElem[1])
                                {
                                        if (pItemElem[2]){ g_DPlay.SendWeaponMerge(pItemElem[0]->m_dwObjId, pItemElem[1]->m_dwObjId, pItemElem[2]->m_dwObjId); }
                                        else{ g_DPlay.SendWeaponMerge(pItemElem[0]->m_dwObjId, pItemElem[1]->m_dwObjId, NULL_ID); }
                                }
                                for (int i = 0; i < 3; ++i)
                                {
                                        if (pItemElem[i]){ pItemElem[i]->SetExtra(0); pItemElem[i] = NULL; }
                                }
                        }
                        m_nCount = 0;
                }
                m_nCount++;
        }
        return true;
}

void CWndWeaponMerge::OnDraw(C2DRender *p2DRender)
{
        if (pItemElem[0] && pItemElem[1] && m_pDestModel)
        {
                LPDIRECT3DDEVICE9 pd3dDevice = p2DRender->m_pd3dDevice;
                pd3dDevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
                pd3dDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
                pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
                pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
                pd3dDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
                pd3dDevice->SetRenderState(D3DRS_AMBIENT, D3DCOLOR_ARGB(255, 255, 255, 255));

                pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
                pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
                pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
                pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);

                pd3dDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
                pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );               

                D3DVIEWPORT9 viewport;
                D3DXCOLOR color;
                D3DXMATRIXA16 matWorld; D3DXMATRIXA16 matScale; D3DXMATRIXA16 matRot; D3DXMATRIXA16 matTrans;
                D3DXMatrixIdentity(&matScale); D3DXMatrixIdentity(&matTrans); D3DXMatrixIdentity(&matWorld);

                D3DXVECTOR3 vEyePt(0.0f, 0.0f, 0.0f);
                D3DXVECTOR3 vLookatPt(0.0f, 0.0f, 0.0f);
                D3DXVECTOR3 vUpVec(0.0f, 1.0f, 0.0f);

                ItemProp* iProp[2];
                iProp[0] = pItemElem[0]->GetProp();
                iProp[1] = pItemElem[1]->GetProp();
                if (iProp[0]->dwItemKind3 == IK3_AXE || iProp[0]->dwItemKind3 == IK3_SWD)
                {
                        if (iProp[0]->dwHanded == HD_ONE)
                        {
                                vEyePt.x = 0.0f;
                                vEyePt.y = 3.0f;
                                vEyePt.z = 0.0f;
                                vLookatPt.x = 0.6f;
                                vLookatPt.y = -0.2f;
                                vLookatPt.z = 0.0f;
                        }
                        else if (iProp[0]->dwHanded == HD_TWO)
                        {
                                vEyePt.x = 1.0f;
                                vEyePt.y = 5.0f;
                                vEyePt.z = 0.0f;
                                vLookatPt.x = 1.2f;
                                vLookatPt.y = -0.2f;
                                vLookatPt.z = 0.0f;
                        }
                }
                else if (iProp[0]->dwItemKind3 == IK3_YOYO || iProp[0]->dwItemKind3 == IK3_KNUCKLEHAMMER || iProp[0]->dwItemKind3 == IK3_CROSSBOW || iProp[0]->dwItemKind3 == IK3_BOW)
                {
                        vEyePt.x = 0.0f;
                        vEyePt.y = 3.0f;
                        vEyePt.z = 0.0f;
                        vLookatPt.x = 0.01f;
                        vLookatPt.y = -0.2f;
                        vLookatPt.z = 0.0f;
                }
                else if (iProp[0]->dwItemKind3 == IK3_WAND)
                {
                        vEyePt.x = 0.0f;
                        vEyePt.y = 3.0f;
                        vEyePt.z = 0.0f;
                        vLookatPt.x = 0.4f;
                        vLookatPt.y = -0.2f;
                        vLookatPt.z = 0.0f;
                }
                else if (iProp[0]->dwItemKind3 == IK3_CHEERSTICK || iProp[0]->dwItemKind3 == IK3_STAFF)
                {
                        vEyePt.x = 0.0f;
                        vEyePt.y = 4.0f;
                        vEyePt.z = 0.0f;
                        vLookatPt.x = 0.01f;
                        vLookatPt.y = -0.2f;
                        vLookatPt.z = 0.0f;
                }

                if (m_nStatus == 1){ vEyePt.y += m_nEyeYPos; }
                D3DXMATRIXA16 matView;
                D3DXMatrixLookAtLH(&matView, &vEyePt, &vLookatPt, &vUpVec);
                pd3dDevice->SetTransform(D3DTS_VIEW, &matView);

                D3DXMATRIXA16 matProj;
                D3DXMatrixPerspectiveFovLH(&matProj, D3DX_PI / 4, 1.0f, 1.0f, 100.0f);
                pd3dDevice->SetTransform(D3DTS_PROJECTION, &matProj);

                m_fRotate += m_fAddRot;
                D3DXMatrixRotationX(&matRot, D3DXToRadian(m_fRotate));
                D3DXMatrixScaling(&matScale, 1.1f, 1.1f, 1.1f);

                viewport.X = p2DRender->m_ptOrigin.x + m_CtrlRenderWeapon->rect.left;
                viewport.Y = p2DRender->m_ptOrigin.y + m_CtrlRenderWeapon->rect.top;
                viewport.Width = m_CtrlRenderWeapon->rect.Width();
                viewport.Height = m_CtrlRenderWeapon->rect.Height();

                viewport.MinZ = 0.0f;
                viewport.MaxZ = 1.0f;
                pd3dDevice->SetViewport(&viewport);
                pd3dDevice->Clear(0, NULL, D3DCLEAR_ZBUFFER, 0xffa08080, 1.0f, 0);

                D3DXMatrixMultiply(&matWorld, &matWorld, &matScale);
                D3DXMatrixMultiply(&matWorld, &matWorld, &matRot);
                D3DXMatrixMultiply(&matWorld, &matWorld, &matTrans);
                pd3dDevice->SetTransform(D3DTS_WORLD, &matWorld);

                pd3dDevice->SetRenderState(D3DRS_FOGENABLE, FALSE);
                pd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE);

                ::SetLight(FALSE); ::SetFog(FALSE);
                SetDiffuse(1.0f, 1.0f, 1.0f);
                SetAmbient(1.0f, 1.0f, 1.0f);

                D3DXVECTOR4 vConst(1.0f, 1.0f, 1.0f, 1.0f);
                pd3dDevice->SetVertexShaderConstantF(95, (float*)&vConst, 1);
                ::SetTransformView(matView);
                ::SetTransformProj(matProj);

                m_pDestModel->Render(p2DRender->m_pd3dDevice, &matWorld);
                viewport.X = p2DRender->m_ptOrigin.x;
                viewport.Y = p2DRender->m_ptOrigin.y;
                viewport.Width = p2DRender->m_clipRect.Width();
                viewport.Height = p2DRender->m_clipRect.Height();
                viewport.MinZ = 0.0f;
                viewport.MaxZ = 1.0f;
                pd3dDevice->SetViewport(&viewport);
                pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
                pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
        }
        for (int i = 0; i < 3; ++i)
        {
                if (pItemElem[i])
                {
                        CTexture *pTex = pItemElem[i]->GetTexture();
                        if (pTex){ pTex->Render(p2DRender, wndCtrl[i]->rect.TopLeft()); }
                }

        }
        if (pItemElem[0] && pItemElem[1]){ p2DRender->TextOut_EditString(m_CtrlOutputStats->rect.left + 3, m_CtrlOutputStats->rect.top + 3, m_editSwordOption, 0, 0, 2); }
        CWndNeuz::OnDraw(p2DRender);
}

BOOL CWndWeaponMerge::OnCommand(UINT nID, DWORD dwMessage, CWndBase *pWndBase)
{
        if (pWndBase && pWndBase->GetWndId() == APP_MESSAGEBOX)
        {
                if (nID == IDYES)
                {
                        m_nStatus = 1;
                }
        }
        return true;
}

BOOL CWndWeaponMerge::OnChildNotify(UINT message, UINT nID, LRESULT *pLResult)
{
        switch (nID)
        {
        case WIDC_BUTTON1:
                if (pItemElem[0] && pItemElem[1])
                {
                        if (pItemElem[2])
                        {
                                m_nStatus = 1;
                        }
                        else
                        {
                                CWndConfirm *pConfirm = (CWndConfirm*)g_WndMng.GetWndBase(APP_MESSAGEBOX);
                                if (pConfirm){ SAFE_DELETE(pConfirm); }
                                pConfirm = new CWndConfirm();
                                pConfirm->SetText(TID_MMI_TWOHANDEDWEAPONMERGE_CONFIRM02);
                                pConfirm->Initialize(this);
                        }
                }
                break;
        case WIDC_BUTTON2: Destroy(); break;
        }
        return CWndNeuz::OnChildNotify(message, nID, pLResult);
}

void CWndWeaponMerge::Clear(bool bProt)
{
        for (int i = 0; i < 3; ++i)
        {
                if (pItemElem[i]){ pItemElem[i]->SetExtra(0); pItemElem[i] = NULL; }
        }
}

/*        Weapon Merge Cancel Window
 *        Window Id:        APP_WEAPONMERGE_CANCEL
 *        Controls:        WIDC_PICTURE1        =        Weapon Output Picture
 *                                WIDC_ST_PENYA02        =        Cost Static Control
 *                                WIDC_PC_DELAY        =        Gauge Time Left
 *                                //Buttons Start
 *                                WIDC_START                =        Finally Start the Process
 *                                WIDC_CANCEL                =        Destroy
 *        Class:                CWndWeaponMergeCancel
 *        Implementation by WurstbrotQT
 */

#define MS_DELAY_MERGE 3000

CWndWeaponMergeCancel::CWndWeaponMergeCancel()
{
        m_pItemElem = NULL;
        m_pStCost = NULL;
        m_pVBProcess = NULL;

        m_bRenderGauge = FALSE;
        m_clkEnd = 0;
        m_nStatus = 0;
        m_nCost = 0;
}


CWndWeaponMergeCancel::~CWndWeaponMergeCancel()
{
        Clear(true);
        if( m_pItemElem )
                m_pItemElem->SetExtra(0);
        m_pItemElem = NULL;

        DeleteDeviceObjects();


       
       
}
void CWndWeaponMergeCancel::OnDestroy()
{
        //Clear(true);
                if( m_pItemElem )
                m_pItemElem->SetExtra(0);
        m_pItemElem = NULL;
        if( m_pItemElem  )
                SAFE_DELETE( m_pItemElem );
        //DeleteDeviceObjects();
}
HRESULT CWndWeaponMergeCancel::RestoreDeviceObjects()
{
        CWndBase::RestoreDeviceObjects();
        if( !m_pVBProcess )
                m_pApp->m_pd3dDevice->CreateVertexBuffer( sizeof( TEXTUREVERTEX2 ) * 3 * 6, D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC, D3DFVF_TEXTUREVERTEX2, D3DPOOL_DEFAULT, &m_pVBProcess, NULL );

        m_TexGaugeProcess.SetInvalidate(m_pApp->m_pd3dDevice);
        return S_OK;
}
HRESULT CWndWeaponMergeCancel::InvalidateDeviceObjects()
{
        CWndBase::InvalidateDeviceObjects();
    SAFE_RELEASE( m_pVBProcess );
        m_TexGaugeProcess.Invalidate();
        return S_OK;
}
HRESULT CWndWeaponMergeCancel::DeleteDeviceObjects()
{
        CWndBase::DeleteDeviceObjects();
        return InvalidateDeviceObjects();
}
BOOL CWndWeaponMergeCancel::Initialize( CWndBase *pWndParent, DWORD dwWndId )
{
        return CWndNeuz::InitDialog( g_Neuz.GetSafeHwnd(), APP_WEAPONMERGE_CANCEL, 0, CPoint(0,0), pWndParent );
}

void CWndWeaponMergeCancel::OnInitialUpdate()
{
        CWndNeuz::OnInitialUpdate();
        RestoreDeviceObjects();

        m_pStCost = (CWndStatic*)GetDlgItem(WIDC_ST_PENYA02);
        m_pStart = (CWndButton*)GetDlgItem(WIDC_START);
        m_CtrlWeapon = GetWndCtrl(WIDC_PICTURE1);
        m_CtrlGauge = GetWndCtrl(WIDC_PC_DELAY);
        m_TexGaugeProcess.LoadTexture( g_Neuz.GetDevice(), MakePath(DIR_THEME,"BarSky.tga"), 0xffff00ff, TRUE );
        m_pStCost->SetTitle("0");
        m_pStart->EnableWindow(FALSE);

        CWndInventory* pWndInventory = (CWndInventory*)g_WndMng.CreateApplet(APP_INVENTORY);
        assert(pWndInventory != NULL);

#ifdef __TABBED_INV
        for( int i = 0; i < 4; ++i )
                pWndInventory->m_wndInvCtrl[i].SetDieFlag(TRUE);
#else
        pWndInventory->m_wndItemCtrl.SetDieFlag(TRUE);
#endif

        MoveParentCenter();
}

BOOL CWndWeaponMergeCancel::Process()
{
        if( m_nStatus == 1 )
        {
                if( clock() >= m_clkEnd )
                {
                        m_nStatus = 0;
                        if( m_pItemElem )
                        {
                                g_DPlay.SendWeaponMergeCancel(m_pItemElem->m_dwObjId);
                                m_pItemElem->SetExtra(0);
                                m_pItemElem = NULL;
                        }
                }
        }
        return TRUE;
}

void CWndWeaponMergeCancel::OnDraw( C2DRender *p2DRender )
{
        if( m_pItemElem )
        {
                CTexture *pTex = m_pItemElem->GetTexture();
                if( pTex )
                        pTex->Render(p2DRender, m_CtrlWeapon->rect.TopLeft());
        }
        if( m_nStatus != 0 )
        {
                float fPercent = 1.0f;
                if( m_nStatus == 1 )
                {
                        float fTimeDiff = (float)(m_clkEnd - clock());
                        fPercent = 1.0f - fTimeDiff / MS_DELAY_MERGE;
                }
               
                CRect rect, rectTemp;
                int nWidth = (int)(m_CtrlGauge->rect.Width() * fPercent);
                rect = m_CtrlGauge->rect;
                rectTemp = rect;
                rectTemp.right = rectTemp.left + nWidth;
                ClientToScreen( rectTemp );
                m_bRenderGauge = m_pTheme->MakeGaugeVertex( m_pApp->m_pd3dDevice, &rectTemp, 0xffffffff, m_pVBProcess, &m_TexGaugeProcess );
               
                if( m_bRenderGauge )
                        m_pTheme->RenderGauge( p2DRender->m_pd3dDevice, m_pVBProcess, &m_TexGaugeProcess );
        }
}

void CWndWeaponMergeCancel::OnMouseWndSurface(CPoint point)
{
        if( m_pItemElem && m_CtrlWeapon->rect.PtInRect(point) )
        {
                PUT_TOOL_TIP(m_CtrlWeapon->rect,point,m_pItemElem);
        }
        CWndNeuz::OnMouseWndSurface(point);
}

void CWndWeaponMergeCancel::CalcCancelCosts()
{
        m_nCost = 0;
        if (m_pItemElem->GetMergedPeirceSize() > 0)
                m_nCost += 100000 + 100000 * m_pItemElem->GetMergedPeirceSize();
        if( m_pItemElem->GetMergedDsts() > 0 )
                m_nCost += 100000;
        if( m_pItemElem->GetMergedWeaponATK() > 0 )
                m_nCost += 100000;
        CString str;
        str.Format("%d",m_nCost);
        m_pStCost->SetTitle(str);
}

BOOL CWndWeaponMergeCancel::OnDropIcon(LPSHORTCUT pShortcut, CPoint point)
{
        if( m_CtrlWeapon->rect.PtInRect(point) )
        {
                CItemElem *pItem = (CItemElem*)g_pPlayer->GetItemId(pShortcut->m_dwId);
                if( SetItem(pItem) )
                        return TRUE;
        }
        return CWndNeuz::OnDropIcon(pShortcut, point);
}

BOOL CWndWeaponMergeCancel::OnChildNotify( UINT message, UINT nID, LRESULT *pLResult )
{
        switch( nID )
        {
        case WIDC_START:
                {
                        if( m_pItemElem )
                        {
                                if( m_nStatus == 0 )
                                {
                                        if( m_nCost > g_pPlayer->GetGold() )
                                        {
                                                CString strAdd;
                                                strAdd.Format(prj.GetText(TID_MMI_TWOHANDEDWEAPONMERGE_ERRORTEXT12), m_nCost);
                                                return FALSE;
                                        }
                                        CWndConfirm *pConfirm = (CWndConfirm*)g_WndMng.GetWndBase(APP_MESSAGEBOX);
                                        if( pConfirm )
                                                SAFE_DELETE(pConfirm);
                                        pConfirm = new CWndConfirm();
                                        pConfirm->SetText(TID_MMI_TWOHANDEDWEAPONMERGE_CANCEL_CONFIRM);
                                        pConfirm->Initialize(this);
                                }
                        }
                        break;
                }
        case WIDC_CANCEL:
                {
                        Destroy();
                        break;
                }
        }
        return CWndNeuz::OnChildNotify(message,nID,pLResult);
}

BOOL CWndWeaponMergeCancel::OnCommand( UINT nID, DWORD dwMessage, CWndBase *pWndBase )
{
        if( pWndBase && pWndBase->GetWndId() == APP_MESSAGEBOX )
        {
                if( nID == IDYES )
                {
                        m_pStart->EnableWindow(FALSE);
                        m_clkEnd = clock() + MS_DELAY_MERGE;
                        m_nStatus = 1;
                }
        }
        return CWndNeuz::OnCommand( nID, dwMessage, pWndBase );
}

BOOL CWndWeaponMergeCancel::SetItem(CItemElem *pItem)
{
        if( pItem && pItem->isMerged() && !g_pPlayer->m_vtInfo.IsTrading(pItem) )
        {
                if( m_pItemElem )
                        m_pItemElem->SetExtra(0);
                m_pItemElem = pItem;
                m_pItemElem->SetExtra(1);
                m_pStart->EnableWindow();
                CalcCancelCosts();
                return TRUE;
        }
        return FALSE;
}
void CWndWeaponMergeCancel::Clear(bool bProt /* = false */)
{
        if( m_pItemDest )
                m_pItemDest->SetExtra(0);
        if( m_pItemSource )
                m_pItemSource->SetExtra(0);
        m_pItemDest = m_pItemSource = NULL;
        if( bProt )
        {
                if( m_pItemProt )
                        m_pItemProt->SetExtra(0);
                m_pItemProt = NULL;
        }
}

#endif

---

Wndgold.h

Spoiler:

Code:

---

#ifdef __WEAPON_MERGE

class CWndWeaponMerge : public CWndNeuz
{
private:
        LPWNDCTRL wndCtrl[3];
        LPWNDCTRL m_CtrlRenderWeapon;
        LPWNDCTRL m_CtrlOutputStats;
        CItemElem* pItemElem[3];
        CWndButton *pButtonStart;
        CModelObject *m_pDestModel;
        CEditString m_editSwordOption;
        //CWndConfirm *m_pWndConfirm;

        float m_fRotate;
        char m_nStatus;
        int m_nCount;
        int m_nDelay;
        float m_nEyeYPos;
        float m_fAddRot;
public:
        CWndWeaponMerge();
        virtual BOOL OnDropIcon(LPSHORTCUT pShortcut, CPoint point = 0);
        virtual BOOL OnChildNotify(UINT message, UINT nID, LRESULT *pLResult);
        virtual void OnInitialUpdate();
        virtual BOOL Initialize(CWndBase *pWndParent = 0, DWORD dwWndId = 0);
        virtual void OnDraw(C2DRender *p2DRender);
        virtual void OnMouseWndSurface(CPoint point);
        virtual void OnRButtonUp(UINT nFlags, CPoint point);
        virtual BOOL OnCommand(UINT nID, DWORD dwMessage, CWndBase *pWndBase = NULL );
        virtual BOOL Process();
        void WeaponMergeText(CItemElem* pItemElem, CEditString* pEdit, int i);

        virtual void OnDestroy();
private:
        int RegisterWeapon(CItemElem *pItem, CItemElem *pOther);
        bool CompareItemLevel(ItemProp *pPropSource, ItemProp *pPropDest);
        void Clear(bool bProt = false);
};

class CWndWeaponMergeCancel : public CWndNeuz
{
private:
        LPWNDCTRL m_CtrlWeapon;
        CWndStatic *m_pStCost;
        LPWNDCTRL m_CtrlGauge;
        CWndButton *m_pStart;
        CItemElem *m_pItemSource;
        CItemElem *m_pItemDest;
        CItemElem *m_pItemProt;
       
        CModelObject *m_pDestModel;

        CItemElem *m_pItemElem;

        CTexture m_TexGaugeProcess;
        LPDIRECT3DVERTEXBUFFER9 m_pVBProcess;

        char m_nStatus;
        int m_nCost;

        BOOL m_bRenderGauge;

        clock_t m_clkEnd;
public:
        CWndWeaponMergeCancel();
        virtual ~CWndWeaponMergeCancel();
        virtual void OnInitialUpdate(); //OK
        virtual BOOL Initialize(CWndBase *pWndParent = NULL, DWORD dwWndId = 0); //OK
        virtual BOOL Process(); //PACKET
        virtual void OnDestroy();
        virtual void OnDraw(C2DRender *p2DRender);
        virtual BOOL OnChildNotify(UINT message, UINT nID, LRESULT *pLResult);
        virtual BOOL OnDropIcon(LPSHORTCUT pShortcut, CPoint point = 0);
        virtual void OnMouseWndSurface(CPoint point);
        virtual BOOL OnCommand(UINT nID, DWORD dwMessage, CWndBase *pWndBase);
        virtual HRESULT RestoreDeviceObjects();
        virtual HRESULT DeleteDeviceObjects();
        virtual HRESULT InvalidateDeviceObjects();

        BOOL SetItem( CItemElem *pItem );
private:
        void CalcCancelCosts();
                void Clear(bool bProt = false);
};

#endif

---

item.cpp

Spoiler:

CItemElem::CItemElem

Code:

---

#ifdef __WEAPON_MERGE
        m_nMergedAtk = 0;
        m_nMergedDsts = 0;
#ifdef __5LAWAKES
        m_nMergedAdjs = 0;
#endif
#endif

---

CItemElem& CItemElem::operator =( CItemElem & ie )

Code:

---


#ifdef __WEAPON_MERGE
        m_nMergedAtk = ie.GetMergedWeaponATK();
        m_nMergedDsts = ie.GetMergedDsts();
#ifdef __5LAWAKES
        m_nMergedAdjs = ie.GetMergedAdjs();
#endif
#endif

---

Code:

---


#ifdef __WEAPON_MERGE
void CItemElem::GetMergedPiercingAvail(PPIERCINGAVAIL pPiercingAvail)
{
        for( int i = 0; i < GetMergedPeirceSize(); i++ )
        {
                PPIERCINGAVAIL ptr = CPiercingAvail::GetInstance()->GetPiercingAvail(GetMergedPierceItem(i));
                if (ptr)
                {
                        for (int j = 0; j < ptr->nSize; j++)
                        {
                                int nFind = -1;
                                for (int k = 0; k < pPiercingAvail->nSize; k++)
                                {
                                        if (pPiercingAvail->anDstParam[k] == ptr->anDstParam[j])
                                        {
                                                nFind = k;
                                                break;
                                        }
                                }
                                if (nFind < 0){ nFind = pPiercingAvail->nSize++; }
                                pPiercingAvail->anDstParam[nFind] = ptr->anDstParam[j];
                                pPiercingAvail->anAdjParam[nFind] += ptr->anAdjParam[j];
                        }
                }
        }
}
#endif

---

Item.h

Spoiler:

class CItemElem : public CItemBase

Code:

---


#ifdef __WEAPON_MERGE
private:
        int        m_nMergedAtk;
        __int64 m_nMergedDsts;
#ifdef __5LAWAKES
        __int64        m_nMergedAdjs;
#endif
public:
        bool isMerged(){ return (IsFlag(merged)); }
        void SetMergedWeaponATK(int nATK) { m_nMergedAtk = nATK; }
        int        GetMergedWeaponATK() { return m_nMergedAtk; }
        void SetMergedDsts(__int64 iID) { m_nMergedDsts = iID; }
        __int64 GetMergedDsts(){ return m_nMergedDsts; }
#ifdef __5LAWAKES
        __int64 GetMergedAdjs(){ return m_nMergedAdjs; }
        void SetMergedAdjs(__int64 nAdj){ m_nMergedAdjs = nAdj; }       
#endif

        void GetMergedPiercingAvail(PPIERCINGAVAIL pPiercingAvail);
        void SetMergedPierceSize(int i){ m_piercing.SetMergedPiercingSize(i); }
        void SetMergedPierceItem(int ati, DWORD nItem){ m_piercing.SetMergedPiercingItem(ati, nItem); }
        int GetMergedPeirceSize(){ return m_piercing.GetMergedPiercingSize(); }
        DWORD GetMergedPierceItem(int ati){ return m_piercing.GetMergedPiercingItem(ati); }

        std::vector<DWORD> GetPierceVector(){ return m_piercing.GetPiercingVec(); }
        void PiercetoMerged(std::vector<DWORD> wew){ m_piercing.SetMergedPierceVec(wew); }
#endif

---

Mover.cpp

Spoiler:

CMover::DestParamPiercingAvail( CItemElem* pItemElem, BOOL bSET )

Code:

---

#ifdef __WEAPON_MERGE
        if (pItemElem->isMerged())
        {
                memset(&piercingAvail, 0, sizeof(piercingAvail));
                pItemElem->GetMergedPiercingAvail(&piercingAvail);
                for (int i = 0; i < piercingAvail.nSize; ++i)
                {
                        if (bSET){ SetDestParam(piercingAvail.anDstParam[i], piercingAvail.anAdjParam[i], NULL_CHGPARAM); }
                        else{ ResetDestParam(piercingAvail.anDstParam[i], piercingAvail.anAdjParam[i], TRUE); }
                }
        }
#endif

---

CMover::SetDestParamRandomOptExtension( CItemElem* pItemElem )

Code:

---

#ifdef __WEAPON_MERGE
#ifdef __5LAWAKES
        cbOption = g_xRandomOptionProperty->GetDstSize(pItemElem->GetMergedDsts());
#else
        cbOption = g_xRandomOptionProperty->GetRandomOptionSize(pItemElem->GetMergedDsts());
#endif
        for (int i = 0; i < cbOption; ++i)
        {
                int nDst, nAdj;
#ifdef __5LAWAKES
                if (g_xRandomOptionProperty->GetDstAdj(pItemElem->GetMergedDsts(), pItemElem->GetMergedAdjs(), i, &nDst, &nAdj))
#else
                if (g_xRandomOptionProperty->GetParam(pItemElem->GetMergedDsts(), i, &nDst, &nAdj))
#endif
                        SetDestParam(nDst, nAdj, NULL_CHGPARAM);
        }
#endif

---

CMover::ResetDestParamRandomOptExtension( CItemElem* pItemElem )

Code:

---

#ifdef __WEAPON_MERGE
#ifdef __5LAWAKES
        cbOption = g_xRandomOptionProperty->GetDstSize(pItemElem->GetMergedDsts());
        for (int i = 0; i < cbOption; ++i)
        {
                int nDst, nAdj;
                if (g_xRandomOptionProperty->GetDstAdj(pItemElem->GetMergedDsts(), pItemElem->GetMergedAdjs(), i, &nDst, &nAdj))
                        ResetDestParam(nDst, nAdj, TRUE);
        }
#else
        cbOption = g_xRandomOptionProperty->GetRandomOptionSize(pItemElem->GetMergedDsts());
        for (int i = 0; i < cbOption; ++i)
        {
                int nDst, nAdj;
                if (g_xRandomOptionProperty->GetParam(pItemElem->GetMergedDsts(), i, &nDst, &nAdj))
                        ResetDestParam(nDst, nAdj, TRUE);
        }
#endif
#endif

---

Mover.h

Spoiler:

Code:

---

#ifdef __WEAPON_MERGE
#define UI_WEAPONMERGE_ATK 31
#define UI_WEAPONMERGE_PIES 32
#define UI_WEAPONMERGE_PIE 33
#define UI_WEAPONMERGE_DST 34
#ifdef __5LAWAKES
#define UI_WEAPONMERGE_ADJ 35
#endif
#endif

---

typedef struct _EQUIP_INFO_ADD

Code:

---

#ifdef __WEAPON_MERGE
        __int64 m_nMergedDsts;
#ifdef __5LAWAKES
        __int64 m_nMergedAdjs;
#endif
        int m_nMergedWeaponATK;
#endif

---

_EQUIP_INFO_ADD()

Code:

---

#ifdef __WEAPON_MERGE
                m_nMergedWeaponATK = 0;
                m_nMergedDsts = 0;
#ifdef __5LAWAKES
                m_nMergedAdjs = 0;
#endif
#endif

---

_EQUIP_INFO_ADD& operator=(const _EQUIP_INFO_ADD& e)

Code:

---

#ifdef __WEAPON_MERGE
                m_nMergedWeaponATK = e.m_nMergedWeaponATK;
                m_nMergedDsts = e.m_nMergedDsts;
#ifdef __5LAWAKES
                m_nMergedAdjs = e.m_nMergedAdjs;
#endif
#endif

---

MoverEquip.cpp

Spoiler:

SetDestParamEquip

Code:

---

#ifdef __WEAPON_MERGE
                if (pItemElem->isMerged()){ SetDestParam(DST_CHR_DMG, pItemElem->GetMergedWeaponATK(), NULL_CHGPARAM); }
#endif

---

ResetDestParamEquip

Code:

---

#ifdef __WEAPON_MERGE
                if (pItemElem->isMerged()){ ResetDestParam(DST_CHR_DMG, pItemElem->GetMergedWeaponATK()); }
#endif

---

CMover::UpdateItemEx

Code:

---

#ifdef __WEAPON_MERGE
                case UI_WEAPONMERGE_DST: pItemElem->SetMergedDsts(iValue); break;
#ifdef __5LAWAKES
                case UI_WEAPONMERGE_ADJ: pItemElem->SetMergedAdjs(iValue); break;
#endif
#endif

---

CMover::UpdateItem

Code:

---

#ifdef __WEAPON_MERGE
                case UI_WEAPONMERGE_ATK: ((CItemElem*)pItemBase)->SetMergedWeaponATK(dwValue); break;
                case UI_WEAPONMERGE_PIES: ((CItemElem*)pItemBase)->SetMergedPierceSize(dwValue); break;
                case UI_WEAPONMERGE_PIE:
                        {
                                WORD wIndex = LOWORD(dwValue), wItemId = HIWORD(dwValue);
                                ((CItemElem*)pItemBase)->SetMergedPierceItem(wIndex, wItemId);
                                break;
                        }
#endif

---

WndField.cpp

Spoiler:

CWndQueryEquip::OnMouseWndSurface

Code:

---

#ifdef __WEAPON_MERGE
                        itemElem.SetMergedWeaponATK(m_aEquipInfoAdd[i].m_nMergedWeaponATK);
                        itemElem.SetMergedDsts(m_aEquipInfoAdd[i].m_nMergedDsts);
#ifdef __5LAWAKES
                        itemElem.SetMergedAdjs(m_aEquipInfoAdd[i].m_nMergedAdjs);
#endif

---

CWndInventory::OnChildNotify

Code:

---


#ifdef __WEAPON_MERGE
                                        if (pWndBase = g_WndMng.GetWndBase(APP_WEAPONMERGE))
                                        {
                                                if (pFocusItem->GetExtra() < ((CItemElem*)pFocusItem)->m_nItemNum)
                                                {
                                                        CWndWeaponMerge* pMerge = (CWndWeaponMerge*)g_WndMng.GetWndBase(APP_WEAPONMERGE);
                                                        return TRUE;
                                                }
                                        }
                                        if (pWndBase = g_WndMng.GetWndBase(APP_WEAPONMERGE_CANCEL))
                                        {
                                                if (pFocusItem->GetExtra() < ((CItemElem*)pFocusItem)->m_nItemNum)
                                                {
                                                        CWndWeaponMergeCancel *pMerge = (CWndWeaponMergeCancel*)g_WndMng.GetWndBase(APP_WEAPONMERGE_CANCEL);
                                                        pMerge->SetItem((CItemElem*)pFocusItem);
                                                        return TRUE;
                                                }
                                        }
#endif

---

WndManager.cpp

Spoiler:

Code:

---

#ifdef __WEAPON_MERGE
void CWndMgr::PutWeaponMergeText(CItemElem* pItemElem, CEditString* pEdit)
{
        if (pItemElem->isMerged())
        {
                CString fnt;
                int nCount = 0;
                for (int j = 0; j < pItemElem->GetMergedPeirceSize(); ++j)
                {
                        if (pItemElem->GetMergedPierceItem(j) != 0)
                                nCount++;
                }

                fnt.Format("\nFusion:(%d/%d)\nBonus Attack: %d", nCount, pItemElem->GetMergedPeirceSize(), pItemElem->GetMergedWeaponATK());
                pEdit->AddString(fnt, 0xFF8B63C5, ESSTY_BOLD);
                fnt.Empty();

                PIERCINGAVAIL pa;
                memset(&pa, 0, sizeof(PIERCINGAVAIL));
                pItemElem->GetMergedPiercingAvail(&pa);
                for (int i = 0; i < pa.nSize; ++i)
                {
                        int nDst = (int)pa.anDstParam[i];
                        int nAdj = (int)pa.anAdjParam[i];

                        if (IsDst_Rate(nDst))
                        {
                                if (nDst == DST_ATTACKSPEED){ fnt.Format("\n%s%+d%%", FindDstString(nDst), nAdj / 2 / 10); }
                                else{ fnt.Format("\n%s%+d%%", FindDstString(nDst), nAdj); }
                        }
                        else{ fnt.Format("\n%s+%d", FindDstString(nDst), nAdj); }
                        pEdit->AddString(fnt, dwItemColor[g_Option.m_nToolTipText].dwPiercing);
                }
                fnt.Empty();
#ifdef __5LAWAKES
                byte nSize = g_xRandomOptionProperty->GetDstSize(pItemElem->GetMergedDsts());
#else
                byte nSize = g_xRandomOptionProperty->GetRandomOptionSize(pItemElem->GetMergedDsts());
#endif
                for (int i = 0; i < nSize; ++i)
                {
                        int nDst, nAdj;
#ifdef __5LAWAKES
                        if (!g_xRandomOptionProperty->GetDstAdj(pItemElem->GetMergedDsts(), pItemElem->GetMergedAdjs(), i, &nDst, &nAdj))
#else
                        if (!g_xRandomOptionProperty->GetParam(pItemElem->GetRandomOptItemId(), i, &nDst, &nAdj))
#endif
                                continue;

                        if (IsDst_Rate(nDst))
                        {
                                if (nDst == DST_ATTACKSPEED){ fnt.Format("\n%s %c%d%% ", FindDstString(nDst), (nAdj > 0 ? '+' : '-'), ::abs(nAdj / 2 / 10)); }
                                else{ fnt.Format("\n%s%+d%%", FindDstString(nDst), nAdj); }
                        }
                        else{ fnt.Format("\n%s+%d", FindDstString(nDst), nAdj); }
                        pEdit->AddString(fnt, dwItemColor[g_Option.m_nToolTipText].dwAwakening);
                }
        }
}

#endif

---

PutToolTip_Item

Code:

---

#ifdef __WEAPON_MERGE
        PutWeaponMergeText(pItemElem, &strEdit);
#endif

---

MakeToolTipText

Code:

---

#ifdef __WEAPON_MERGE
        PutWeaponMergeText(pItemElem, &strEdit);
#endif

---

WndManager.h in CWndMgr class

Code:

---

#ifdef __WEAPON_MERGE
        void PutWeaponMergeText(CItemElem* pItemElem, CEditString* pEdit);
#endif

---

DpClient.cpp

Spoiler:

CDPClient::OnQueryEquip

Code:

---

#ifdef __WEAPON_MERGE
                ar >> aEquipInfoAdd[nParts].m_nMergedWeaponATK;
                ar >> aEquipInfoAdd[nParts].m_nMergedDsts;
#ifdef __5LAWAKES
                ar >> aEquipInfoAdd[nParts].m_nMergedAdjs;
#endif
#endif

---

Code:

---

#ifdef __WEAPON_MERGE
void CDPClient::SendWeaponMerge(DWORD dwidfirst, DWORD dwidsecond, DWORD dwIdProt)
{
        BEFORESENDSOLE(ar, PACKETTYPE_WEAPONMERGE, DPID_UNKNOWN);
        ar << dwidfirst << dwidsecond << dwIdProt;
        SEND(ar, this, DPID_SERVERPLAYER);
}
void CDPClient::SendWeaponMergeCancel(DWORD dwIdItem)
{
        BEFORESENDSOLE(ar, PACKETTYPE_WEAPONMERGE_CANCEL, DPID_UNKNOWN);
        ar << dwIdItem;
        SEND(ar, this, DPID_SERVERPLAYER);
}
#endif

---

dpClient.h

Code:

---

#ifdef __WEAPON_MERGE
        void SendWeaponMerge(DWORD dwidfirst, DWORD dwidsecond, DWORD dwIdProt);
        void SendWeaponMergeCancel(DWORD dwIdItem);
#endif

---

dpSrvr

Spoiler:

dpSrvr.h

Code:

---

#ifdef __WEAPON_MERGE
        void OnWeaponMerge(CAr & ar, DPID dpidCache, DPID dpidUser, LPBYTE, u_long);
        void OnWeaponMergeCancel(CAr & ar, DPID dpidCache, DPID dpidUser, LPBYTE, u_long);
#endif

---

DpSrvr::CDPSrvr()

Code:

---

#ifdef __WEAPON_MERGE
        ON_MSG(PACKETTYPE_WEAPONMERGE, &CDPSrvr::OnWeaponMerge);
        ON_MSG(PACKETTYPE_WEAPONMERGE_CANCEL, &CDPSrvr::OnWeaponMergeCancel);
#endif

---

Code:

---

#ifdef __WEAPON_MERGE
void CDPSrvr::OnWeaponMerge(CAr & ar, DPID dpidCache, DPID dpidUser, LPBYTE, u_long)
{
        CUser *pUser = g_UserMng.GetUser(dpidCache, dpidUser);
        if (IsInvalidObj(pUser)){ return; }

        DWORD dwIdSource, dwIdDest, dwIdProt;
        ar >> dwIdSource >> dwIdDest >> dwIdProt;
        if (dwIdSource == dwIdDest){ Error("Hack Attempt : Same item Weapon Merge"); return; }
        CItemElem *pItemSource = pUser->m_Inventory.GetAtId(dwIdSource), *pItemDest = pUser->m_Inventory.GetAtId(dwIdDest),
                *pItemProt = pUser->m_Inventory.GetAtId(dwIdProt);
        if (pItemSource == NULL || pItemDest == NULL){ return; } //invalid / no item
        ItemProp *pPropSource = pItemSource->GetProp(), *pPropDest = pItemDest->GetProp(),
                *pPropProt = (pItemProt != NULL) ? pItemProt->GetProp() : NULL;
        if (pPropSource == NULL || pPropDest == NULL){ return; }
        if (!IsUsableItem(pItemSource) || !IsUsableItem(pItemDest)){ return; }
        if (pUser->m_vtInfo.IsTrading(pItemSource) || pUser->m_vtInfo.IsTrading(pItemDest)){ return; }
        if (pItemSource->isMerged() || pItemDest->isMerged())
        {
                pUser->AddDefinedText(TID_MMI_TWOHANDEDWEAPONMERGE_ERRORTEXT01);
                return;
        }
        if (pPropSource->dwHanded != HD_TWO || pPropDest->dwHanded != HD_TWO)
        {
                pUser->AddDefinedText(TID_MMI_TWOHANDEDWEAPONMERGE_ERRORTEXT03);
                return;
        }
        if (pPropSource->IsBaruna() || pPropDest->IsBaruna())
        {
                pUser->AddDefinedText(TID_MMI_TWOHANDEDWEAPONMERGE_ERRORTEXT04);
                return;
        }
        if (pPropSource->dwItemKind3 != pPropDest->dwItemKind3)
        {
                pUser->AddDefinedText(TID_MMI_TWOHANDEDWEAPONMERGE_ERRORTEXT05);
                return;
        }

        bool bProt = false;
        if (pPropProt != NULL)
        {
                if (IsUsableItem(pItemProt) && pPropProt->dwID == II_SYS_SYS_BX_MAGICGRINDSTONE && !(pUser->m_vtInfo.IsTrading(pItemProt)))
                {
                        bProt = true;
                        pUser->RemoveItem((BYTE)pItemProt->m_dwObjId, 1);
                }
        }

        if (xRandom(5000) >= 0)
        {
                //pItemSource->SetMergedDsts(pItemDest->GetRandomOptItemId());
                pUser->UpdateItemEx((BYTE)(pItemSource->m_dwObjId), UI_WEAPONMERGE_DST, pItemDest->GetRandomOptItemId());
#ifdef __5LAWAKES
                //pItemSource->SetMergedAdjs(pItemDest->GetnAdjItemId());
                pUser->UpdateItemEx((BYTE)(pItemSource->m_dwObjId), UI_WEAPONMERGE_ADJ, pItemDest->GetnAdjItemId());
#endif
                //pItemSource->SetMergedPierceSize(pItemDest->GetPiercingSize());
                pUser->UpdateItem((BYTE)(pItemSource->m_dwObjId), UI_WEAPONMERGE_PIES, pItemDest->GetPiercingSize());
                for (int i = 0; i < pItemDest->GetPiercingSize(); ++i)
                {
                        pItemSource->SetMergedPierceItem(i,pItemDest->GetPiercingItem(i));
                        pUser->UpdateItem((BYTE)(pItemSource->m_dwObjId), UI_WEAPONMERGE_PIE, MAKELONG(i, pItemDest->GetPiercingItem(i)));
                }

                float fFactor = 0.08f + ( 0.04f * (pItemDest->GetAbilityOption() + 1));
                int ability = xRandom(pPropDest->dwAbilityMin, pPropDest->dwAbilityMax);
                pUser->UpdateItem((BYTE)pItemSource->m_dwObjId, UI_WEAPONMERGE_ATK, (ability * fFactor));
               
                pItemSource->SetFlag(CItemElem::merged);

                pUser->RemoveItem((BYTE)pItemDest->m_dwObjId, 1);
                pUser->AddDefinedText(TID_MMI_TWOHANDEDWEAPONMERGE_SUCCESSTEXT01);
        }
        else
        {
                if (bProt){ pUser->AddDefinedText(TID_MMI_TWOHANDEDWEAPONMERGE_FAILTEXT02); }
                else
                {
                        pUser->AddDefinedText(TID_MMI_TWOHANDEDWEAPONMERGE_FAILTEXT01, pItemSource->GetName());
                        pUser->RemoveItem((BYTE)pItemSource->m_dwObjId, 1);
                }
        }
}

void CDPSrvr::OnWeaponMergeCancel(CAr &ar, DPID dpidCache, DPID dpidUser, LPBYTE, u_long)
{
        CUser *pUser = g_UserMng.GetUser(dpidCache, dpidUser);
        if (IsInvalidObj(pUser)){ return;}

        DWORD dwIdItem; ar >> dwIdItem;
        CItemElem *pItem = pUser->m_Inventory.GetAtId(dwIdItem);

        if (!IsUsableItem(pItem)){ return;}
        if (pUser->m_vtInfo.IsTrading(pItem)){ return;}
        if (!pItem->isMerged()){ return; }

        int nCost = 10000;
        if (pItem->GetMergedPeirceSize() > 0){ nCost += 100000 * pItem->GetMergedPeirceSize();}
        if (pItem->GetMergedDsts() > 0){ nCost += 100000 * g_xRandomOptionProperty->GetDstSize(pItem->GetMergedDsts());}
        if (pItem->GetMergedWeaponATK() > 0){ nCost += 100000;}

        if (pUser->GetGold() < nCost)
        {
                pUser->AddDefinedText(TID_MMI_TWOHANDEDWEAPONMERGE_ERRORTEXT12, "%d", nCost);
                return;
        }
        pUser->AddGold(-nCost);

        pUser->UpdateItem((BYTE)(pItem->m_dwObjId), UI_WEAPONMERGE_ATK, 0);
        pUser->UpdateItem((BYTE)(pItem->m_dwObjId), UI_WEAPONMERGE_PIES, 0);
        pUser->UpdateItem((BYTE)(pItem->m_dwObjId), UI_WEAPONMERGE_PIE, 0);
        pUser->UpdateItemEx((BYTE)(pItem->m_dwObjId), UI_WEAPONMERGE_DST, 0);
#ifdef __5LAWAKES
        pUser->UpdateItemEx((BYTE)(pItem->m_dwObjId), UI_WEAPONMERGE_ADJ, 0);
#endif
        pItem->ResetFlag(CItemElem::merged);
        pUser->UpdateItem((BYTE)(pItem->m_dwObjId), UI_FLAG, MAKELONG(pItem->m_dwObjIndex, pItem->m_byFlag));
        pUser->AddDefinedText(TID_MMI_TWOHANDEDWEAPONMERGE_SUCCESSTEXT02);
}
#endif

---

user.cpp

Spoiler:

AddQueryEquip

Code:

---

#ifdef __WEAPON_MERGE
                        m_Snapshot.ar << pItemElem->GetMergedWeaponATK();
                        m_Snapshot.ar << pItemElem->GetMergedDsts();
#ifdef __5LAWAKES
                        m_Snapshot.ar << pItemElem->GetMergedAdjs();
#endif
#endif

---

functextcmd

Spoiler:

Code:

---


#ifdef __WEAPON_MERGE
bool TextCmd_WeaponMerge(CScanner &s)
{
#ifdef __WORLDSERVER
        CUser* pUser = (CUser*)s.dwValue;
        if (IsValidObj(pUser))
        {
                CItemElem* pItemElem = pUser->m_Inventory.GetAt(0);
                if (pItemElem == NULL){
                        pUser->AddText("Missing Item in First slot"); return false;
                }
                int nOption = 0;
                nOption = s.GetNumber();
                if (nOption == 1){ pItemElem->SetFlag(CItemElem::merged); }
                else if (nOption == 2) //attack
                {
                        int nAttack = s.GetNumber();
                        pItemElem->SetMergedWeaponATK(nAttack);
                        pUser->UpdateItem((BYTE)(pItemElem->m_dwObjId), UI_WEAPONMERGE_ATK, pItemElem->GetMergedWeaponATK());
                        pUser->AddText("Weapon Merge Attack set");
                }
                else if (nOption == 3) //awake
                {
                        int nRandomOptionKind = g_xRandomOptionProperty->GetRandomOptionKind(pItemElem);
                        if (nRandomOptionKind >= 0)
                        {
                                pItemElem->SetMergedDsts(0);
                                pItemElem->SetMergedAdjs(0);
                                __int64 DstSet = 0, AdjSet = 0;

                                byte nDst = 0; short nAdj = 0; byte nLoop = 0;
                                nDst = s.GetNumber();
                                while (s.tok != FINISHED)
                                {
                                        nAdj = s.GetNumber();
                                        if (nDst < 0 || nDst > MAX_ADJPARAMARY){ pUser->AddText("You went over or under the required Dst amount"); break; }
                                        if (nAdj < -512 || nAdj > 512){ pUser->AddText("Max Adj = 512, Min adj = -512. Stop overflowing you hoe"); break; }
                                        g_xRandomOptionProperty->SetDsts(&DstSet, nLoop, nDst);
                                        g_xRandomOptionProperty->SetAdjs(&AdjSet, nLoop, nAdj);

                                        nLoop++;
                                        if (nLoop >= 5){ break; }
                                        nDst = s.GetNumber();
                                }
                                pItemElem->SetMergedDsts(DstSet);
                                pItemElem->SetMergedAdjs(AdjSet);
                                pUser->UpdateItemEx((BYTE)(pItemElem->m_dwObjId), UI_WEAPONMERGE_ADJ, pItemElem->GetMergedAdjs());
                                pUser->UpdateItemEx((BYTE)(pItemElem->m_dwObjId), UI_WEAPONMERGE_DST, pItemElem->GetMergedDsts());
                                pUser->AddText("Merged Awakening set!");
                        }
                }
                else if (nOption == 4) //Piercing size
                {
                        int nValue = 0;
                        nValue = s.GetNumber();
                        if (nValue >= 0 || nValue < 11)
                        {
                                pItemElem->SetMergedPierceSize(nValue);
                                pUser->UpdateItem((BYTE)(pItemElem->m_dwObjId), UI_WEAPONMERGE_PIES, pItemElem->GetMergedPeirceSize());
                        }
                }
                else if (nOption == 5) // Piercing item
                {
                        s.GetToken();
                        if (s.Token == _T("fill"))
                        {
                                s.GetToken();
                                ItemProp* pProp = NULL;

                                if (s.tokenType == NUMBER)
                                        pProp = prj.GetItemProp(_ttoi(s.Token));
                                else
                                        pProp = prj.GetItemProp(s.Token);

                                if (pProp->dwItemKind3 == IK3_SOCKETCARD2)
                                {
                                        for (int i = 0; i < pItemElem->GetMergedPeirceSize(); ++i)
                                        {
                                                pItemElem->SetMergedPierceItem(i, pProp->dwID);
                                                pUser->UpdateItem((BYTE)(pItemElem->m_dwObjId), UI_WEAPONMERGE_PIE, MAKELONG(i, pItemElem->GetMergedPierceItem(i)));
                                        }
                                }
                        }
                        else if (s.Token == _T("at"))
                        {
                                int ati = 0;
                                ati = s.GetNumber();
                                s.GetToken();
                                ItemProp* pProp = NULL;
                                if (s.tokenType == NUMBER)
                                        pProp = prj.GetItemProp(_ttoi(s.Token));
                                else
                                        pProp = prj.GetItemProp(s.Token);

                                if (pProp->dwItemKind3 == IK3_SOCKETCARD2)
                                {
                                        if (ati > pItemElem->GetMergedPeirceSize() && ati < 11)
                                        {
                                                pItemElem->SetMergedPierceSize(ati);
                                                pUser->UpdateItem((BYTE)(pItemElem->m_dwObjId), UI_WEAPONMERGE_PIES, pItemElem->GetMergedPeirceSize());
                                        }
                                        pItemElem->SetMergedPierceItem(ati, pProp->dwID);
                                        pUser->UpdateItem((BYTE)(pItemElem->m_dwObjId), UI_WEAPONMERGE_PIE, MAKELONG(ati, pProp->dwID));
                                }
                        }
                }
                else
                {
                        pUser->AddText("*Weapon Merge Help*"); //Help
                        pUser->AddText("1: This option will make your wepaon 'merged'");
                        pUser->AddText("2: This option will allow you to edit the bonus attack IE: /wms 1 50");
                        pUser->AddText("3: This Option will edit the bonus awakening IE: /wms 2 77 9 77 9");
                        pUser->AddText("4: This option will edit the size of piercing IE: /wms 3 10");
                        pUser->AddText("5: This option will add the card. use at or fill. /wms 4 fill FireCardA");
                }
        }
#endif
        return true;
}
#endif

---

hi i would like to ask if it is possible to make weapon merge system so i can register a one handed weapon aswell (for only IK3_WAND & IK3_KNUCKLEHAMMER)? i'd appreciate if someone could show me what to change! i'm currently trying myself ill update this post . . . thanks in advance!