Re: Weapon Merge problems...
Havent touched this in ages since I won't be using it, lol.
MsgHdr.h
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
Re: Weapon Merge problems...
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!