userinfo.cpp

真正的传奇源代码

#include "stdafx.h"

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

CUserInfo::CUserInfo()
{
	m_bEmpty					= true;

	m_pxPlayerObject			= NULL;
	m_pGateInfo					= NULL;

	m_nNumOfMagics				= 0;
	m_nNumOfGenItems			= 0;
	m_nNumOfItems				= 0;

	m_lpTMagicErgumSkill		= NULL;
	m_lpTMagicBanwolSkill		= NULL;
	m_lpTMagicFireSwordSkill	= NULL;
	m_lpTMagicOneSwordSkill		= NULL;
	m_lpTMagicIlkwangSkill		= NULL;
	m_lpTMagicPowerHitSkill		= NULL;

	m_fLongHitSkill				= FALSE;
	m_fWideHitSkill				= FALSE;
	m_fFireHitSkill				= FALSE;

	m_dwLatestFireHitTime		= 0;
}

bool CUserInfo::IsEmpty()
{
	return m_bEmpty;
}
/*
void CUserInfo::RandomUpgradeItem(WORD wStdMode, _LPTMAKEITEMRCD lpMakeItemRcd)
{
	if (wStdMode == 5 || wStdMode == 6)
		g_pStdItemWeapon[lpMakeItemRcd->nStdIndex - 1].UpgradeRandomItem(lpMakeItemRcd);
	else if (wStdMode == 10 || wStdMode == 11)
		g_pStdItemArmor[lpMakeItemRcd->nStdIndex - 1].UpgradeRandomItem(lpMakeItemRcd);
	else if (wStdMode >= 21 && wStdMode <= 50)
		g_pStdItemAccessory[lpMakeItemRcd->nStdIndex - 1].UpgradeRandomItem(lpMakeItemRcd);
}
*/
void CUserInfo::AddNewItem(char *pszItemName)
{
	int		i;
	WORD	wStdMode;

	_TMAKEITEMRCD		MakeItemRcd;

	if (m_lpTItemRcd.GetCount() + m_lpTGenItemRcd.GetCount() > USERITEMMAX) return;

	int nLen = memlen(pszItemName) - 1;
	int nCmpLen;

	for (i = 0; i < g_nStdItemSpecial; i++)
	{
		nCmpLen = memlen(g_pStdItemSpecial[i].szName) - 1;

		if (nCmpLen == nLen)
		{
			if (memcmp(g_pStdItemSpecial[i].szName, pszItemName, nLen) == 0)
			{
				ZeroMemory(MakeItemRcd.btValue, sizeof(MakeItemRcd.btValue));

				MakeItemRcd.nStdIndex		= i;

				switch (g_pStdItemSpecial[i].btType)
				{
					case 0:
						MakeItemRcd.szStdType		= 'A';
						break;
					case 1:
						MakeItemRcd.szStdType		= 'B';
						break;
					case 2:
						MakeItemRcd.szStdType		= 'C';
						break;
				}

				MakeItemRcd.nDura			= g_pStdItemSpecial[i].wDuraMax;
				MakeItemRcd.nDuraMax		= g_pStdItemSpecial[i].wDuraMax;

				wStdMode					= g_pStdItemSpecial[i].wStdMode;

				if (rand() % 10 == 0)
					g_pStdItemSpecial[i].UpgradeRandomItem(MakeItemRcd.btValue, MakeItemRcd.nDura, MakeItemRcd.nDuraMax);

				MakeItemToDB((int)this, m_szUserID, m_szCharName, &MakeItemRcd);
			}
		}
	}

	for (i = 0; i < g_nStdItemEtc; i++)
	{
		nCmpLen = memlen(g_pStdItemEtc[i].szName) - 1;

		if (nCmpLen == nLen)
		{
			if (memcmp(g_pStdItemEtc[i].szName, pszItemName, nLen) == 0)
			{
				_LPTGENERALITEMRCD		lptGenItemRcd = new _TGENERALITEMRCD;

				if (lptGenItemRcd)
				{
//					lptGenItemRcd->szStdType	= g_pStdItemEtc[i].m_btType;
					lptGenItemRcd->nStdIndex	= i;
					lptGenItemRcd->nDura		= g_pStdItemEtc[i].wDuraMax;
					lptGenItemRcd->nDuraMax		= g_pStdItemEtc[i].dwRSource;

					MakeGenItem(lptGenItemRcd);
				}

				return;
			}
		}
	}
}

