mugongdialog.cpp

墨香最新私服

// MugongDialog.cpp: implementation of the CMugongDialog class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MugongDialog.h"
#include "MugongManager.h"

#include "WindowIDEnum.h"
#include "./Interface/cIconGridDialog.h"
#include "ItemManager.h"
#include "GameIn.h"
#include "InventoryExDialog.h"
#include "input/UserInput.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CMugongDialog::CMugongDialog()
{
	m_type = WT_MUGONGDIALOG;
	m_pTempDeleteMugong = NULL;
}

CMugongDialog::~CMugongDialog()
{
	DeleteIconAll();
}

void CMugongDialog::Linking()
{
	m_pMugongRect[MUGONGWINDOW_NORMAL].Init(MUGONGTYPE_NORMAL,
//		MUGONG_WEAREDPOSITION,MUGONG_STARTPOSITION,MUGONG_ENDPOSITION,
		TP_MUGONG_START,TP_MUGONG_END,
		this,
		MGI_MUGONG_WEAR,
		MGI_MUGONG_GRID,
		MGI_MUGONG_NAME_STATIC,
		MGI_MUGONG_LEVEL_STATIC,
		MGI_MUGONG_EXP_STATIC,
		MGI_MUGONG_EXP_GUAGE);
			
	((cIconDialog*)GetWindowForID(MGI_MUGONG_WEAR))->SetDragOverIconType( WT_MUGONG );
	((cIconGridDialog*)GetWindowForID(MGI_MUGONG_GRID))->SetDragOverIconType( WT_MUGONG );

	m_pMugongRect[MUGONGWINDOW_JINBUB].Init(MUGONGTYPE_JINBUB,
//		JINBUB_WEAREDPOSITION,JINBUB_STARTPOSITION,JINBUB_ENDPOSITION,
		TP_JINBUB_START,TP_JINBUB_END,
		this,
		MGI_JINBUB_WEAR,
		MGI_JINBUB_GRID,
		MGI_JINBUB_NAME_STATIC,
		MGI_JINBUB_LEVEL_STATIC,
		MGI_JINBUB_EXP_STATIC,
		MGI_JINBUB_EXP_GUAGE);

	((cIconDialog*)GetWindowForID(MGI_JINBUB_WEAR))->SetDragOverIconType( WT_JINBUB );
	((cIconGridDialog*)GetWindowForID(MGI_JINBUB_GRID))->SetDragOverIconType( WT_JINBUB );
}

void CMugongDialog::Init(LONG x, LONG y, WORD wid, WORD hei, cImage * basicImage, LONG ID)
{
	cIconDialog::Init(x,y,wid,hei,basicImage,ID);
	m_type = WT_MUGONGDIALOG;
}

void CMugongDialog::SetActive(BOOL val)
{
	if( m_bDisable ) return;

	cDialog::SetActiveRecursive(val);
}

void CMugongDialog::Add(cWindow * window)
{

	cDialog::Add(window);
}

BOOL CMugongDialog::GetBlankPositionRef(BYTE type, WORD & absPos)
{
	MLOC loc = MUGONGWINDOW_MAX;
	switch(type)
	{
	case eMUGONGBOOK:	loc = MUGONGWINDOW_NORMAL;	break;
	case eJINBUBBOOK:	loc = MUGONGWINDOW_JINBUB;	break;
	}
	if(loc == MUGONGWINDOW_MAX)
	{
		ASSERT(0);
		return FALSE;
	}

	return m_pMugongRect[loc].GetBlankPositionRef(absPos);
}

void CMugongDialog::AddMugong(MUGONGBASE * mugongBase)
{
	if(mugongBase->dwDBIdx > 0)
	{
		if(IsAddMugong(mugongBase->Position))
		{
			CMugongBase * mugong = MUGONGMGR->NewMugongIcon(mugongBase);
						
			AddMugong(mugongBase->Position, mugong);
		}
	}
}

BOOL CMugongDialog::IsAddMugong(POSTYPE pos)
{
	MLOC wloc = GetWindowLocate(pos);
	switch(wloc)
	{
	case MUGONGWINDOW_NORMAL:
	case MUGONGWINDOW_JINBUB:
		{
			return m_pMugongRect[wloc].IaAddable(pos);
		}
		break;
	default:
		ASSERT(0);
	}

	return FALSE;
}

void CMugongDialog::AddMugong(POSTYPE pos/*abs pos*/, CMugongBase * mugong)
{
	ASSERT(mugong);
	
	MLOC loc = GetWindowLocate(pos);
	switch(loc)
	{
	case MUGONGWINDOW_NORMAL:
	case MUGONGWINDOW_JINBUB:
		{
			m_pMugongRect[loc].AddMugong(pos,mugong);
		}
		break;
	default:
		ASSERT(0);
	}
}

