objectplayer.cpp

真正的传奇源代码

#include "stdafx.h"

#define _MSG_GOOD		"+GOOD/"
#define _MSG_FAIL		"+FAIL/"

CMagicInfo*		GetMagicInfo(int nMagicID);
int				GetBack(int nDirection);
CMirMap*		GetMap(char *pszMapName);

CPlayerObject*	GetUserHuman(char *pszCharName);

void SendRDBSocket(int nCertification, char *pszData1, char *pszData2, int nData2Len);

void CPlayerObject::Constructor()
{
	m_bEmpty				= true;
	m_wObjectType			= _OBJECT_HUMAN;

	m_nViewRange			= 12;
	m_dwSearchTime			= GetTickCount();
	m_dwSearchTick			= 1000;

	m_fIsDead				= FALSE;

	m_btLight				= 2;

	m_fAdminMode			= FALSE;
	
	m_dwLastCryTime			= 0;

	m_fIsCapture			= FALSE;
}

bool CPlayerObject::IsEmpty()
{
	return m_bEmpty;
}

CPlayerObject::CPlayerObject(): CCharObject(NULL)
{
	Constructor();
}

CPlayerObject::CPlayerObject(CUserInfo* pUserInfo): CCharObject(pUserInfo)
{
	Constructor();
}

BOOL CPlayerObject::IsProperTarget(CCharObject* pTargetObject)
{
	BOOL fFlag = FALSE;

	if (!pTargetObject)
		return fFlag;

	int nMode = m_pUserInfo->GetAttackMode();

	switch (nMode)
	{
		case HAM_ALL:
			if (!(pTargetObject->m_wObjectType & _OBJECT_NPC))
				fFlag = TRUE;
			break;
		case HAM_PEACE:
			if (pTargetObject->m_wObjectType & _OBJECT_ANIMAL)
				fFlag = TRUE;
			break;
		case HAM_GROUP:
/*                  if not ((target.RaceServer >= RC_NPC) and (target.RaceServer <= RC_PEACENPC)) then
             Result := TRUE;
          if target.RaceServer = RC_USERHUMAN then
             if IsGroupMember (target) then
                Result := FALSE; */
			break;
		case HAM_GUILD:
/*                  if not ((target.RaceServer >= RC_NPC) and (target.RaceServer <= RC_PEACENPC)) then
             Result := TRUE;
          if target.RaceServer = RC_USERHUMAN then
             if MyGuild <> nil then begin
                if TGuild(MyGuild).IsMember(target.UserName) then
                   Result := FALSE;
                if BoGuildWarArea and (target.MyGuild <> nil) then begin  //巩颇傈,傍己傈 瘤开俊 乐澜
                   if TGuild(MyGuild).IsAllyGuild(TGuild(target.MyGuild)) then
                      Result := FALSE;
                end;
             end;
       end; */
			break;
		case HAM_PKATTACK:
/*
          if not ((target.RaceServer >= RC_NPC) and (target.RaceServer <= RC_PEACENPC)) then
             Result := TRUE;
          if target.RaceServer = RC_USERHUMAN then
             if self.PKLevel >= 2 then begin  //傍拜窍绰 磊啊 弧盎捞
                if target.PKLevel < 2 then Result := TRUE
                else Result := FALSE;
             end else begin
                //傍拜窍绰 磊啊 闰嫡捞
                if target.PKLevel >= 2 then Result := TRUE
                else Result := FALSE;
             end;
       end;
*/			break;
	}

/*			if target.RaceServer = RC_USERHUMAN then begin
        if (InSafeZone) or (target.InSafeZone) then begin
           Result := FALSE;
        end;

        if not target.BoInFreePKArea then begin  //傍己傈 瘤开俊辑绰 力寇 等促.
           if (PKLevel >= 2) and (Abil.Level > 10) then begin //绊乏 弧盎捞甸
              if (target.Abil.Level <= 10) and (target.PKLevel < 2) then //历肪 馒茄 檬焊甫 傍拜 给茄促.
                 Result := FALSE;
           end;
           if (Abil.Level <= 10) and (PKLevel < 2) then begin //历肪 馒茄 檬焊
              if (target.PKLevel >= 2) and (target.Abil.Level > 10) then //绊肪 弧盎捞甸阑 傍拜给茄促.
                 Result := FALSE;
           end;
        end;

        //甘 捞悼饶 3檬 悼救篮 傍拜 给窍绊 救 寸窃
        if (GetTickCount - MapMoveTime < 3000) or (GetTickCount - target.MapMoveTime < 3000) then
           Result := FALSE;

     end else begin
        if target.Master = self then begin  //郴 何窍
           if HumAttackMode <> HAM_ALL then  //葛滴 傍拜 老锭父 何窍啊 傍拜凳
              Result := FALSE;
        end else begin
           if target.Master <> nil then
              Result := IsProperTarget(target.Master);
        end;
     end;	*/

	return fFlag;
}