void CUserInfo::MakeGenItem(_LPTGENERALITEMRCD lptGenItemRcd)
{
	if (m_pxPlayerObject)
	{
		// Make Item on Server
		_TGENITEMRCD		GenItemRcd;

		sprintf(GenItemRcd.szItem, "G%03d%04d%04d", lptGenItemRcd->nStdIndex, lptGenItemRcd->nDura, lptGenItemRcd->nDuraMax);

		memcpy(lptGenItemRcd->szMakeIndex, GenItemRcd.szItem, 12);

		m_lpTGenItemRcd.AddNewNode(lptGenItemRcd);

		_TCLIENTITEMRCD		tClientItemRcd;
		_TDEFAULTMESSAGE	SendDefMsg;
		char				szEncodeMsg[256];

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

		// Get Standard General Item (STDITEM_ETC)
		g_pStdItemEtc[lptGenItemRcd->nStdIndex].GetStandardItem(&tClientItemRcd);

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

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

		m_pxPlayerObject->SendSocket(&SendDefMsg, szEncodeMsg);
	}
}

int	CUserInfo::GetDressFeature()
{
	if (m_lpTItemRcd.GetCount())
	{
		PLISTNODE pListNode = m_lpTItemRcd.GetHead();

		while (pListNode)
		{
			_LPTUSERITEMRCD lpTItemRcd = m_lpTItemRcd.GetData(pListNode);
		
			if (memcmp(m_THumanRcd.szTakeItem[U_DRESS], lpTItemRcd->szMakeIndex, _MAKEITEMINDEX) == 0)
				return g_pStdItemSpecial[lpTItemRcd->nStdIndex].wShape;

			pListNode = m_lpTItemRcd.GetNext(pListNode);
		}
	}

	return 0;
}

int	CUserInfo::GetWeaponFeature()
{
	if (m_lpTItemRcd.GetCount())
	{
		PLISTNODE pListNode = m_lpTItemRcd.GetHead();

		while (pListNode)
		{
			_LPTUSERITEMRCD lpTItemRcd = m_lpTItemRcd.GetData(pListNode);
		
			if (memcmp(m_THumanRcd.szTakeItem[U_WEAPON], lpTItemRcd->szMakeIndex, _MAKEITEMINDEX) == 0)
				return g_pStdItemSpecial[lpTItemRcd->nStdIndex].wShape;

			pListNode = m_lpTItemRcd.GetNext(pListNode);
		}
	}

	return 0;
}

_LPTUSERITEMRCD	CUserInfo::GetItem(char *pszMakeIndex)
{
	if (m_lpTItemRcd.GetCount())
	{
		PLISTNODE pListNode = m_lpTItemRcd.GetHead();

		while (pListNode)
		{
			_LPTUSERITEMRCD lpTItemRcd = m_lpTItemRcd.GetData(pListNode);
		
			if (memcmp(pszMakeIndex, lpTItemRcd->szMakeIndex, _MAKEITEMINDEX) == 0)
				return lpTItemRcd;

			pListNode = m_lpTItemRcd.GetNext(pListNode);
		}
	}

	return NULL;
}

