teammgr.cpp

Blood 2全套源码

/****************************************************************************
;
;	 MODULE:		TEAMMGR (.CPP)
;
;	PURPOSE:		Team Manager for multiplayer teams
;
;	HISTORY:		12/21/98 [blg] This file was created
;
;	COMMENT:		Copyright (c) 1998, Monolith Productions Inc.
;
****************************************************************************/

// Includes...

#include "TeamMgr.h"


// Functions...

// *********************************************************************** //
// CTeamPlayer

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeamPlayer::Init
//
//	PURPOSE:	Initialization
//
// ----------------------------------------------------------------------- //

DBOOL CTeamPlayer::Init(DDWORD dwPlayerID, DDWORD dwFlags)
{
	// Set simple members...

	m_dwID    = dwPlayerID;
	m_dwFlags = dwFlags;


	// All done...

	return(DTRUE);
}


// *********************************************************************** //
// CTeam

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeam::Init
//
//	PURPOSE:	Initialization
//
// ----------------------------------------------------------------------- //

DBOOL CTeam::Init(DDWORD dwTeamID, char* sTeamName, DDWORD dwFlags)
{
	// Clear simple members...

	Clear();


	// Set simple members...

	m_dwID    = dwTeamID;
	m_dwFlags = dwFlags;

	strncpy(m_sName, sTeamName, TM_MAX_NAME);


	// All done...

	return(DTRUE);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeam::Term
//
//	PURPOSE:	Termination
//
// ----------------------------------------------------------------------- //

void CTeam::Term()
{
	// Delete all of the players...

	DeleteAllPlayers();


	// Clear simple members...

	Clear();
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeam::Reset
//
//	PURPOSE:	Resets our values and all of the players in the list
//
// ----------------------------------------------------------------------- //

void CTeam::Reset()
{
	// Reset our score values...

	m_nScore  = 0;
	m_nFrags  = 0;
	m_nDeaths = 0;


	// Reset all of the players...

	ResetAllPlayers();
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeam::AddPlayer
//
//	PURPOSE:	Adds the given player to the team
//
// ----------------------------------------------------------------------- //

CTeamPlayer* CTeam::AddPlayer(DDWORD dwPlayerID, DDWORD dwFlags)
{
	// Make sure this player doesn't already exist...

	if (GetPlayer(dwPlayerID))
	{
		return(NULL);
	}


	// Create and init a new player...

	CTeamPlayer* pPlayer = new CTeamPlayer;
	if (!pPlayer) return(NULL);

	if (!pPlayer->Init(dwPlayerID, dwFlags))
	{
		delete pPlayer;
		return(DFALSE);
	}


	// Add the new player to our list...

	if (!AddPlayer(pPlayer))
	{
		return(DFALSE);
	}


	// All done...

	return(pPlayer);
}

DBOOL CTeam::AddPlayer(CTeamPlayer* pPlayer)
{
	// Sanity checks...

	if (!pPlayer) return(DFALSE);


	// Add the player to our list...

	m_lsPlayers.InsertLast(pPlayer);


	// All done...

	return(DTRUE);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeam::RemovePlayer
//
//	PURPOSE:	Removes the given player from the team
//
// ----------------------------------------------------------------------- //

DBOOL CTeam::RemovePlayer(DDWORD dwPlayerID)
{
	// Get this player...

	CTeamPlayer* pPlayer = GetPlayer(dwPlayerID);
	if (!pPlayer) return(DFALSE);


	// Remove this player...

	return(RemovePlayer(pPlayer));
}

DBOOL CTeam::RemovePlayer(CTeamPlayer* pPlayer)
{
	// Sanity checks...

	if (!pPlayer) return(DFALSE);


	// Delete this player from the list...

	m_lsPlayers.Delete(pPlayer);


	// Delete the player object...

	delete pPlayer;


	// All done...

	return(DTRUE);
}

DBOOL CTeam::ChangePlayerTeam(DDWORD dwPlayerID, CTeam* pNewTeam, DBOOL bReset)
{
	// Sanity checks...

	if (!pNewTeam) return(DFALSE);


	// Get the player...

	CTeamPlayer* pPlayer = GetPlayer(dwPlayerID);
	if (!pPlayer) return(DFALSE);


	// Change the player's team...

	return(ChangePlayerTeam(pPlayer, pNewTeam, bReset));

}

DBOOL CTeam::ChangePlayerTeam(CTeamPlayer* pPlayer, CTeam* pNewTeam, DBOOL bReset)
{
	// Sanity checks...

	if (!pPlayer) return(DFALSE);
	if (!pNewTeam) return(DFALSE);


	// Delete this player from the list...

	m_lsPlayers.Delete(pPlayer);


	// Reset this player if requested...

	if (bReset)
	{
		pPlayer->Reset();
	}


	// Add this player to the new team...

	if (!pNewTeam->AddPlayer(pPlayer))
	{
		return(DFALSE);
	}


	// All done...

	return(DTRUE);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeam::GetPlayer
//
//	PURPOSE:	Gets the player with the given client handle
//
// ----------------------------------------------------------------------- //

CTeamPlayer* CTeam::GetPlayer(DDWORD dwPlayerID)
{
	// Look for this player...

	CTeamPlayer* pPlayer = GetFirstPlayer();

	while (pPlayer)
	{
		if (pPlayer->GetID() == dwPlayerID)
		{
			return(pPlayer);
		}

		pPlayer = GetNextPlayer(pPlayer);
	}


	// If we get here, this player is not in the team...

	return(NULL);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeam::SetScore
//
//	PURPOSE:	Sets the given score value
//
// ----------------------------------------------------------------------- //

DBOOL CTeam::SetScore(int nScore)
{
	// Set the given score value...

	m_nScore = nScore;

	
	// All done...

	return(DTRUE);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeam::AddScore
//
//	PURPOSE:	Adds the given score value to the team score
//
// ----------------------------------------------------------------------- //

DBOOL CTeam::AddScore(int nScore)
{
	// Add the given score value...

	m_nScore += nScore;

	
	// All done...

	return(DTRUE);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeam::AddFrags
//
//	PURPOSE:	Adds the given frags to the team score
//
// ----------------------------------------------------------------------- //

DBOOL CTeam::AddFrags(DDWORD dwPlayerID, int nFrags)
{
	// Find the player...

	CTeamPlayer* pPlayer = GetPlayer(dwPlayerID);
	if (!pPlayer) return(DFALSE);


	// Add the frags to the player and the team...

	pPlayer->AddFrags(nFrags);
	m_nFrags += nFrags;


	// All done...

	return(DTRUE);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeam::AddDeaths
//
//	PURPOSE:	Adds the given deaths to the team score
//
// ----------------------------------------------------------------------- //

DBOOL CTeam::AddDeaths(DDWORD dwPlayerID, int nDeaths)
{
	// Find the player...

	CTeamPlayer* pPlayer = GetPlayer(dwPlayerID);
	if (!pPlayer) return(DFALSE);


	// Add the frags to the player and the team...

	pPlayer->AddDeaths(nDeaths);
	m_nDeaths += nDeaths;


	// All done...

	return(DTRUE);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeam::ResetPlayers
//
//	PURPOSE:	Resets each player in the team
//
// ----------------------------------------------------------------------- //

void CTeam::ResetAllPlayers()
{
	CTeamPlayer* pPlayer = m_lsPlayers.GetFirst();

	while (pPlayer)
	{
		pPlayer->Reset();
		pPlayer = pPlayer->GetNext();
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeamMgr::SortPlayers
//
//	PURPOSE:	Sorts the players using the given sort key
//
// ----------------------------------------------------------------------- //

void CTeam::SortPlayers(int nSortKey, int nDir)
{
	// Sanity checks...

	if (nSortKey == TM_KEY_SCORE) return;
	if (GetNumPlayers() <= 1) return;


	// Remove each player from our list, and insert it, sorted, into a temp list...

	CTeamPlayerList lsTemp;

	CTeamPlayer* pCurPlr = GetFirstPlayer();

	while (pCurPlr)
	{
		CTeamPlayer* pNextPlr = GetNextPlayer(pCurPlr);

		m_lsPlayers.Delete(pCurPlr);


		// Insert the player from our main list, sorted, into our temp list...

		CTeamPlayer* pTmpPlr = lsTemp.GetFirst();

		if (!pTmpPlr)
		{
			lsTemp.Insert(pCurPlr);
		}
		else
		{
			while (pTmpPlr)
			{
				if (nDir == TM_SORT_DESCENDING && IsGreater(pCurPlr, pTmpPlr, nSortKey))
				{
					lsTemp.InsertBefore(pTmpPlr, pCurPlr);
					pTmpPlr = NULL;
				}
				else if (nDir == TM_SORT_ASCENDING && IsLess(pCurPlr, pTmpPlr, nSortKey))
				{
					lsTemp.InsertBefore(pTmpPlr, pCurPlr);
					pTmpPlr = NULL;
				}
				else
				{
					pTmpPlr = pTmpPlr->GetNext();
					if (!pTmpPlr)
					{
						lsTemp.InsertLast(pCurPlr);
					}
				}
			}
		}

		pCurPlr = pNextPlr;
	}


	// Re-insert all items into our main list...

	CTeamPlayer* pPlr = lsTemp.GetFirst();

	while (pPlr)
	{
		CTeamPlayer* pNextPlr = pPlr->GetNext();
		m_lsPlayers.InsertLast(pPlr);
		pPlr = pNextPlr;
	}
}


// *********************************************************************** //
// CTeamMgr

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeamMgr::Init
//
//	PURPOSE:	Initialization
//
// ----------------------------------------------------------------------- //

DBOOL CTeamMgr::Init()
{
	// Clear all members...

	Clear();


	// All done...

	return(DTRUE);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeamMgr::Term
//
//	PURPOSE:	Termination
//
// ----------------------------------------------------------------------- //

void CTeamMgr::Term()
{
	// Delete all of the teams...

	DeleteAllTeams();


	// Clear all members...

	Clear();
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeamMgr::GetTeam
//
//	PURPOSE:	Gets the team with the given ID
//
// ----------------------------------------------------------------------- //

CTeam* CTeamMgr::GetTeam(DDWORD dwTeamID)
{
	// Look for a team with the given ID...

	CTeam* pTeam = GetFirstTeam();

	while (pTeam)
	{
		if (pTeam->GetID() == dwTeamID)
		{
			return(pTeam);
		}

		pTeam = GetNextTeam(pTeam);
	}


	// If we get here, we didn't find the team...

	return(NULL);
}

CTeam* CTeamMgr::GetTeam(const char* sName)
{
	// Sanity checks...

	if (!sName) return(NULL);
	if (sName[0] == '\0') return(NULL);


	// Look for a team with the given name...

	CTeam* pTeam = GetFirstTeam();

	while (pTeam)
	{
		if (strncmp(pTeam->GetName(), sName, TM_MAX_NAME) == 0)
		{
			return(pTeam);
		}

		pTeam = GetNextTeam(pTeam);
	}


	// If we get here, we didn't find the team...

	return(NULL);
}

CTeam* CTeamMgr::GetTeamFromPlayerID(DDWORD dwPlayerID)
{
	// Look for the player on each team...

	CTeam* pTeam = GetFirstTeam();

	while (pTeam)
	{
		CTeamPlayer* pPlayer = pTeam->GetFirstPlayer();

		while (pPlayer)
		{
			if (pPlayer->GetID() == dwPlayerID)
			{
				return(pTeam);
			}

			pPlayer = pTeam->GetNextPlayer(pPlayer);
		}

		pTeam = GetNextTeam(pTeam);
	}


	// If we get here, we didn't find the player's team...

	return(NULL);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeamMgr::AddTeam
//
//	PURPOSE:	Adds a new team with the given values
//
// ----------------------------------------------------------------------- //

CTeam* CTeamMgr::AddTeam(DDWORD dwTeamID, char* sTeamName, DDWORD dwFlags)
{
	// Make sure this team doesn't already exist...

	if (GetTeam(dwTeamID)) return(NULL);
	if (GetTeam(sTeamName)) return(NULL);


	// Create and init a new team...

	CTeam* pTeam = new CTeam();
	if (!pTeam) return(NULL);

	if (!pTeam->Init(dwTeamID, sTeamName, dwFlags))
	{
		delete pTeam;
		return(NULL);
	}


	// Add the new team to our list...

	m_lsTeams.InsertLast(pTeam);


	// All done...

	return(pTeam);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeamMgr::AddPlayer
//
//	PURPOSE:	Adds a new player to the specified team
//
// ----------------------------------------------------------------------- //

CTeamPlayer* CTeamMgr::AddPlayer(DDWORD dwTeamID, DDWORD dwPlayerID, DDWORD dwFlags)
{
	// Get the team...

	CTeam* pTeam = GetTeam(dwTeamID);
	if (!pTeam) return(NULL);


	// Add the player to the team...

	return(AddPlayer(pTeam, dwPlayerID, dwFlags));
}

CTeamPlayer* CTeamMgr::AddPlayer(char* sTeamName, DDWORD dwPlayerID, DDWORD dwFlags)
{