void CPlayerObject::GetCharName(char *pszCharName)
{ 
	strcpy(pszCharName, m_szName); 
}

BOOL CPlayerObject::ReadBook(char *pszMakeIndex)
{
	if (!m_pUserInfo) return FALSE;

	int nMagicID = m_pUserInfo->GetMagicID(pszMakeIndex);

	if (m_pUserInfo->IsMyMagic(nMagicID)) return FALSE;

	CMagicInfo*	pMagicInfo	= GetMagicInfo(nMagicID);

	if (pMagicInfo)
	{
		if (((pMagicInfo->sJob == m_pUserInfo->GetJob()) || pMagicInfo->sJob == 99) && m_Ability.Level >= pMagicInfo->sNeed[0])
		{
			char				szEncodeMsg[256];
			_TDEFAULTMESSAGE	DefMsg;
			_LPTHUMANMAGICRCD	lpHumanMagicRcd = new _THUMANMAGICRCD;

			if (lpHumanMagicRcd)
			{
				lpHumanMagicRcd->btMagicID		= nMagicID;
				lpHumanMagicRcd->btLevel		= 0;
				lpHumanMagicRcd->btUseKey		= 0;
				lpHumanMagicRcd->nCurrTrain		= 0;

				m_pUserInfo->m_lpTMagicRcd.AddNewNode(lpHumanMagicRcd);
				
				RecalcAbilitys();

				_TCLIENTMAGICRCD	tClientMagicRcd;

				tClientMagicRcd.btMagicID	= lpHumanMagicRcd->btMagicID;
				tClientMagicRcd.btLevel		= lpHumanMagicRcd->btLevel;
				tClientMagicRcd.btUseKey	= lpHumanMagicRcd->btUseKey;
				tClientMagicRcd.nCurrTrain	= lpHumanMagicRcd->nCurrTrain;

				tClientMagicRcd.tStdMagic.btEffect		= (BYTE)g_pMagicInfo[lpHumanMagicRcd->btMagicID].sEffect;
				tClientMagicRcd.tStdMagic.btEffectType	= (BYTE)g_pMagicInfo[lpHumanMagicRcd->btMagicID].sEffectType;
				memcpy(&tClientMagicRcd.tStdMagic.sNeed, g_pMagicInfo[lpHumanMagicRcd->btMagicID].sNeed, sizeof(tClientMagicRcd.tStdMagic.sNeed));
				memcpy(&tClientMagicRcd.tStdMagic.nTrain, g_pMagicInfo[lpHumanMagicRcd->btMagicID].nTrain, sizeof(tClientMagicRcd.tStdMagic.nTrain));
				tClientMagicRcd.tStdMagic.btDefSpell	= (BYTE)g_pMagicInfo[lpHumanMagicRcd->btMagicID].sDefSpell;
				tClientMagicRcd.tStdMagic.nDelayTime	= g_pMagicInfo[lpHumanMagicRcd->btMagicID].sDelay;

				fnMakeDefMessage(&DefMsg, SM_ADDMAGIC, 0, 0, 0, 1);
				int nPos = fnEncode6BitBufA((unsigned char *)&tClientMagicRcd, szEncodeMsg, sizeof(_TCLIENTMAGICRCD), sizeof(szEncodeMsg));
				szEncodeMsg[nPos] = '\0';
				SendSocket(&DefMsg, szEncodeMsg);

				return TRUE;
			}
		}
	}

	return FALSE;
}