_LPTGENERALITEMRCD CUserInfo::GetUseGenItem(char *pszMakeItemID)
{
	if (m_lpTGenItemRcd.GetCount())
	{
		PLISTNODE pListNode = m_lpTGenItemRcd.GetHead();

		while (pListNode)
		{
			_LPTGENERALITEMRCD lpTItemRcd = m_lpTGenItemRcd.GetData(pListNode);
		
			if (memcmp(pszMakeItemID, lpTItemRcd->szMakeIndex, _MAKEITEMINDEX) == 0)
				return lpTItemRcd;

			pListNode = m_lpTGenItemRcd.GetNext(pListNode);
		}
	}

	return NULL;
}

BOOL CUserInfo::IsMyMagic(int nIndex)
{
	if (m_lpTMagicRcd.GetCount())
	{
		_LPTHUMANMAGICRCD	lptUserMagicRcd;

		PLISTNODE pListNode = m_lpTMagicRcd.GetHead();

		while (pListNode)
		{
			lptUserMagicRcd = m_lpTMagicRcd.GetData(pListNode);

			if (lptUserMagicRcd->btMagicID == nIndex)
				return TRUE;

			pListNode = m_lpTMagicRcd.GetNext(pListNode);
		}
	}

	return FALSE;
}

int CUserInfo::EncodeMyMagicToServer(char *pszEncodeMsg, int nBuffSize, int& nPos)
{
	int	nCnt = 0;

	if (m_lpTMagicRcd.GetCount())
	{
		_LPTHUMANMAGICRCD	lptUserMagicRcd;

		PLISTNODE pListNode = m_lpTMagicRcd.GetHead();

		while (pListNode)
		{
			lptUserMagicRcd = m_lpTMagicRcd.GetData(pListNode);

			if (lptUserMagicRcd)
			{
				nPos +=	fnEncode6BitBufA((unsigned char *)lptUserMagicRcd, pszEncodeMsg + nPos, sizeof(_THUMANMAGICRCD), nBuffSize - nPos);

				*(pszEncodeMsg + nPos) = '/';

				nPos++;
				nCnt++;
			}

			pListNode = m_lpTMagicRcd.GetNext(pListNode);
		}
	}

	return nCnt;
}

int CUserInfo::EncodeMyMagic(char *pszEncodeMsg, int nBuffSize, int& nPos)
{
	int	nCnt = 0;

	if (m_lpTMagicRcd.GetCount())
	{
		_LPTHUMANMAGICRCD	lptUserMagicRcd;
		_TCLIENTMAGICRCD	tClientMagicRcd;

		PLISTNODE pListNode = m_lpTMagicRcd.GetHead();

		while (pListNode)
		{
			lptUserMagicRcd = m_lpTMagicRcd.GetData(pListNode);

			if (lptUserMagicRcd)
			{
				tClientMagicRcd.btMagicID	= lptUserMagicRcd->btMagicID;
				tClientMagicRcd.btLevel		= lptUserMagicRcd->btLevel;
				tClientMagicRcd.btUseKey	= lptUserMagicRcd->btUseKey;
				tClientMagicRcd.nCurrTrain	= lptUserMagicRcd->nCurrTrain;

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

				nPos +=	fnEncode6BitBufA((unsigned char *)&tClientMagicRcd, pszEncodeMsg + nPos, sizeof(_TCLIENTMAGICRCD), nBuffSize - nPos);

				*(pszEncodeMsg + nPos) = '/';

				nPos++;
				nCnt++;
			}

			pListNode = m_lpTMagicRcd.GetNext(pListNode);
		}
	}

	return nCnt;
}

void CUserInfo::RemoveGenItem(_LPTGENERALITEMRCD lptItemRcd)
{
	if (m_lpTGenItemRcd.GetCount())
	{
		_LPTGENERALITEMRCD	lptGenItemRcd;

		PLISTNODE pListNode = m_lpTGenItemRcd.GetHead();

		while (pListNode)
		{
			lptGenItemRcd = m_lpTGenItemRcd.GetData(pListNode);

			if (lptGenItemRcd == lptItemRcd)
			{
				m_lpTGenItemRcd.RemoveNode(pListNode);
				delete lptGenItemRcd;
				lptGenItemRcd = NULL;
				return;
			}

			pListNode = m_lpTGenItemRcd.GetNext(pListNode);
		}
	}
}

