userinfo.cpp

真正的传奇源代码

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

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

		while (pListNode)
		{
			_LPTGENERALITEMRCD lpTItemRcd = m_lpTGenItemRcd.GetData(pListNode);
		
			if (memcmp(pszMakeIndex, lpTItemRcd->szMakeIndex, _MAKEITEMINDEX) == 0)
			{
				if (m_pxPlayerObject->DropItemDown((_LPTUSERITEMRCD)lpTItemRcd, 2, TRUE))
				{
//					delete lpTItemRcd;
					m_lpTGenItemRcd.RemoveNode(pListNode);

					m_pxPlayerObject->WeightChanged();

					return TRUE;
				}
			}

			pListNode = m_lpTGenItemRcd.GetNext(pListNode);
		}
	}

	return FALSE;
}

BOOL CUserInfo::IncGold(int nGold)
{
	if (m_THumanRcd.dwGold + nGold <= BAGGOLD)
	{
		m_THumanRcd.dwGold  += nGold;
		return TRUE;
	}

	return FALSE;
}

BOOL CUserInfo::DecGold(int nGold)
{
	if (m_THumanRcd.dwGold - nGold >= 0)
	{
		m_THumanRcd.dwGold  -= nGold;
		return TRUE;
	}

	return FALSE;
}

_LPTHUMANMAGICRCD CUserInfo::GetMagicRcdByKey(int nKey)
{
	PLISTNODE pListNode = m_lpTMagicRcd.GetHead();

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

		if (lptUserMagicRcd)
		{
			if (lptUserMagicRcd->btUseKey == nKey)
				return lptUserMagicRcd;
		}

		pListNode = m_lpTMagicRcd.GetNext(pListNode);
	}

	return NULL;
}

_LPTHUMANMAGICRCD CUserInfo::GetMagicRcdByID(int nID)
{
	PLISTNODE pListNode = m_lpTMagicRcd.GetHead();

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

		if (lptUserMagicRcd)
		{
			if (lptUserMagicRcd->btMagicID == nID)
				return lptUserMagicRcd;
		}

		pListNode = m_lpTMagicRcd.GetNext(pListNode);
	}

	return NULL;
}

_LPTGENERALITEMRCD CUserInfo::CanUseBujuk()
{
	_LPTGENERALITEMRCD lptItem = GetUseGenItem(m_THumanRcd.szTakeItem[U_ARMRINGL]);

	if (lptItem)
	{
		if (lptItem->szMakeIndex[0] == 'G')
		{
			int nIndex = GetGenItemStdIdx(lptItem->szMakeIndex);

			if (g_pStdItemEtc[nIndex].wStdMode == 25 || g_pStdItemEtc[nIndex].wStdMode == 5)
				return lptItem;
		}
	}

	return NULL;
}

void CUserInfo::ProcessUserMessage(char *pszPacket)
{
	_LPTDEFAULTMESSAGE lpDefMsg = (_LPTDEFAULTMESSAGE)pszPacket;

	if (m_pxPlayerObject->m_fIsCapture)
	{
		if (m_pxPlayerObject->m_hCaptureFile)
		{
			DWORD	dwWrite = 0;

			fprintf(m_pxPlayerObject->m_hCaptureFile, "%d, %d, %d, %d, %d\r\n", lpDefMsg->wIdent, lpDefMsg->nRecog, lpDefMsg->wParam, lpDefMsg->wTag, lpDefMsg->wSeries);

			switch (lpDefMsg->wIdent)
			{
//				case CM_SAY:
				case CM_PICKUP:
				{
					char szDecodeMsg[512];
					int nPos = fnDecode6BitBufA(pszPacket + sizeof(_TDEFAULTMESSAGE), szDecodeMsg, sizeof(szDecodeMsg));
					szDecodeMsg[nPos] = '\0';

					fprintf(m_pxPlayerObject->m_hCaptureFile, "%s\r\n", szDecodeMsg);
				}
			}
		}
	}

	switch (lpDefMsg->wIdent)
	{
		case CM_HIT:
		case CM_POWERHIT:
		case CM_LONGHIT:
		case CM_WIDEHIT:
		case CM_HEAVYHIT:
		case CM_BIGHIT:
		case CM_FIREHIT:
			m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, lpDefMsg->wTag, LOWORD(lpDefMsg->nRecog), HIWORD(lpDefMsg->nRecog), lpDefMsg->wParam, NULL);
			break;
		case CM_TURN:
		case CM_WALK:
		case CM_RUN:
		case CM_SITDOWN:
		case CM_RIDE:
			m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, lpDefMsg->wTag, LOWORD(lpDefMsg->nRecog), HIWORD(lpDefMsg->nRecog), NULL);
			break;