MLOC CMugongDialog::GetWindowLocate(POSTYPE abs_pos/*abs pos*/)
{
//	if(MUGONG_WEAREDPOSITION <= abs_pos && abs_pos < MUGONG_ENDPOSITION)
	if(TP_MUGONG_START <= abs_pos && abs_pos < TP_MUGONG_END)
	{
		return MUGONGWINDOW_NORMAL;
	}
//	else if(JINBUB_WEAREDPOSITION <= abs_pos && abs_pos < JINBUB_ENDPOSITION)
	else if(TP_JINBUB_START <= abs_pos && abs_pos < TP_JINBUB_END)
	{
		return MUGONGWINDOW_JINBUB;
	}
	
	return MUGONGWINDOW_MAX;
}
BOOL CMugongDialog::DeleteMugong(POSTYPE pos/*abs pos*/, CMugongBase ** mugong)
{
	ASSERT(mugong);
	
	MLOC loc = GetWindowLocate(pos);
	switch(loc)
	{
	case MUGONGWINDOW_NORMAL:
	case MUGONGWINDOW_JINBUB:
		{
			return m_pMugongRect[loc].DeleteMugong(pos,mugong);
		}
		break;
	default:
		ASSERT(0);
	}
	return FALSE;
}
BOOL CMugongDialog::FakeMoveIcon(LONG mouseX, LONG mouseY, cIcon * icon)
{
	ASSERT(icon);

	if(icon->GetType() == WT_ITEM)
		FakeAddItem(mouseX, mouseY, (CItem *)icon);
	else if(icon->GetType() == WT_MUGONG || icon->GetType() == WT_JINBUB )
		return FakeMoveMugong(mouseX, mouseY, (CMugongBase *)icon);

	return FALSE;
}

void CMugongDialog::FakeAddItem(LONG mouseX, LONG mouseY, CItem * pItem)
{
	// 绢恫 公傍氓捞衬?公傍, 郴傍, 版傍
	if((pItem->GetItemKind() & eMUGONG_ITEM) == FALSE)
		return;
	BYTE type = GetItemKindDetail(pItem->GetItemIdx());
	switch(type)
	{
	case eMUGONGBOOK:
	case eJINBUBBOOK:
		break;
	default:
		return;
	}

	WORD ToPos=0;
	if(!GetPositionForXYRef(mouseX,mouseY, ToPos))		// 例措困摹 逞绢 咳
	{
		 if(!GetBlankPositionRef(type, ToPos))
			 return;
	}

	// 函券 啊瓷茄啊?? 炼扒,力茄 眉农, 饭骇, 流诀, 己??
	if(!CanBeMoved(pItem, ToPos))
		return;

	GAMEIN->GetInventoryDialog()->UseItem(pItem);
}
BOOL CMugongDialog::FakeMoveMugong(LONG mouseX, LONG mouseY, CMugongBase * icon)
{
	WORD ToPos=0;
	if(!GetPositionForXYRef(mouseX,mouseY, ToPos))		// 例措困摹 逞绢 咳
		return FALSE;

	if(!CanBeMoved(icon, ToPos))
		return FALSE;

	// 公傍,郴傍,版傍
	CMugongBase * pMugong = (CMugongBase *)icon;
	//------------------------------------
	MSG_MUGONG_MOVE_SYN msg;
	msg.Category = MP_MUGONG;
	msg.Protocol = MP_MUGONG_MOVE_SYN;
	msg.dwObjectID = HEROID;
	//------------------------------------
	msg.FromPos = pMugong->GetPosition();
	msg.ToPos = ToPos;

	if( msg.FromPos == msg.ToPos )
		return FALSE;
/*
	msg.dwMugongDBIdx	= pMugong->GetDBIdx();
	msg.wToPosition		= ToPos;									//例措 困摹肺 back
	msg.wFromPosition	= pMugong->GetPosition();					//例措 困摹肺 back
	
	if(msg.wFromPosition == msg.wToPosition)
		return ;
*/
	ASSERT(ToPos != 0);
	NETWORK->Send(&msg,sizeof(msg));
	SetDisable(TRUE);

	return TRUE;
}

void CMugongDialog::MoveMugong(POSTYPE ToPos/*abs pos*/, POSTYPE FromPos/*abs pos*/)
{
	CMugongBase * FromMugong = NULL;
	CMugongBase * ToMugong = NULL;
	DeleteMugong(FromPos, &FromMugong);
	DeleteMugong(ToPos, &ToMugong);

	if(FromMugong)
	{
		FromMugong->SetPosition(ToPos);
		AddMugong(ToPos, FromMugong);
	}
	
	if(ToMugong)
	{
		ToMugong->SetPosition(FromPos);
		AddMugong(FromPos, ToMugong);
	}
}