int CUserInfo::EncodeGenItem(char *pszEncodeMsg, int nBuffSize, int& nPos)
{
	int	nCnt = 0;

	if (m_lpTGenItemRcd.GetCount())
	{
		_LPTGENERALITEMRCD	lptGenItemRcd;
		_TGENITEMRCD		GenItemRcd;
		TCHAR				wszItem[13];

		PLISTNODE pListNode = m_lpTGenItemRcd.GetHead();

		while (pListNode)
		{
			lptGenItemRcd = m_lpTGenItemRcd.GetData(pListNode);

			if (lptGenItemRcd)
			{
				wsprintf(wszItem, _TEXT("G%03d%04d%04d"), lptGenItemRcd->nStdIndex, lptGenItemRcd->nDura, lptGenItemRcd->nDuraMax);
				WideCharToMultiByte(CP_ACP, 0, wszItem, -1, GenItemRcd.szItem, sizeof(GenItemRcd.szItem), NULL, NULL);

				nPos +=	fnEncode6BitBufA((unsigned char *)&GenItemRcd, pszEncodeMsg + nPos, sizeof(_TGENITEMRCD), nBuffSize - nPos);

				*(pszEncodeMsg + nPos) = '/';

				nPos++;
				nCnt++;
			}

			pListNode = m_lpTGenItemRcd.GetNext(pListNode);
		}
	}

	return nCnt;
}

void CUserInfo::AllowLongHitSkill(BOOL fFlag)
{
	TCHAR	szText[64];
	char	szMsg[64];

	m_fLongHitSkill = fFlag;

	if (m_fLongHitSkill)
		LoadString(g_hInst, IDS_ALLOW_LONGHIT, szText, sizeof(szText)/sizeof(TCHAR));
	else
		LoadString(g_hInst, IDS_NOTALLOW_LONGHIT, szText, sizeof(szText)/sizeof(TCHAR));

	WideCharToMultiByte(CP_ACP, 0, szText, -1, szMsg, sizeof(szMsg), NULL, NULL);
	
	m_pxPlayerObject->SysMsg(szMsg, 1);
}

void CUserInfo::AllowWideHitSkill(BOOL fFlag)
{
	TCHAR	szText[64];
	char	szMsg[64];

	m_fWideHitSkill = fFlag;

	if (m_fWideHitSkill)
		LoadString(g_hInst, IDS_ALLOW_WIDEHIT, szText, sizeof(szText)/sizeof(TCHAR));
	else
		LoadString(g_hInst, IDS_NOTALLOW_WIDEHIT, szText, sizeof(szText)/sizeof(TCHAR));

	WideCharToMultiByte(CP_ACP, 0, szText, -1, szMsg, sizeof(szMsg), NULL, NULL);
	
	m_pxPlayerObject->SysMsg(szMsg, 1);
}

BOOL CUserInfo::AllowFireHitSkill()
{
	TCHAR	szText[128];
	char	szMsg[128];

	if (GetTickCount() - m_dwLatestFireHitTime > 10 * 1000)
	{
		m_fFireHitSkill			= TRUE;
		m_dwLatestFireHitTime	= GetTickCount();

		LoadString(g_hInst, IDS_ALLOW_FIREHIT, szText, sizeof(szText)/sizeof(TCHAR));
		WideCharToMultiByte(CP_ACP, 0, szText, -1, szMsg, sizeof(szMsg), NULL, NULL);
		
		m_pxPlayerObject->SysMsg(szMsg, 1);

		return TRUE;
	}
	else
	{
		LoadString(g_hInst, IDS_NOTALLOW_FIREHIT, szText, sizeof(szText)/sizeof(TCHAR));
		WideCharToMultiByte(CP_ACP, 0, szText, -1, szMsg, sizeof(szMsg), NULL, NULL);
		
		m_pxPlayerObject->SysMsg(szMsg, 0);
	}

	return FALSE;
}

