Weapon Merge problems...

[chicorafael]

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

 

[Fenris]

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

MsgHdr.h

Spoiler

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

DbManagerfun.cpp

Spoiler

CDbManager::LoadPiercingInfo

#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

#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

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

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

#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()

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

CItemElem& CItemElem:perator =( CItemElem & ie )

#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

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

#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 )

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

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

Piercing.cpp

Spoiler

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

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

CPiercing::Clear

#ifdef __WEAPON_MERGE
	m_vMergedPiercing.clear();
#endif

CPiercing::Serialize

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

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

#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

#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

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

#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

#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

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

CItemElem& CItemElem:perator =( CItemElem & ie )

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

#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

#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:estParamPiercingAvail( CItemElem* pItemElem, BOOL bSET )

#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 )

#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 )

#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

#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

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

_EQUIP_INFO_ADD()

#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)

#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

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

ResetDestParamEquip

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

CMover::UpdateItemEx

#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

#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

#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

#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

#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

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

MakeToolTipText

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

WndManager.h in CWndMgr class

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

DpClient.cpp

Spoiler

CDPClient::OnQueryEquip

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

#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

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

dpSrvr

Spoiler

dpSrvr.h

#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()

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

#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

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

functextcmd

Spoiler

#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

 

[69BOLT69]

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!