BOOL CMugongDialog::GetPositionForXYRef(LONG x, LONG y, POSTYPE& pos)
{
	WORD position=0;
	for(int n=0;n<MUGONGWINDOW_MAX;++n)
	{
		if(m_pMugongRect[n].GetPositionForXYRef(x,y,pos) == TRUE)
			return TRUE;
	}
	
	return FALSE;
}

/*
void CMugongDialog::FakeDeleteMugong(POSTYPE absPos)
{
	m_TempDeleteMugong = absPos;
}
*/

void CMugongDialog::FakeDeleteMugong(CMugongBase* pMugong)
{
	m_pTempDeleteMugong = pMugong;
}

void CMugongDialog::SendDeleteMugong()
{	
	if( m_pTempDeleteMugong == NULL ) return;

	MSG_MUGONG_REM_SYN msg;
	msg.Category = MP_MUGONG;
	msg.Protocol = MP_MUGONG_REM_SYN;
	msg.dwObjectID = HEROID;
	msg.TargetPos = m_pTempDeleteMugong->GetPosition();
	msg.wMugongIdx = m_pTempDeleteMugong->GetItemIdx();

	NETWORK->Send(&msg,sizeof(msg));
	m_pTempDeleteMugong = NULL;
	SetDisable(TRUE);
}



CMugongBase * CMugongDialog::GetMugongAbs(POSTYPE abs_Pos)
{
	//*mugongOut = *(CMugongBase * )GetIconForIdx(relPos);
	MLOC loc = GetWindowLocate(abs_Pos);
	switch(loc)
	{
	case MUGONGWINDOW_NORMAL:
	case MUGONGWINDOW_JINBUB:
		return m_pMugongRect[loc].GetMugong(abs_Pos);
		break;
	default:
		{
			ASSERT(0);
		}
	}
	return NULL;
}

void CMugongDialog::SetMugongSung(POSTYPE abspos, BYTE sung)
{
	MLOC loc = GetWindowLocate(abspos);
	switch(loc)
	{
	case MUGONGWINDOW_NORMAL:
	case MUGONGWINDOW_JINBUB:
		m_pMugongRect[loc].SetMugongSung(abspos,sung);
		break;
	default:
		{
			ASSERT(0);
		}
	}
}

void CMugongDialog::SetMugongExpPoint(POSTYPE abspos, EXPTYPE expPoint)
{
	MLOC loc = GetWindowLocate(abspos);
	switch(loc)
	{
	case MUGONGWINDOW_NORMAL:
	case MUGONGWINDOW_JINBUB:
		m_pMugongRect[loc].SetMugongExpPoint(abspos,expPoint);
		break;
	default:
		{
			ASSERT(0);
		}
	}
	MUGONGMGR->RefreshMugong();
}

BOOL CMugongDialog::CanBeMoved(cIcon * pIcon, POSTYPE abs_pos)
{
	ASSERT(pIcon);	
	MLOC loc = GetWindowLocate(abs_pos);
	switch(loc)
	{
	case MUGONGWINDOW_NORMAL:
	case MUGONGWINDOW_JINBUB:
		{
			return m_pMugongRect[loc].CanBeMoved(pIcon,abs_pos);
		}
		break;
	default:
		ASSERT(0);
	}
	return FALSE;
}

void CMugongDialog::OnActionEvnet(LONG lId, void * p, DWORD we)
{
	if(we == WE_LBTNCLICK || we == WE_LBTNDBLCLICK)
	{
		MLOC loc;
		BYTE type2 = 0;
		switch(lId)
		{
		case MGI_MUGONG_GRID:
			{
				loc = MUGONGWINDOW_NORMAL;
				type2 = eMUGONGBOOK;
			}
			break;
		case MGI_JINBUB_GRID:
			{
				loc = MUGONGWINDOW_JINBUB;
				type2 = eJINBUBBOOK;
			}
			break;
		default:
			{
				return;
			}
		}
		
		POSTYPE pos;
		int mouseX = MOUSE->GetMouseX();
		int mouseY = MOUSE->GetMouseY();
		if(!GetPositionForXYRef(mouseX,mouseY, pos))		// 例措困摹 逞绢 咳
			return;

		if(we == WE_LBTNCLICK)
			SelectMugong(pos);
		else if(we == WE_LBTNDBLCLICK)
			ExcuteMugong(pos);
	}
	
}

void CMugongDialog::ExcuteMugong(POSTYPE pos)
{
}

void CMugongDialog::SelectMugong(POSTYPE pos)
{
	MLOC loc = GetWindowLocate(pos);
	switch(loc)
	{
	case MUGONGWINDOW_NORMAL:
	case MUGONGWINDOW_JINBUB:
		{
			m_pMugongRect[loc].SelectMugong(pos);
		}
		break;
	default:
		ASSERT(0);
	}

}