skillobject_server.cpp

墨香最新私服

// SkillObject.cpp: implementation of the CSkillObject class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#ifdef _MAPSERVER_

#include "SkillObject_server.h"
#include "SkillInfo.h"
#include "SkillObjectTerminator.h"
#include "SkillObjectTargetList.h"
#include "SkillObjectFirstUnit.h"
#include "SkillObjectStateUnit.h"

#include "UserTable.h"
#include "ServerSystem.h"
#include "PackedData.h"
#include "Player.h"

#include "BattleSystem_Server.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CSkillObject::CSkillObject( CSkillInfo* pSkillInfo,
							CSkillObjectTerminator* pTerminator,
							CSkillObjectTargetList* pTargetList,
							CSkillObjectFirstUnit* pFirstUnit)
{
	m_pSkillInfo = pSkillInfo;
	m_pTerminator = pTerminator;
	m_pTargetList = pTargetList;
	m_pTargetList->SetSkillObject(this);
	m_pFirstUnit = pFirstUnit;
	m_PositiveTargetType = pSkillInfo->GetPositiveResultTargetType();
	m_NegativeTargetType = pSkillInfo->GetNegativeResultTargetType();
	
	m_ObjectKind = eObjectKind_SkillObject;
}

CSkillObject::~CSkillObject()
{
	Release();

	SAFE_DELETE(m_pTerminator);
	SAFE_DELETE(m_pTargetList);

	CSkillObjectSingleUnit* pSingleUnit;
	while(pSingleUnit = (CSkillObjectSingleUnit*)m_SingleUnitList.RemoveTail())
	{
		delete pSingleUnit;
	}
}

void CSkillObject::Init(SKILLOBJECT_INFO* pInfo,CTargetList* pTList)
{
	m_bDieFlag = FALSE;

	m_pTerminator->Init(m_pSkillInfo,pInfo->SkillLevel);

	// 积疙仿 汲沥
	m_MaxLife = m_CurLife = m_pSkillInfo->GetSkillInfo()->Life;
	
	m_BaseObjectInfo.dwObjectID = pInfo->SkillObjectIdx;
	strcpy(m_BaseObjectInfo.ObjectName,"SkillObject");
	m_BaseObjectInfo.ObjectState = eObjectState_None;

	m_pOperator = g_pUserTable->FindUser(pInfo->Operator);
	ASSERT(m_pOperator);
	
	WORD ResultKind = SKILLRESULTKIND_NONE;
	// SingleUnit Init
	PTRLISTSEARCHSTART(m_SingleUnitList,CSkillObjectSingleUnit*,pSingleUnit)
		pSingleUnit->Init(m_pSkillInfo,pInfo->SkillLevel);
		ResultKind |= pSingleUnit->GetPNTarget();
	PTRLISTSEARCHEND;

	// StateUnit Init
	PTRLISTSEARCHSTART(m_StateUnitList,CSkillObjectStateUnit*,pStateUnit)
		pStateUnit->Init(m_pSkillInfo,pInfo->SkillLevel);
		ResultKind |= pStateUnit->GetPNTarget();
	PTRLISTSEARCHEND;

	CObject* pAdditionalTarget = NULL;
	if( ResultKind & SKILLRESULTKIND_POSITIVE && 
		m_pSkillInfo->GetPositiveResultTargetType() == SKILLTARGETTYPE_SELF)
		pAdditionalTarget = m_pOperator;
	if( ResultKind & SKILLRESULTKIND_NEGATIVE && 
		m_pSkillInfo->GetNegativeResultTargetType() == SKILLTARGETTYPE_SELF)
		pAdditionalTarget = m_pOperator;

	memcpy(&m_SkillObjectInfo,pInfo,sizeof(SKILLOBJECT_INFO));
	m_pTargetList->InitTargetList(this,pTList,pAdditionalTarget,&pInfo->MainTarget);
	
	MSG_SKILLOBJECT_ADD msg;
	msg.InitMsg(&m_SkillObjectInfo,TRUE);
	


	PTRLISTSEARCHSTART(m_StateUnitList,CSkillObjectStateUnit*,pStateUnit)
		pStateUnit->StartState(m_pTargetList);
	PTRLISTSEARCHEND;
	
	
	m_pFirstUnit->Init(m_pSkillInfo,pInfo->SkillLevel);
	m_pFirstUnit->ExcuteFirstUnit(m_pOperator,m_pTargetList,&msg);

	
	
	PACKEDDATA_OBJ->QuickSend(m_pOperator,&msg,msg.GetMsgLength());
}

