user.h

网络游戏魔域的服务端与客户端完整源代码 包括详细的说明文档与开发日志

	void		SetCheat(int nType, int nLevel);
protected:
	auto_long	m_nCheatLevel;
	auto_long	m_nCheatCount;
	auto_long	m_maskCheat;

	deque<DWORD>	m_setActionTime;

	auto_long	m_dwLastTimeStamp;

protected:
	virtual		I64		SetEffect			(I64 i64Effect)	{ m_data.m_Info.i64Effect |= i64Effect; return m_data.m_Info.i64Effect; }
	virtual		I64		ResetEffect			(I64 i64Effect=0xFFFFFFFFFFFFFFFF)	{ m_data.m_Info.i64Effect &= (~i64Effect); return m_data.m_Info.i64Effect; }

public:
	UserInfoStruct*	GetInfo	(void)		{return &m_data.m_Info;}

	virtual DWORD			GetWeightLimit	();
//	virtual CGameMap*		GetMap			()			{ CHECKF(m_pMap); return m_pMap; }


public: // apply ---------------------------------------------
	enum { 
		APPLY_NONE=0,
		APPLY_FRIEND, 
		APPLY_MARRY, 
		APPLY_TRADE, 
		APPLY_TEAMAPPLY, 
		APPLY_TEAMINVIT,
		APPLY_JOIN_SYN, 
		APPLY_INVITE_JOIN_SYN, 
		APPLY_ALLY_SYN, 

		APPLY_STUDENTAPPLY,		// 申请收徒弟
		APPLY_TEACHERAPPLY,		// 申请拜师
	};

	void	SetApply		(int nApply, OBJID idTarget)	{ m_nApply = nApply; m_idApplyTarget = idTarget; }
	OBJID	FetchApply		(int nApply)					{ if(nApply == m_nApply) { m_nApply = APPLY_NONE; return m_idApplyTarget; } return ID_NONE; }
	bool	FetchApply		(int nApply, OBJID idTarget)	{ if(nApply == m_nApply && idTarget == m_idApplyTarget) { m_nApply = APPLY_NONE; return true; } return false; }
protected:
	int		m_nApply;
	OBJID	m_idApplyTarget;

public:	//-------- 不知道的类型 -----------------------
//	void		InitWalkStep		()				{ m_nWalkStep = 0; }

	void		SetForce			(DWORD dwForce);
	DWORD		GetForce			()				{ return m_data.GetForce();}

	void		SetDexterity		(DWORD dwDex);

	void		SetSpeed			(DWORD dwSpeed);
	DWORD		GetSpeed			()				{ return m_data.GetSpeed();}
	// 根据状态调整速度
	DWORD		AdjustSpeed			(int nSpeed);

	void		SetHealth			(DWORD dwHealth);
	DWORD		GetHealth			()				{ return m_data.GetHealth();}

	void		SetSoul				(DWORD dwSoul);
	DWORD		GetSoul				()				{ return m_data.GetSoul();}
	DWORD		GetSoulSum			();

	void		SetFace				(DWORD dwFace);
	DWORD		GetFace				()				{ return (m_data.GetLookFace()/10000)%1000; }
	void		SetLook				(DWORD dwLook);

	void		ClsXpVal			(bool bSynchro = SYNCHRO_TRUE);
	void		ProcXpVal			();
	bool		IsFullXp			()				{ return m_dwXP >= MAX_USER_XP; }
	bool		BurstXp				();
	void		SetXp				(int nXp);
	void		AddXp				(int nXp);

	OBJID		GetHomeID			()				{ return m_data.GetHomeID(); }
	OBJID		GetMateHomeID();

	int			GetRace				()				{ if(GetLook(GetLookFace()) > 6) return RACE_NONE; return (GetLook(GetLookFace())+1) / 2; }

	void		ProcSlowHealLifeUp	();
	void		ProcSlowHealManaUp	();
	void		ProcAutoHealLife	();		// 每隔5秒自动补血，跑跳不补血

#ifdef _DEBUG
	void		SetName	(const char* pszName)	{ m_data.SetName(pszName); }
#endif

public: // profession
	DWORD		GetProfession		()	{ return m_data.GetProfession(); }
	DWORD		GetProfessionSort	()	{ return (m_data.GetProfession()%1000)/10; }
	DWORD		GetProfessionLevel	()	{ return m_data.GetProfession()%10; }

public:	//---------- USER专有的战斗函数 ----------------------
	void		IncAddPoint			(int nAddPoint);
	void		SetExp				(int nExp)				{m_data.SetExp(nExp);}
	void		CalcFightRate		()						{ m_nFightRate = GetInterAtkRate(); }
	void		ProcessAutoAttack	();
	int			GetDelay			()						{ return m_nFightPause; }
	void		SetDelay			(int nDelay)			{ m_nFightPause = nDelay; }
	int			AdjustExp			(IRole* pTarget, int nRawExp, bool bNewbieBonusMsg=false);
	bool		CheckCrime			(IRole* pRole);		
	bool		IsImmunity			(IRole* pRole);		