/*		case CM_SAY:
			m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, 0, 0, 0, 0, pszPacket + sizeof(_TDEFAULTMESSAGE));
			break;*/
		case CM_SPELL:
			m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, 
														lpDefMsg->wTag/*MagicID*/, LOWORD(lpDefMsg->nRecog)/*TargetX*/, HIWORD(lpDefMsg->nRecog)/*TargetY*/, 
														MAKELONG(lpDefMsg->wSeries, lpDefMsg->wParam)/*TargetObj*/, NULL);
			break;
		case CM_TAKEONITEM:
		case CM_TAKEOFFITEM:
			m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, lpDefMsg->wSeries, lpDefMsg->nRecog, lpDefMsg->wParam, lpDefMsg->wTag, pszPacket + sizeof(_TDEFAULTMESSAGE));
			break;
        case CM_QUERYUSERNAME:
			m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, 0, lpDefMsg->nRecog, lpDefMsg->wParam, lpDefMsg->wTag, NULL);
			break;
		case CM_EAT:
		case CM_DROPITEM:
			m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, lpDefMsg->wSeries, 0, 0, 0, pszPacket + sizeof(_TDEFAULTMESSAGE));
			break;
		case CM_PICKUP:
			m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, lpDefMsg->wSeries, lpDefMsg->nRecog, lpDefMsg->wTag, lpDefMsg->wParam);
			break;
		default:
			m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, lpDefMsg->wSeries, lpDefMsg->nRecog, lpDefMsg->wTag, NULL);
	}