BOOL CPlayerObject::EatItem(char *pszMakeIndex)
{
	int nStdIndex = m_pUserInfo->GetGenItemStdIdx(pszMakeIndex);

	if (g_pStdItemEtc[nStdIndex].wStdMode != 0) return FALSE;

	if (g_pStdItemEtc[nStdIndex].wShape == 1)
		IncHealthSpell(g_pStdItemEtc[nStdIndex].wDuraMax/*+hp*/, g_pStdItemEtc[nStdIndex].dwRSource/*+mp*/);
	else
	{
		if ((m_IncHealth + g_pStdItemEtc[nStdIndex].wDuraMax < 500) && (g_pStdItemEtc[nStdIndex].wDuraMax > 0))
			m_IncHealth += (WORD)g_pStdItemEtc[nStdIndex].wDuraMax;
		
		if ((m_IncSpell + g_pStdItemEtc[nStdIndex].dwRSource < 500) && (g_pStdItemEtc[nStdIndex].dwRSource > 0))
			m_IncSpell += (WORD)g_pStdItemEtc[nStdIndex].dwRSource;
	}

	return TRUE;
}

BOOL CPlayerObject::ServerGetEatItem(int nItemIndex, char *pszMakeIndex)
{
	if (!m_pUserInfo) return FALSE;

	_TDEFAULTMESSAGE	DefMsg;
	BOOL				fFlag = FALSE;

	_LPTGENERALITEMRCD lptGenItem = m_pUserInfo->GetUseGenItem(pszMakeIndex);

	if (lptGenItem)
	{
		switch (g_pStdItemEtc[nItemIndex].wStdMode)
		{
			case 0:
			{
				if (EatItem(pszMakeIndex))
				{
					m_pUserInfo->RemoveGenItem(lptGenItem);
					fFlag = TRUE;
				}

				break;
			}
			case 3:
			{
				break;
			}
			case 4:
			{
				if (ReadBook(pszMakeIndex))
				{
					m_pUserInfo->RemoveGenItem(lptGenItem);

					if (m_pUserInfo->m_lpTMagicErgumSkill)
					{
						if (!m_pUserInfo->m_fLongHitSkill)
						{
							m_pUserInfo->AllowLongHitSkill(TRUE);
							SendSocket(NULL, "+LNG");
						}
					}

					if (m_pUserInfo->m_lpTMagicBanwolSkill)
					{
						if (!m_pUserInfo->m_fWideHitSkill)
						{
							m_pUserInfo->AllowWideHitSkill(TRUE);
							SendSocket(NULL, "+WID");
						}
					}

					fFlag = TRUE;
				}

				break;
			}
		}
	}

	if (fFlag)
	{
 		fnMakeDefMessage(&DefMsg, SM_EAT_OK, 0, 0, 0, 0);
		SendSocket(&DefMsg, NULL);
	}
	else
	{
 		fnMakeDefMessage(&DefMsg, SM_EAT_FAIL, 0, 0, 0, 0);
		SendSocket(&DefMsg, NULL);
	}

	return fFlag;
}

void CPlayerObject::SendAddItem(_LPTUSERITEMRCD lpTItemRcd)
{
	_TDEFAULTMESSAGE	SendDefMsg;
	_TCLIENTITEMRCD		tClientItemRcd;
	char				szEncodeMsg[256];

	fnMakeDefMessage(&SendDefMsg, SM_ADDITEM, (int)this, 0, 0, 1);

	if (lpTItemRcd->szMakeIndex[0] != 'G')
	{
		g_pStdItemSpecial[lpTItemRcd->nStdIndex].GetStandardItem(&tClientItemRcd);
		g_pStdItemSpecial[lpTItemRcd->nStdIndex].GetUpgradeStdItem(&tClientItemRcd, lpTItemRcd);

		if (strlen(lpTItemRcd->szPrefixName))
			strcpy(tClientItemRcd.tStdItem.szPrefixName, lpTItemRcd->szPrefixName);
		else
			ZeroMemory(tClientItemRcd.tStdItem.szPrefixName, sizeof(tClientItemRcd.tStdItem.szPrefixName));
	}
	else
	{
		g_pStdItemEtc[lpTItemRcd->nStdIndex].GetStandardItem(&tClientItemRcd);
		g_pStdItemEtc[lpTItemRcd->nStdIndex].GetUpgradeStdItem(&tClientItemRcd, lpTItemRcd);
	}

	memcpy(tClientItemRcd.szMakeIndex, lpTItemRcd->szMakeIndex, 12);
	
	tClientItemRcd.nDura		= lpTItemRcd->nDura;
	tClientItemRcd.nDuraMax		= lpTItemRcd->nDuraMax;

	int nPos = 	fnEncode6BitBufA((unsigned char *)&tClientItemRcd, szEncodeMsg, sizeof(_TCLIENTITEMRCD), sizeof(szEncodeMsg));
	szEncodeMsg[nPos] = '\0';

	SendSocket(&SendDefMsg, szEncodeMsg);
}