void CSkillObject::Release()
{
	PTRLISTSEARCHSTART(m_StateUnitList,CSkillObjectStateUnit*,pStateUnit)
		pStateUnit->EndState(m_pTargetList);
	PTRLISTSEARCHEND;

	m_pFirstUnit->Release();
	m_pTargetList->Release(this);
	
	PTRLISTSEARCHSTART(m_SingleUnitList,CSkillObjectSingleUnit*,pSingleUnit)
		pSingleUnit->Release();
	PTRLISTSEARCHEND;

	m_pOperator = NULL;
}

void CSkillObject::AddSingleUnit(CSkillObjectSingleUnit* pSingleUnit)
{
	m_SingleUnitList.AddTail(pSingleUnit);
	pSingleUnit->SetSkillObject(this);
}

void CSkillObject::AddStateUnit(CSkillObjectStateUnit* pStateUnit)
{
	m_StateUnitList.AddTail(pStateUnit);
	pStateUnit->SetSkillObject(this);
}

DWORD CSkillObject::Update()
{
	if(m_bDieFlag == TRUE)
		return SO_DESTROYOBJECT;
	
	//////////////////////////////////////////////////////////////////////////
	//YHTEST
	if(m_pOperator==NULL)
	{
//		MessageBox(NULL,"m_pOperator is NULL (CSkillObject::Update)",0,0);
		return SO_DESTROYOBJECT;
	}
	//////////////////////////////////////////////////////////////////////////
	

	if( m_pOperator->GetInited() == FALSE ||
		m_pOperator->GetID() != m_SkillObjectInfo.Operator)
		return SO_DESTROYOBJECT;
	
	PTRLISTSEARCHSTART(m_SingleUnitList,CSkillObjectSingleUnit*,pSingleUnit)
		pSingleUnit->Update(&m_SkillObjectInfo,m_pTargetList);
	PTRLISTSEARCHEND;
	
	if(m_pTerminator->CheckTerminate(&m_SkillObjectInfo) == TRUE)
	{
		//辆丰贸府
		return SO_DESTROYOBJECT;
	}

	return SO_OK;
}

void CSkillObject::UpdateTargetList(CObject* pObject)
{
	m_pTargetList->UpdateTargetList(pObject);
}

void CSkillObject::AddTargetObject(CObject* pObject)
{
	// YH2DO 八荤 鞘夸

	BYTE bTargetKind = m_pTargetList->AddTargetObject(pObject,0);

	// yh 眠啊 凳
	if(bTargetKind == SKILLRESULTKIND_NONE)
		return;

	//////////////////////////////////////////////////////////////////////////
	// YH2DO Positive Negative 鸥百 利侩
	PTRLISTSEARCHSTART(m_StateUnitList,CSkillObjectStateUnit*,pStateUnit)
		pStateUnit->StartState(pObject,bTargetKind);
	PTRLISTSEARCHEND;
	//////////////////////////////////////////////////////////////////////////
	

	MSG_DWORD2BYTE msg;
	msg.Category = MP_SKILL;
	msg.Protocol = MP_SKILL_ADDOBJECT_TO_SKILLOBJECTAREA_ACK;
	msg.dwData1 = GetID();
	msg.dwData2 = pObject->GetID();
	msg.bData = bTargetKind;
	PACKEDDATA_OBJ->QuickSendExceptObjectSelf(this,&msg,sizeof(msg));
}
void CSkillObject::RemoveTargetObject(DWORD ObjectID)
{
	// YH2DO 八荤 鞘夸


	BYTE bTargetKind = m_pTargetList->RemoveTargetObject(ObjectID);

	// yh 眠啊 凳
	if(bTargetKind == SKILLRESULTKIND_NONE)
		return;
	
	CObject* pObject = g_pUserTable->FindUser(ObjectID);
	if(pObject)
	{
		//////////////////////////////////////////////////////////////////////////
		// YH2DO Positive Negative 鸥百 利侩
		PTRLISTSEARCHSTART(m_StateUnitList,CSkillObjectStateUnit*,pStateUnit)
			pStateUnit->EndState(pObject,bTargetKind);
		PTRLISTSEARCHEND;
		//////////////////////////////////////////////////////////////////////////
	}


	MSG_DWORD2 msg;
	msg.Category = MP_SKILL;
	msg.Protocol = MP_SKILL_REMOVEOBJECT_FROM_SKILLOBJECTAREA_ACK;
	msg.dwData1 = GetID();
	msg.dwData2 = ObjectID;
	PACKEDDATA_OBJ->QuickSendExceptObjectSelf(this,&msg,sizeof(msg));
}