/*	case CM_QUERYUSERNAME:
            begin
               hum.SendMsg (hum, pmsg.Ident, 0, pmsg.Recog, pmsg.Param{x}, pmsg.Tag{y}, '');
            end;

         //string 颇扼皋磐啊 乐澜.
	case CM_DROPITEM:
	case CM_TAKEOFFITEM:
	case CM_EXCHGTAKEONITEM:
	case CM_MERCHANTDLGSELECT:
	case CM_MERCHANTQUERYSELLPRICE:
	case CM_MERCHANTQUERYREPAIRCOST:
	case CM_USERSELLITEM:
	case CM_USERREPAIRITEM:
	case CM_USERSTORAGEITEM:
	case CM_USERBUYITEM:
	case CM_USERGETDETAILITEM:
	case CM_CREATEGROUP:
	case CM_ADDGROUPMEMBER:
	case CM_DELGROUPMEMBER:
	case CM_DEALTRY:
	case CM_DEALADDITEM:
	case CM_DEALDELITEM:
	case CM_USERTAKEBACKSTORAGEITEM:
	case CM_USERMAKEDRUGITEM:
	case CM_GUILDADDMEMBER:
	case CM_GUILDDELMEMBER:
	case CM_GUILDUPDATENOTICE:
	case CM_GUILDUPDATERANKINFO:
         :
            begin
               hum.SendMsg (hum, pmsg.Ident, pmsg.Series, pmsg.Recog, pmsg.Param, pmsg.Tag, DecodeString(body));
            end;
	case CM_ADJUST_BONUS:
         :
            begin
               hum.SendMsg (hum, pmsg.Ident, pmsg.Series, pmsg.Recog, pmsg.Param, pmsg.Tag, body);
            end;
         else
            hum.SendMsg (hum, pmsg.Ident, pmsg.Series, pmsg.Recog, pmsg.Param, pmsg.Tag, '');
      end;
	}
/*
	char				szEncodeMsg[256];

	switch (lpDefMsg->wIdent)
	{
		case CM_TURN:
		{
			if (pUserInfo->m_pxPlayerObject->TurnXY(lpDefMsg->wTag, LOWORD(lpDefMsg->nRecog), HIWORD(lpDefMsg->nRecog)))
				memmove(szEncodeMsg, _MSG_GOOD, sizeof(_MSG_GOOD));
			else
				memmove(szEncodeMsg, _MSG_FAIL, sizeof(_MSG_FAIL));

			ValToAnsiStr(GetTickCount(), &szEncodeMsg[sizeof(_MSG_GOOD) - 1]);
			pUserInfo->m_pxPlayerObject->SendSocket(NULL, szEncodeMsg);
			break;
		}
		case CM_WALK:
		{
			if (pUserInfo->m_pxPlayerObject->WalkTo(lpDefMsg->wTag))
				memmove(szEncodeMsg, _MSG_GOOD, sizeof(_MSG_GOOD));
			else
				memmove(szEncodeMsg, _MSG_FAIL, sizeof(_MSG_FAIL));

			ValToAnsiStr(GetTickCount(), &szEncodeMsg[sizeof(_MSG_GOOD) - 1]);
			pUserInfo->m_pxPlayerObject->SendSocket(NULL, szEncodeMsg);
			break;
		}
		case CM_RUN:
		{
			if (pUserInfo->m_pxPlayerObject->RunTo(lpDefMsg->wTag))
				memmove(szEncodeMsg, _MSG_GOOD, sizeof(_MSG_GOOD));
			else
				memmove(szEncodeMsg, _MSG_FAIL, sizeof(_MSG_FAIL));

			ValToAnsiStr(GetTickCount(), &szEncodeMsg[sizeof(_MSG_GOOD) - 1]);
			pUserInfo->m_pxPlayerObject->SendSocket(NULL, szEncodeMsg);
			break;
		}
/*		case CM_HIT:
		{
			if (HitXY(lpProcessMsg->wIdent, lpProcessMsg->lParam1, lpProcessMsg->lParam2, lpProcessMsg->wParam))
				memmove(szEncodeMsg, _MSG_GOOD, sizeof(_MSG_GOOD));
			else
				memmove(szEncodeMsg, _MSG_FAIL, sizeof(_MSG_FAIL));

			ValToAnsiStr(GetTickCount(), &szEncodeMsg[sizeof(_MSG_GOOD) - 1]);
			SendSocket(NULL, szEncodeMsg);
			break;
		}
		case CM_RIDE:
		{
			if (DoRideHorse(lpProcessMsg->wParam, lpProcessMsg->lParam1))
				memmove(szEncodeMsg, _MSG_GOOD, sizeof(_MSG_GOOD));
			else
				memmove(szEncodeMsg, _MSG_FAIL, sizeof(_MSG_FAIL));

			ValToAnsiStr(GetTickCount(), &szEncodeMsg[sizeof(_MSG_GOOD) - 1]);
			SendSocket(NULL, szEncodeMsg);

			break;
		}
		case CM_SAY:
		{
			if (lpProcessMsg->pszData)
				ProcessForUserSaid(lpProcessMsg);
			break;
		}
		case CM_SPELL:
		{
			if (SpellXY(lpProcessMsg->wParam, lpProcessMsg->lParam1, lpProcessMsg->lParam2, lpProcessMsg->lParam3))
				memmove(szEncodeMsg, _MSG_GOOD, sizeof(_MSG_GOOD));
			else
				memmove(szEncodeMsg, _MSG_FAIL, sizeof(_MSG_FAIL));

			ValToAnsiStr(GetTickCount(), &szEncodeMsg[sizeof(_MSG_GOOD) - 1]);
			SendSocket(NULL, szEncodeMsg);

			break;
		}
		case CM_TAKEONITEM:
		{
			lpProcessMsg->pCharObject->m_tFeature.btGender	= lpProcessMsg->wParam;
			lpProcessMsg->pCharObject->m_tFeature.btWear	= HIBYTE(lpProcessMsg->lParam1);
			lpProcessMsg->pCharObject->m_tFeature.btHair	= LOBYTE(lpProcessMsg->lParam1);
			lpProcessMsg->pCharObject->m_tFeature.btWeapon	= lpProcessMsg->lParam2;

			//AddRefMsg(
			break;
		}
	} */
}

void CUserInfo::Operate()
{
	if (GetTickCount() - m_pxPlayerObject->m_dwSearchTime >= m_pxPlayerObject->m_dwSearchTick)
	{
		m_pxPlayerObject->m_dwSearchTime = GetTickCount();
		m_pxPlayerObject->SearchViewRange();

		if (m_pxPlayerObject->m_btBright != g_nMirDayTime)
		{
			m_pxPlayerObject->m_btBright = g_nMirDayTime;
			m_pxPlayerObject->AddProcess(m_pxPlayerObject, RM_DAYCHANGING, 0, 0, 0, 0, NULL);
		}
	}

	m_pxPlayerObject->Operate();
}