BOOL CPlayerObject::PickUp()
{
	CMapItem* pMapItem = m_pMap->GetItem(m_nCurrX, m_nCurrY);

	if (pMapItem)
	{
		if (memcmp(pMapItem->szName, g_szGoldName, memlen(g_szGoldName) - 1) == 0)
		{
			if (m_pMap->RemoveObject(m_nCurrX, m_nCurrY, OS_ITEMOBJECT, (VOID *)pMapItem))
			{
				if (m_pUserInfo->IncGold(pMapItem->nCount))
				{
					AddRefMsg(RM_ITEMHIDE, 0, (int)pMapItem, m_nCurrX, m_nCurrY, NULL);

					GoldChanged();
					
					delete pMapItem;
					pMapItem = NULL;

					return TRUE;
				}
				else
					m_pMap->AddNewObject(m_nCurrX, m_nCurrY, OS_ITEMOBJECT, (VOID *)pMapItem);
			}
		}
		else
		{
			if (m_pUserInfo->IsEnoughBag())
			{
				if (m_pMap->RemoveObject(m_nCurrX, m_nCurrY, OS_ITEMOBJECT, (VOID *)pMapItem))
				{
					_LPTUSERITEMRCD lptItemRcd = (_LPTUSERITEMRCD)pMapItem->pItem;

					if (int nUpdate = UpdateItemToDB(lptItemRcd, _ITEM_ACTION_PICKUP))
					{
						AddRefMsg(RM_ITEMHIDE, 0, (int)pMapItem, m_nCurrX, m_nCurrY, NULL);

						if (nUpdate == 2)
						{
							SendAddItem(lptItemRcd);
							m_pUserInfo->m_lpTItemRcd.AddNewNode(lptItemRcd);
						}
						
						delete pMapItem;
						pMapItem = NULL;
					}
				}
			}
		}
	}

	return FALSE;
}
/*function  TCreature.PickUp: Boolean;
var
   i: integer;
   pu: PTUserItem;
   pmi: PTMapItem;
   ps: PTStdItem;
   hum: TUserHuman;
begin
   Result := FALSE;
   if BoDealing then exit;  //背券吝俊绰 拱扒阑 林阑 荐 绝促.
   pmi := PEnvir.GetItem (CX, CY);
   if pmi <> nil then begin
      if CompareText (pmi.Name, '陛傈') = 0 then begin
         if PEnvir.DeleteFromMap (CX, CY, OS_ITEMOBJECT, TObject(pmi)) = 1 then begin
            if IncGold (pmi.Count) then begin
               SendRefMsg (RM_ITEMHIDE, 0, integer(pmi), CX, CY, '');
               //肺弊巢辫
               AddUserLog ('凛扁_' +
                           MapName + '_' +
                           IntToStr(CX) + '_' +
                           IntToStr(CY) + '_' +
                           UserName + '_' +
                           '陛傈_' +
                           IntToStr(pmi.count));
               GoldChanged;
               Dispose (pmi);
            end else
               PEnvir.AddToMap (CX, CY, OS_ITEMOBJECT, TObject(pmi));
         end;
      end else
         if IsEnoughBag then begin
            if PEnvir.DeleteFromMap (CX, CY, OS_ITEMOBJECT, TObject(pmi)) = 1 then begin
               new (pu);
               pu^ := pmi.UserItem;
               ps := UserEngine.GetStdItem (pu.Index);
               if (ps <> nil) and IsAddWeightAvailable (UserEngine.GetStdItemWeight(pu.Index)) then begin
                  SendMsg (self, RM_ITEMHIDE, 0, integer(pmi), CX, CY, '');
                  AddItem (pu);
                  //肺弊巢辫
                  if not IsCheapStuff (ps.StdMode) then
                     AddUserLog ('凛扁_' +
                                 MapName + '_' +
                                 IntToStr(CX) + '_' +
                                 IntToStr(CY) + '_' +
                                 UserName + '_' +
                                 UserEngine.GetStdItemName (pu.Index) + '_' +
                                 IntToStr(pu.MakeIndex));