void CSkillObject::SetAddMsg(char* pAddMsg,WORD* pMsgLen,DWORD dwReceiverID,BOOL bLogin)
{
	if(bLogin == TRUE)
	{
		*pMsgLen = 0;		// 贸澜 肺弊牢 沁阑锭 皋技瘤绰 InitSkillObject俊辑 焊辰促.
		return;
	}

	MSG_SKILLOBJECT_ADD* pMsg = (MSG_SKILLOBJECT_ADD*)pAddMsg;
	pMsg->InitMsg(&m_SkillObjectInfo,FALSE);
	pMsg->dwObjectID = dwReceiverID;
	CTargetListIterator iter(&pMsg->TargetList);
	m_pTargetList->SetPositionHead();
	STLIST* pList;
	while(pList = m_pTargetList->GetNextTargetList())
	{
		iter.AddTargetWithNoData(pList->pObject->GetID(),pList->bTargetKind);
	}
	iter.Release();
	*pMsgLen = pMsg->GetMsgLength();
}
void CSkillObject::SetRemoveMsg(char* pRemoveMsg,WORD* pMsgLen,DWORD dwReceiverID)
{
	MSG_DWORD* pMsg = (MSG_DWORD*)pRemoveMsg;
	pMsg->Category = MP_SKILL;
	pMsg->Protocol = MP_SKILL_SKILLOBJECT_REMOVE;
	pMsg->dwObjectID = dwReceiverID;
	pMsg->dwData = GetID();
	
	*pMsgLen = sizeof(MSG_DWORD);
}

void CSkillObject::GetPosition(VECTOR3* pPos)
{
	*pPos = m_SkillObjectInfo.Pos;
}

BOOL CSkillObject::IsNegativeTarget(CObject* pObject)
{
	return TargetTypeCheck(m_NegativeTargetType,pObject);
}

BOOL CSkillObject::IsPositiveTarget(CObject* pObject)
{
	return TargetTypeCheck(m_PositiveTargetType,pObject);
}

BOOL CSkillObject::TargetTypeCheck(WORD TargetType,CObject* pObject)
{
	switch(TargetType)
	{
	case SKILLTARGETTYPE_ENEMY:
		{
			CBattle* pBattle = pObject->GetBattle();	// m_pOperator 加茄 海撇阑 掘绢柯促.
			return pBattle->IsEnemy(m_pOperator,pObject);
		}
		break;
	case SKILLTARGETTYPE_TEAMMATE:
		{
			CBattle* pBattle = pObject->GetBattle();	// m_pOperator 加茄 海撇阑 掘绢柯促.
			return pBattle->IsFriend(m_pOperator,pObject);
		}
		break;
	case SKILLTARGETTYPE_SELF:
		{
			if(pObject != m_pOperator)
				return FALSE;
		}
		break;
	case SKILLTARGETTYPE_ENEMYANDTEAM:
		{
			CBattle* pBattle = pObject->GetBattle();	// m_pOperator 加茄 海撇阑 掘绢柯促.
			if(pBattle->IsEnemy(m_pOperator,pObject))
				return TRUE;
			if(pBattle->IsFriend(m_pOperator,pObject))
				return TRUE;

			return FALSE;
		}
		break;
	case SKILLTARGETTYPE_NOTENEMYTARGET:
		{
			CBattle* pBattle = BATTLESYSTEM->GetBattle(m_pOperator->GetBattleID());	// m_pOperator 加茄 海撇阑 掘绢柯促.
			if(pBattle->IsEnemy(m_pOperator,pObject))
				return FALSE;

			return TRUE;
		}
		break;
	}
	return TRUE;
}

CObject* CSkillObject::GetOperator()
{
	return m_pOperator;
}

void CSkillObject::DoDie(CObject* pAttacker)
{
	m_bDieFlag = TRUE;
}

DWORD CSkillObject::GetLife()
{
	return m_CurLife;	
}
void CSkillObject::SetLife(DWORD Life,BOOL bSendMsg)
{
	if(Life > GetMaxLife()) 
		Life = GetMaxLife(); 
	m_CurLife = Life;
}
DWORD CSkillObject::DoGetMaxLife()
{
	return m_MaxLife;
}

#endif