void CUserInfo::CloseUserHuman()
{
	Lock();

	if (m_pxPlayerObject)
	{
		m_THumanRcd.nCX	= m_pxPlayerObject->m_nCurrX;
		m_THumanRcd.nCY	= m_pxPlayerObject->m_nCurrY;

		if (m_pxPlayerObject->m_nDirection >= 0 && m_pxPlayerObject->m_nDirection <= 7)
			m_THumanRcd.nDirection	= m_pxPlayerObject->m_nDirection;
		else
			m_THumanRcd.nDirection	= 4;

		if (m_pxPlayerObject->m_pMap)
		{
			ZeroMemory(m_THumanRcd.szMapName, sizeof(m_THumanRcd.szMapName));
			memcpy(m_THumanRcd.szMapName, m_pxPlayerObject->m_pMap->m_szMapName, memlen(m_pxPlayerObject->m_pMap->m_szMapName));
		}

		m_THumanRcd.szLevel = m_pxPlayerObject->m_Ability.Level;
		m_THumanRcd.nExp	= m_pxPlayerObject->m_Ability.Exp;
		m_THumanRcd.nExp	= m_pxPlayerObject->m_Ability.Exp;

		// Save Player Information Data
		SaveHumanToDB("192.168.0.200");
	}

	if (m_pxPlayerObject)
	{										  
		PLISTNODE pVisibleObjListNode = m_pxPlayerObject->m_xVisibleObjectList.GetHead();

		while (pVisibleObjListNode)
		{
			CVisibleObject* pVisibleObject = m_pxPlayerObject->m_xVisibleObjectList.GetData(pVisibleObjListNode);

			if (pVisibleObject) 
			{
				delete pVisibleObject;
				pVisibleObject = NULL;
			}

			pVisibleObjListNode = m_pxPlayerObject->m_xVisibleObjectList.RemoveNode(pVisibleObjListNode);
		}

		m_pxPlayerObject->m_pMap->RemoveObject(m_pxPlayerObject->m_nCurrX,m_pxPlayerObject->m_nCurrY,
												OS_MOVINGOBJECT, m_pxPlayerObject);
		
		m_pxPlayerObject->m_fIsAlive = FALSE;
	}

	PLISTNODE pListNode;

	// Remove User Item
	if (m_lpTItemRcd.GetCount())
	{
		pListNode = m_lpTItemRcd.GetHead();

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

			if (lpUserItemRcd) 
			{
				delete lpUserItemRcd;
				lpUserItemRcd = NULL;
			}

			pListNode = m_lpTItemRcd.RemoveNode(pListNode);
		}
	}

	// Remove General User Item
	if (m_lpTGenItemRcd.GetCount())
	{
		pListNode = m_lpTGenItemRcd.GetHead();

		while (pListNode)
		{
			_LPTGENERALITEMRCD lpGenItemRcd = m_lpTGenItemRcd.GetData(pListNode);

			if (lpGenItemRcd) 
			{
				delete lpGenItemRcd;
				lpGenItemRcd = NULL;
			}

			pListNode = m_lpTGenItemRcd.RemoveNode(pListNode);
		}
	}

	// Remove User Magic Information
	if (m_lpTMagicRcd.GetCount())
	{
		pListNode = m_lpTMagicRcd.GetHead();

		while (pListNode)
		{
			_LPTHUMANMAGICRCD lpMagicRcd = m_lpTMagicRcd.GetData(pListNode);

			if (lpMagicRcd) 
			{
				delete lpMagicRcd;
				lpMagicRcd = NULL;
			}

			pListNode = m_lpTMagicRcd.RemoveNode(pListNode);
		}
	}

	if (m_pxPlayerObject)
		CloseAccount(m_szUserID, m_nCertification);

	m_bEmpty = true;
	Unlock();

	UpdateStatusBarUsers(FALSE);
}