int CUserInfo::GetGenItemStdIdx(char *pszMakeIndex)
{
	char	szStdIdx[5];

	ZeroMemory(szStdIdx, sizeof(szStdIdx));
	memmove(szStdIdx, &pszMakeIndex[1], 3);

	return AnsiStrToVal(szStdIdx);
}

int CUserInfo::GetGenItemVal1(char *pszMakeIndex)
{
	char	szVal1[5];

	ZeroMemory(szVal1, sizeof(szVal1));
	memmove(szVal1, &pszMakeIndex[4], 4);

	return AnsiStrToVal(szVal1);
}

int CUserInfo::GetGenItemVal2(char *pszMakeIndex)
{
	char	szVal2[5];

	ZeroMemory(szVal2, sizeof(szVal2));
	memmove(szVal2, &pszMakeIndex[8], 4);

	return AnsiStrToVal(szVal2);
}

int CUserInfo::CalcBagWeight()
{
	int nWeight = 0;

	if (m_lpTItemRcd.GetCount())
	{
		PLISTNODE pListNode = m_lpTItemRcd.GetHead();

		while (pListNode)
		{
			_LPTUSERITEMRCD lpTItemRcd = m_lpTItemRcd.GetData(pListNode);

			if (lpTItemRcd)
				nWeight += g_pStdItemSpecial[lpTItemRcd->nStdIndex].wWeight;

			pListNode = m_lpTItemRcd.GetNext(pListNode);
		}
	}

	if (m_lpTGenItemRcd.GetCount())
	{
		_LPTGENERALITEMRCD	lptGenItemRcd;

		PLISTNODE pListNode = m_lpTGenItemRcd.GetHead();

		while (pListNode)
		{
			lptGenItemRcd = m_lpTGenItemRcd.GetData(pListNode);

			if (lptGenItemRcd)
				nWeight += g_pStdItemEtc[lptGenItemRcd->nStdIndex].wWeight;

			pListNode = m_lpTGenItemRcd.GetNext(pListNode);
		}
	}

	return nWeight;
}

int CUserInfo::CalcWearWeightEx(int nIndex)
{
	_LPTUSERITEMRCD lptItemRcd;
	int				nWeight = 0;

	for (int i = 0; i < 8; i++)
	{
		if ((i != nIndex) && (i != U_WEAPON) && (i != U_RIGHTHAND))
		{
			lptItemRcd = GetUseItem(i);

			if (lptItemRcd)
				nWeight += g_pStdItemSpecial[lptItemRcd->nStdIndex].wWeight;
		}
	}

	return nWeight;
}

BOOL CUserInfo::UserDropItem(int nItemIndex, char *pszMakeIndex)
{
	if (!m_pxPlayerObject) return FALSE;

	if (m_lpTItemRcd.GetCount())
	{
		PLISTNODE pListNode = m_lpTItemRcd.GetHead();

		while (pListNode)
		{
			_LPTUSERITEMRCD lpTItemRcd = m_lpTItemRcd.GetData(pListNode);
		
			if (memcmp(pszMakeIndex, lpTItemRcd->szMakeIndex, _MAKEITEMINDEX) == 0)
			{
				if (m_pxPlayerObject->DropItemDown(lpTItemRcd, 2, FALSE))
				{
					m_pxPlayerObject->UpdateItemToDB(lpTItemRcd, _ITEM_ACTION_THROW);

//					delete lpTItemRcd;
					m_lpTItemRcd.RemoveNode(pListNode);

					m_pxPlayerObject->WeightChanged();

					return TRUE;
				}
			}

			pListNode = m_lpTItemRcd.GetNext(pListNode);
		}
	}

	return FALSE;
}