public:	//--------- 队伍管理 --------------------------------
	BOOL		CreateTeam			();
	BOOL		AcceptTeamMember	(CUser* pMemeber);
	BOOL		AcceptTeamInvit		(CUser* pLeader);
	BOOL		QuitTeam			();
	BOOL		DismissTeam			();
	BOOL		KickOut				(OBJID idMember);
	void		SetTeam				(CTeam* pTeam);
	void		ClrTeam				();
	CTeam*		GetTeam				();
	void		ProcessTeamTimer	();
	void		SendShow			(CUser* pNewMember);
	void		AppendTeam			(TeamInfoStruct* pInfo);
protected: // IChangeTeam
	virtual bool AddTeamMember(OBJID idUser);
	virtual bool DelTeamMember(OBJID idUser);
	virtual bool DelTeam();
	virtual bool SendInfo(SOCKET_ID idSocket, OBJID idAgent);		// agent overload

private:
	CTeam*		m_pTeam;
	CTimeOut	m_tTeam;

	

public: //--------- 玩家行为 --------------------------
	int			GetPk				()				{ return m_data.GetPk(); }
	int			IncPk				()				{ return AddPk(PKVALUE_ONEKILL); }
	int			GetPkMode			()				{ return m_data.m_Info.ucPkMode; }
	void		SetPkMode			(int nMode)		{ m_data.m_Info.ucPkMode = nMode; }
	bool		IsPkEnable			(IRole* pRole);
	bool		IsGhost				()				{ return m_bGhost; }
	void		Reborn				(bool bChgPos=true);
	void		TransformGhost		();
	int			CalcExpLostOfDeath	(IRole* pKiller);

protected:
	bool		m_bGhost;

public:	// 可用于任务系统
	int			AddPk				(int nAdd);
	void		ProcessPkTimer		(void);			// auto synchro
	void		SendSystemBBS		(LPCTSTR szText);

public: // item ------------------------------------------
	enum { IDENT_OK = true, NO_COMBINE=false, };
	CItem*	AwardItem		(int nItemType, bool bSynchro, bool bIdentOK=false, bool bAutoCombine=true);		// 同时操作数据库
	CItem*	AwardItem		(ItemInfoStruct* pInfo, bool bSynchro, bool bAutoCombine=true);		// 同时操作数据库
	bool	EraseItem		(OBJID idItem, bool bSynchro);			// 同时操作数据库
	bool	EraseEquip		(int nPosition, bool bSynchro);			// 同时操作数据库
	CItem*	GetItem			(OBJID idItem);
	CItem*	GetItemByType	(OBJID idItemType);
	CItem*	GetEquipItem	(OBJID idItem);
	CItemPtr*	GetEquipItemPtr	(int nPosition);
	CItemPtr&	GetEquipItemRef	(int nPosition)						{ CItemPtr* ppEquip = GetEquipItemPtr(nPosition); ASSERT(ppEquip); return *ppEquip; }
	CItem*	GetEquipItemByPos	(int nPosition);
	bool	AddItem			(CItem* pItem, bool bSynchro, bool bUpdate = true);
	bool	DelItem			(OBJID idItem, bool bSynchro);
	bool	DelItemPt		(OBJID idItem);							// 只删除指针
	CItem*	PopItem			(OBJID idItem, bool bSynchro, bool bUpdate);			// 立即清除OWNER
	bool	TryItem			(OBJID idItem, int nPosition);
	bool	ChkUseItem		(CItem* pItem, IRole* pTarget);
	bool	UseItem			(OBJID idItem, int nPosition, bool bSynchro);
	bool	UseItemTo		(OBJID idTarget, OBJID idItem);			// 对别人使用物品 -- zlong 2004.09.23
	bool	UserItemToByType(OBJID idTarget, OBJID idType);			// 根据物品类型对别人使用物品——用于武器附带的魔魂宝石攻击效果
	bool	UnEquipItem		(int nPosition, bool bSynchro);
	bool	SplitItem		(OBJID idItem, int nNum);
	bool	CombineItem		(OBJID idItem, OBJID idOther);
	CItem*	FindCombineItem	(OBJID idType);
	CItem*	CombineNewItem	(CItem* pItem, ItemInfoStruct* pInfo, bool bSynchro);
	bool	PickMapItem		(OBJID idItem);
	bool	DropItem		(OBJID idItem, int x, int y);
	bool	DropMoney		(DWORD dwMoney, int x, int y);
	bool	RepairItem		(OBJID idItem, bool bSynchro);
	bool	RepairAll		(bool bSynchro);
	bool	IdentItem		(OBJID idItem, bool bSynchro);
	CItem*	GetTaskItem		(LPCTSTR szItemName);
	CItem*	GetTaskItemByType		(OBJID idItemType, int nAmount=0);
	bool	IsItemFull		(int nWeight, OBJID idItemType, DWORD dwData);	//					{ return !IsBackPackSpare(1, nWeight); }
	bool	IsBackPackSpare	(int nNum, int nWeight, OBJID idItemType, DWORD dwData)		{ return m_pPackage->IsPackSpare(nNum, idItemType, dwData); }		//{ if(nWeight && GetWeight()+nWeight > GetWeightLimit() || nNum && m_setItem.size()+nNum > _MAX_USERITEMSIZE) return false; return true; }
	int		GetWeight		();
	CItem*	FindSpaceTransSpell();
	void	AddEquipmentDurability		(int nPosition, int nAddValue);
	bool	MultiDelItem(OBJID idTypeFirst, OBJID idTypeLast, int nNum);
	bool	MultiCheckItem(OBJID idTypeFirst, OBJID idTypeLast, int nNum);
	bool	DecEquipmentDurability(bool bBeAttack, bool bMagic, int bDurValue=1);
	bool	SpendItemByType	(OBJID idType, bool bSynchro);
	bool	SpendEquipItem	(int nSubType, int nNum, bool bSynchro);
	virtual bool	SpendArrow();
	bool	SpendItem(CItem* pItem, int nNum=1, int nPosition=ITEMPOSITION_BACKPACK, bool bSynchro=true);	// may be erase