void CUserInfo::SaveHumanToDB(char *pszUserAddr)
{
	_TDEFAULTMESSAGE	Def;
	_TLOADHUMAN			tLoadHuman;
	char				szEncodeMsg1[24];
	char				szEncodeMsg2[8192];

	fnMakeDefMessage(&Def, DB_SAVEHUMANRCD, (int)this, m_lpTMagicRcd.GetCount(), m_lpTGenItemRcd.GetCount(), 0);

	memcpy(tLoadHuman.szUserID, m_szUserID, memlen(m_szUserID));
	memcpy(tLoadHuman.szCharName, m_szCharName, memlen(m_szCharName));
	memcpy(tLoadHuman.szUserAddr, pszUserAddr, memlen(pszUserAddr));
	tLoadHuman.nCertification	= m_nCertification;
	
	int nPos = fnEncodeMessageA(&Def, szEncodeMsg1, sizeof(szEncodeMsg1));
	szEncodeMsg1[nPos] = '\0';
	nPos = fnEncode6BitBufA((unsigned char *)&tLoadHuman, szEncodeMsg2, sizeof(_TLOADHUMAN), sizeof(szEncodeMsg2));
	nPos += fnEncode6BitBufA((unsigned char *)&m_THumanRcd, &szEncodeMsg2[nPos], sizeof(_THUMANRCD), sizeof(szEncodeMsg2) - nPos);

	// BEGIN:Add Magic Information
	EncodeMyMagicToServer(szEncodeMsg2, sizeof(szEncodeMsg2) - nPos, nPos);
	// END

	// BEGIN:Add General Item Information
	EncodeGenItem(szEncodeMsg2, sizeof(szEncodeMsg2) - nPos, nPos);
	// END

	szEncodeMsg2[nPos] = '\0';

	SendRDBSocket(tLoadHuman.nCertification, szEncodeMsg1, szEncodeMsg2, nPos);
}

void CUserInfo::CloseAccount(char *pszName, int nCertification)
{
	char	szMsg[256];
	int		nLen = memlen(pszName) - 1;

	szMsg[0] = '%';
	szMsg[1] = 'S';

	memcpy(&szMsg[2], pszName, nLen);

	szMsg[nLen + 2] = '/';

	char *pszPos = ValToAnsiStr(nCertification, &szMsg[nLen + 3]);

	*pszPos++	= '$';
	*pszPos		= '\0';

	send(g_clsock, szMsg, memlen(szMsg) - 1, 0);
}

void CUserInfo::DoClientCertification(char *pszPacket)
{
	char szDecodePacket[64];
	char *pszDecodePacket = &szDecodePacket[0];
	char *pszPos;

	if (m_btCurrentMode == USERMODE_NOTICE)
	{
		int nLen = memlen(pszPacket);

		if (pszPos = (char *)memchr(pszPacket, '!', nLen))
		{
			*pszPos = '\0';

			//             uid  chr	 cer  ver  startnew
			// pszPacket **SSSS/SSSS/SSSS/SSSS/1
			nLen = fnDecode6BitBufA(pszPacket + 2, szDecodePacket, sizeof(szDecodePacket));
			szDecodePacket[nLen] = '\0';

			if (*pszDecodePacket == '*' && *(pszDecodePacket + 1) == '*')
			{
				pszDecodePacket += 2;

				if (!(pszPos = (char *)memchr(pszDecodePacket, '/', nLen))) return;

				*pszPos++ = '\0';
				nLen -= (pszPos - pszDecodePacket);
				memmove(m_szUserID, pszDecodePacket, (pszPos - pszDecodePacket));
				pszDecodePacket = pszPos;

				if (!(pszPos = (char *)memchr(pszDecodePacket, '/', nLen))) return;

				*pszPos++ = '\0';
				nLen -= (pszPos - pszDecodePacket);
				memmove(m_szCharName, pszDecodePacket, (pszPos - pszDecodePacket));
				pszDecodePacket = pszPos;

				if (!(pszPos = (char *)memchr(pszDecodePacket, '/', nLen))) return;

				*pszPos++ = '\0';
				nLen -= (pszPos - pszDecodePacket);
				m_nCertification = AnsiStrToVal(pszDecodePacket);
				pszDecodePacket = pszPos;

				if (!(pszPos = (char *)memchr(pszDecodePacket, '/', nLen))) return;

				*pszPos++ = '\0';
				nLen -= (pszPos - pszDecodePacket);
				m_nClientVersion = AnsiStrToVal(pszDecodePacket);
				pszDecodePacket = pszPos;

				m_btCurrentMode = USERMODE_LOGIN;
//				(*pszDecodePacket == '0' ? StartNew = TRUE : StartNew = FALSE);

				// INSERT:Check pay bill.

//				if (pUserInfo->m_nCertification >= 30)
//				{

//					LoadPlayer(pUserInfo);
//				}
	/*				else
				{
					// INSERT:Close User
				} */
			}
		}
	}
}