protected:
	bool	EquipItem		(CItem* pItem, int nPosition, bool bSynchro);
	CItem*	UnEquipOnly		(int nPosition);
	void	UpdateWeight	();
	void	UpdateEquipmentDurability	();
protected:
	bool	CreateAllItem	(IDatabase* pDb);
	void	SaveItemInfo	();
	void	DeleteAllItem	();
	void	SendAllItemInfo	();
public: // msgitem
	void	SendAllEquipInfoTo(CUser* pTarget);
	void	BuyItem			(OBJID idNpc, OBJID idType);
	void	SellItem		(OBJID idNpc, OBJID idItem);
protected: // member
	bool	m_bUpdateWeight;		// false: m_nAllWeight值无效，需要重新计算
	int		m_nAllWeight;			// 当前总负重量的CACHE
	int		m_idxLastArrow;

public: // task & action -------------------------------------------------------------------------------
	void	ClearTaskID		()									{ m_setTaskID.clear(); m_setIterID.clear(); }
	void	SetTaskNpcID	(OBJID idNpc)						{ m_idTaskNpc = idNpc; }
	void	SetTaskItemID	(OBJID idItem)						{ m_idTaskItem = idItem; }
	OBJID	GetTaskItemID	()									{ return m_idTaskItem; }
	OBJID	GetTaskItemActionID()								{ return m_idTaskItemAction; }
	void	SetTaskItemActionID(OBJID idAction)					{ m_idTaskItemAction = idAction; }
	bool	TestTask		(CTaskData* pTask);
	bool	ProcessTask		(int idx, LPCTSTR pszAccept);
	bool	ProcessClientTask(OBJID idTask, LPCTSTR pszAccept);
//	bool	ProcessAction	(OBJID idAction, IRole* pRole = NULL, CItem* pItem = NULL, LPCTSTR pszAccept = NULL);
	bool	DebugShowAction	()									{ m_bDebugAction = !m_bDebugAction; return m_bDebugAction; }
	int&	TaskIterator	()									{ return m_nTaskIterator; }
//	void	ReplaceAttrStr		(char* pszTarget, const char* pszSource, IRole* pRole = NULL);
	int		PushTaskID			(OBJID idTask)					{ if(idTask!=ID_NONE && m_setTaskID.size() < MAX_MENUTASKSIZE) return m_setTaskID.push_back(idTask), m_setTaskID.size()-1; return INDEX_NONE; }

	int		PushTaskID			(OBJID idTask, OBJID idIter);
	CUserData* QueryDataForAction()								{ return &m_data; }
	void 	SetRecordPos	(OBJID idMap, DWORD dwX, DWORD dwY, BOOL bUpdate = false);

	void	AddTaskMask		(int idx);
	void	ClrTaskMask		(int idx);
	bool	ChkTaskMask		(int idx);

	// ========= 佣兵任务相关 ============
	bool	AcceptMercenaryTask(OBJID idTask);
	bool	CancelMercenaryTask(OBJID idTask);
	bool	CompleteMercenaryTask(OBJID idTask, OBJID idItem);
	// ===================================

protected:
	OBJID	GetTaskID			(int idx)						{ if(idx >= 0 && idx < m_setTaskID.size()) return m_setTaskID[idx]; return ID_NONE; }
	bool	CheckItem			(CTaskData* pTask);
	void	SetIterID			(int idx)						{ if(idx >= 0 && idx < m_setIterID.size()) m_nTaskIterator = m_setIterID[idx]; }

protected:
	vector<OBJID>			m_setTaskID;
	vector<OBJID>			m_setIterID;
	OBJID					m_idTaskNpc;
	OBJID					m_idTaskItemAction;		// for idTaskItem
	OBJID					m_idTaskItem;
	bool					m_bDebugAction;				// 是否给GM显示每条ACTION的执行细节
	int						m_nTaskIterator;			// 用于在任务系统中叠代
	
public:	// wanted
	WantedInfoStruct& WantedInfo(void)		{ return m_data.GetInfo().infoWanted; }
	void	ResetWantedInfo(void)	{ memset(&m_data.GetInfo().infoWanted, 0L, sizeof(WantedInfoStruct)); }
	OBJID&	PoliceWantedID()	{ return m_data.GetInfo().idPoliceWanted; }
	void	TeamHuntKill		(OBJID idTarget, int nTargetLev, const char* pszTargetName);
	bool	IsMyWantedTarget	(CUser* pTarget);
	bool	IsPoliceWantedTarget(CUser* pTarget);

public: // magic ------------------------------------------------------------------------------------
	bool		SendAllMagicInfo()		{ return m_pMagic->SendInfoToClient(); }
	CMagic*		QueryMagic()			{ CHECKF(m_pMagic); return m_pMagic; }
	static bool	IsInCircle(POINT pos, POINT posCenter, int nRange)	{ return sqrt((double)(posCenter.x-pos.x)*(posCenter.x-pos.x) + (double)(posCenter.y-pos.y)*(posCenter.y-pos.y)) < nRange+.9; }
//	bool		IsInFan(POINT pos, POINT posSource, int nRange, int nWidth, POINT posMidline);
	bool		IsArrowPass(int x, int y, int nAlt=ARROW_FLY_ALT);
	bool		IsJumpPass(int x, int y, int nAlt);
	bool		EquipMagicItem(CItem* pItem, int nPosition);
	bool		UnequipMagicItem(int nPosition);
	void		CalcSupermanKills();
	void		SynchroSupermanOrder(int nOrder);
	int			GetSupermanAddSecs()			{ return m_nSupermanOrder; }
	void		QuerySupermanSecs();
	void		QuerySupermanList(int nIndex, OBJID idAction, int nNumber);
protected:
	CMagic*		m_pMagic;
	int			m_nCurrSupermanKills;
	int			m_nTopSupermanKills;
	int			m_nSupermanOrder;

public: // Transformation ----------------------------------------
	bool		Transform(DWORD dwType, int nKeepSecs, bool bSynchro=true);
	CTransformation* QueryTransformation()		{ return m_pTransformation; }
	void		AbortTransform();
	bool		SynchroTransform();
protected:
	CTransformation*		m_pTransformation;
	CTimeOut				m_tTransformation;

public: // call pet -----------------------------------------------
	bool		CallPet(OBJID idMonsterType, int x, int y, int nKeepSecs=0);
	CMonster*	QueryCallPet()			{ return m_pCallPet; }
	void		KillCallPet(bool bNow=false);
	OBJID		GetCallPetID();
protected:
	CAutoLink<CMonster>		m_pCallPet;			// may be null
	CTimeOut				m_tCallPet;			// no active for keep alive

	//---任务系统---begin
	CTaskDetail	*	m_pTaskDetail;
	//---任务系统---end

public: // eudemon -- zlong 2004-02-05  -----------------------------------------------
	bool		CreateEudemon(CItem* pItem, int x, int y);
	void		CallBackEudemon(OBJID idItem, bool bNow=true);
	//========
	int			GetEudemonAmount()			{ return m_setEudemon.size(); }
	CMonster*	QueryEudemonByIndex(int nIdx);
	CMonster*	QueryEudemonByID(OBJID idEudemon);
	CMonster*	QueryEudemon(OBJID idItem);
	//========

	bool		HatchEudemon(CItem* pItem);
	bool		EvolveEudemon(OBJID idEudemonItem, int nType);
	bool		Evolve2Eudemon(OBJID idEudemonItem, int nType);
	bool		RebornEudemon(OBJID idEudemonItem, OBJID idGem);
	bool		EnhanceEudemon(OBJID idEudemonItem, OBJID idGem);

	void		AwardEudemonExp(OBJID idItem, int nExp, bool bGemEffect = true);

	bool		AttachEudemon(OBJID idItem);
	void		DetachEudemon(CItem* pItem = NULL);