void CMenuMission::Term()
{

	//take anything we've cached out of the list, so that we
	// don't try to delete them twice
	RemoveObjectives();

	//delete our cache
	ControlArray::iterator iter = m_Objectives.begin();
	while (iter != m_Objectives.end())
	{
		debug_delete(*iter);
		iter++;
	}
	m_Objectives.clear();

	if (m_pObjLabel)
	{
		debug_delete(m_pObjLabel);
		m_pObjLabel = LTNULL;
	}
	if (m_pParameters)
	{
		debug_delete(m_pParameters);
		m_pParameters = LTNULL;
	}

	CBaseMenu::Term();
}

void CHUDMessageQueue::Term()
{
	MessageArray::iterator iter = m_ActiveMsgs.begin();
	while (iter !=  m_ActiveMsgs.end())
	{
		CHUDMessage *pMsg = (*iter);
		pMsg->Destroy();
		debug_delete(pMsg);
		iter++;
	}

	iter = m_HistoryMsgs.begin();
	while (iter !=  m_HistoryMsgs.end())
	{
		CHUDMessage *pMsg = (*iter);
		pMsg->Destroy();
		debug_delete(pMsg);
		iter++;
	}

	MCArray::iterator mcIter = m_History.begin();
	while (mcIter != m_History.end())
	{
		debug_delete((*mcIter));
		mcIter++;
	}


}

// Creation
LTBOOL CListCtrl::Create ( int nHeight, LTBOOL bUseArrows, int nArrowOffset)
{
	m_nHeight=nHeight;
    m_bCreated=LTTRUE;

	if (bUseArrows)
	{
        m_bArrows       = LTTRUE;
		m_nArrowOffset	= nArrowOffset;
		//Add Server Arrows
		m_pUp = debug_new(CBitmapCtrl);
        if (!m_pUp->Create(g_pLTClient,"interface\\ListArrowUp.pcx","interface\\ListArrowUpH.pcx","interface\\ListArrowUpD.pcx"))
		{
			debug_delete(m_pUp);
            m_pUp = LTNULL;
		}

		m_pDown = debug_new(CBitmapCtrl);
        if (!m_pDown->Create(g_pLTClient,"interface\\ListArrowDn.pcx","interface\\ListArrowDnH.pcx","interface\\ListArrowDnD.pcx"))
		{
			debug_delete(m_pDown);
            m_pDown = LTNULL;
		}

	}

    return LTTRUE;
}

LTBOOL CHUDMessageQueue::Init()
{
	UpdateLayout();

	g_pLTClient->RegisterConsoleProgram("SimulateChat", SimulateChatFn);

	ASSERT(m_nMaxActiveMsgs);
	if (!m_nMaxActiveMsgs) return LTFALSE;

	m_ActiveMsgs.reserve(m_nMaxActiveMsgs);
	m_HistoryMsgs.reserve(m_nMaxHistoryMsgs);

	m_History.reserve(32);


	MsgCreate fmt = m_MsgFormat;
	fmt.sString = "";
	fmt.fDuration = 0.0f;

	for (int i = 0; i < m_nMaxActiveMsgs; i++)
	{
		CHUDMessage *pMsg = debug_new(CHUDMessage);
		if (pMsg->Create(fmt))
		{
			pMsg->Show(LTFALSE);
			m_ActiveMsgs.push_back(pMsg);
		}
		else
		{
			debug_delete(pMsg);
		}
	}

	for (i = 0; i < m_nMaxHistoryMsgs; i++)
	{
		CHUDMessage *pMsg = debug_new(CHUDMessage);
		if (pMsg->Create(fmt))
		{
			pMsg->Show(LTFALSE);
			m_HistoryMsgs.push_back(pMsg);
		}
		else
		{
			debug_delete(pMsg);
		}
	}

	return LTTRUE;

}

uint16 CBaseMenu::AddControl (char *pString, uint32 commandID, LTBOOL bStatic)
{
	CUIFont* pFont = g_pInterfaceResMgr->GetFont(m_FontFace);
	if (!pFont) return -1;

	CLTGUITextCtrl* pCtrl=debug_new(CLTGUITextCtrl);
    if (!pCtrl->Create(pString, commandID, LTNULL, pFont, m_FontSize, this))
	{
		debug_delete(pCtrl);
        return -1;
	}

	pCtrl->SetBasePos(m_nextPos);
	if (bStatic)
	{
		pCtrl->SetColors(m_NonSelectedColor,m_NonSelectedColor,m_NonSelectedColor);
		pCtrl->Enable(LTFALSE);
	}
	else
		pCtrl->SetColors(m_SelectedColor,m_NonSelectedColor,m_DisabledColor);
	pCtrl->SetScale(g_pInterfaceResMgr->GetXRatio());

	return m_List.AddControl(pCtrl);

}

CAnimationTreePacked* CAnimationTreePackedMgr::CreateAnimationTreePacked( const char* pszFilename )
{
	// Create a new tree.

	CAnimationTreePacked* pTree = debug_new( CAnimationTreePacked );

	// Bail if we fail to load the specified packed anim tree file.

	CAnimationTreePackedLoader Loader;
	if( !Loader.LoadAnimationTreePacked( pTree, pszFilename ) )
	{
		debug_delete( pTree );
		return NULL;
	}

	// Assign the new tree a unique ID.

	pTree->m_eTreeID = (AT_TREE_ID)m_iNextTreeID;
	++m_iNextTreeID;

	// Assign global transition IDs.
	// These IDs allow searching for transitions across multiple trees.

	AssignGlobalTransitionIDs( pTree );

	// Add the new tree to the list.

	m_lstAnimTrees.push_back( pTree );
	return pTree;
}

void CClientFXDB::Term()
{
	//empty out our types
	debug_deletea(m_pEffectTypes);
	m_pEffectTypes		= NULL;
	m_nNumEffectTypes	= 0;

	// Delete all the FX groups
	CLinkListNode<FX_GROUP *> *pGroupNode = m_collGroupFX.GetHead();

	while (pGroupNode)
	{
		//delete all the key property lists
		for(uint32 nCurrKey = 0; nCurrKey < pGroupNode->m_Data->m_nNumKeys; nCurrKey++)
		{
			if(m_pfnFreePropList)
			{
				m_pfnFreePropList(pGroupNode->m_Data->m_pKeys[nCurrKey].m_pProps);
				pGroupNode->m_Data->m_pKeys[nCurrKey].m_pProps = NULL;
			}
		}

		debug_delete( pGroupNode->m_Data );		
		pGroupNode = pGroupNode->m_pNext;
	}
	m_collGroupFX.RemoveAll();

	UnloadFxDll();
}

Prop::~Prop()
{
	ClearTouchSoundIfDone( LTTRUE );
	ClearHitSoundIfDone( LTTRUE );

	debug_delete(m_pDisturb);
}

CScreenSprite * CScreenSpriteMgr::CreateScreenSprite(char * pFile, bool bExpires, ScreenSpriteLayer eLayer)
{
	// Make sure the ScreenSpriteMgr is operational
	if (!m_bInitialized)
		Init();

	CScreenSprite * pSpr = debug_new(CScreenSprite);
	pSpr->Init();

	bool bResult = GiveSpriteResources(pSpr, pFile);

	if (!bResult)
	{
		debug_delete(pSpr);
		return LTNULL;
	}

	pSpr->SetExpiration(bExpires);
	pSpr->m_eLayer = eLayer;		// determine the draw-order with the layer number

//	m_SpriteArray.push_back(pSpr);
	ScreenSpriteArray::iterator iter = m_SpriteArray.begin();
	while (iter != m_SpriteArray.end())
	{
		if (pSpr->m_eLayer <= (*iter)->m_eLayer)
		{
			m_SpriteArray.insert(iter, pSpr);
			return pSpr;
		}
		iter++;
	}
	// pSpr didn't come before anything in the array, or the array is empty.  Add it
	m_SpriteArray.push_back(pSpr);	
	return pSpr;
}

// Destroy the control
void CListCtrl::Destroy ( )
{
	m_controlArray.RemoveAll();

	if (m_pUp)
	{
		debug_delete(m_pUp);
        m_pUp = LTNULL;
	}
	if (m_pDown)
	{
		debug_delete(m_pDown);
        m_pDown = LTNULL;
	}
    m_bCreated=LTFALSE;
}

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

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


	// Create and init a new player...

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

	if (!pPlayer->Init(dwPlayerID, dwFlags))
	{
		debug_delete(pPlayer);
        return(LTFALSE);
	}


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

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


	// All done...

	return(pPlayer);
}

LTBOOL BuildPolyDebrisFXList(PolyDebrisFXList & list, CButeMgr & buteMgr,
							char* pTagBase)
{
    if (!pTagBase) return LTFALSE;

	int nNum = 0;
	sprintf(s_aTagName, "%s%d", pTagBase, nNum);

	// Read in the properties for each scale fx...

	while (buteMgr.Exist(s_aTagName))
	{
		CPolyDebrisFX* pFX = debug_new(CPolyDebrisFX);

		if (pFX && pFX->Init(buteMgr, s_aTagName))
		{
			pFX->nId = nNum;
			list.AddTail(pFX);
		}
		else
		{
			debug_delete(pFX);
            return LTFALSE;
		}

		nNum++;
		sprintf(s_aTagName, "%s%d", pTagBase, nNum);
	}

    return LTTRUE;
}

void CMenuMgr::Term()
{
	//term menus
	MenuArray::iterator iter = m_MenuArray.begin();
	while (iter != m_MenuArray.end())
	{
		(*iter)->Term();
		iter++;
	}

	//clear menu array
	m_MenuArray.clear();

	//term menus
	KeyArray::iterator kiter = m_HotKeys.begin();
	while (kiter != m_HotKeys.end())
	{
		debug_delete(*kiter);
		kiter++;
	}

	//clear menu array
	m_HotKeys.clear();

}

CClientInfoMgr::~CClientInfoMgr()
{
    CLIENT_INFO* ptr = LTNULL;
	while (m_pClients)
	{
		ptr = m_pClients->pNext;
		g_pLTClient->FreeString (m_pClients->hstrName);
		debug_delete(m_pClients);
		m_pClients = ptr;
	}

	if (m_hFragString)
	{
		g_pLTClient->FreeString(m_hFragString);
	    m_hFragString = LTNULL;
	}
	if (m_hTeamScore)
	{
		g_pLTClient->FreeString(m_hTeamScore);
	    m_hTeamScore = LTNULL;
	}
	if (m_hOppScore)
	{
		g_pLTClient->FreeString(m_hOppScore);
	    m_hOppScore = LTNULL;
	}

}

LTBOOL CSoundFilterMgr::Init(const char* szAttributeFile)
{
    if (g_pSoundFilterMgr || !szAttributeFile) return LTFALSE;
    if (!Parse(szAttributeFile)) return LTFALSE;

	g_pSoundFilterMgr = this;

	// Read in the properties for each sound filter record...

	int nNum = 0;
	sprintf(s_aTagName, "%s%d", SFM_TAG, nNum);

	while (m_buteMgr.Exist(s_aTagName))
	{
		SOUNDFILTER* pFilter = debug_new(SOUNDFILTER);

		if (pFilter && pFilter->Init(m_buteMgr, s_aTagName))
		{
			pFilter->nId = nNum;
			m_FilterList.AddTail(pFilter);
		}
		else
		{
			debug_delete(pFilter);
            return LTFALSE;
		}

		nNum++;
		sprintf(s_aTagName, "%s%d", SFM_TAG, nNum);
	}


    return LTTRUE;
}

void CLoadingScreen::CreateScaleFX(char *szFXName)
{	
	if( m_pRenderScreen )
		return;

	CScaleFX* pScaleFX = g_pFXButeMgr->GetScaleFX(szFXName);
	if (pScaleFX)
	{
		CBaseScaleFX *pSFX = debug_new(CBaseScaleFX);
		if (!g_pFXButeMgr->CreateScaleFX(pScaleFX,m_vPos, m_vF, LTNULL, &m_rRot, pSFX))
		{
			debug_delete(pSFX);
			return;
		}
		m_SFXArray.Add(pSFX);
		g_pInterfaceMgr->AddInterfaceSFX(pSFX, IFX_NORMAL);				

		//adjust the object's position based on screen res
		HOBJECT hSFX = pSFX->GetObject();
		if (hSFX)
		{
			LTVector vNewPos;
			g_pLTClient->GetObjectPos(hSFX, &vNewPos);
			vNewPos.z;
			g_pLTClient->SetObjectPos(hSFX, &vNewPos);
		}
	}
}

LTBOOL CPropTypeMgr::Init(const char* szAttributeFile)
{
    if (g_pPropTypeMgr || !szAttributeFile) return LTFALSE;
    if (!Parse(szAttributeFile)) return LTFALSE;

	g_pPropTypeMgr = this;


	// Read in the properties for each prop type record...

	int nNum = 0;
	sprintf(s_aTagName, "%s%d", PTMGR_TAG, nNum);

	while (m_buteMgr.Exist(s_aTagName))
	{
		PROPTYPE* pPropType = debug_new(PROPTYPE);

		if (pPropType && pPropType->Init(m_buteMgr, s_aTagName, nNum))
		{
			pPropType->nId = nNum;
			m_PropTypeList.AddTail(pPropType);
		}
		else
		{
			debug_delete(pPropType);
            return LTFALSE;
		}

		nNum++;
		sprintf(s_aTagName, "%s%d", PTMGR_TAG, nNum);
	}


    return LTTRUE;
}

void CClientInfoMgr::RemoveClient (uint32 nID)
{
	if (!m_pClients) return;

	m_nLocalID = 0;
	g_pLTClient->GetLocalClientID (&m_nLocalID);

	// find the client

	CLIENT_INFO* ptr = GetClientByID(nID, false);
	if (!ptr) return;

	if( g_pGameClientShell->ShouldUseRadar() )
	{
		g_pRadar->UpdatePlayerName( nID, "", 0);
	}
	// remove the client from the list

	if (ptr->pNext) 
		ptr->pNext->pPrev = ptr->pPrev;
	if (ptr->pPrev) 
		ptr->pPrev->pNext = ptr->pNext;
	if (m_pClients == ptr) 
		m_pClients = ptr->pNext;

	debug_delete(ptr);

}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CLightCycleMgr::RemoveCyclist
//
//	PURPOSE:	Completely removes a light cycle from the manager
//
// ----------------------------------------------------------------------- //
bool CLightCycleMgr::RemoveCyclist(HOBJECT hObj)
{
	// Since we're removing from the list, we need to walk it manually
	std::vector<LIGHT_CYCLIST*>::iterator iter;
	for(iter=m_collCyclists.begin();iter!=m_collCyclists.end();iter++)
	{
		if((*iter)->hObject == hObj)
		{
			// We found him. Killlllll! KIIIILLLLLLLLL!
			LIGHT_CYCLIST* pCyclist = (*iter);
			debug_delete(pCyclist);

			// Remove from list
			m_collCyclists.erase(iter);

			// Notify the client
			CAutoMessage cMsg;
			cMsg.WriteByte(LCI_REMOVE_CYCLIST);
			cMsg.WriteObject(hObj);
			g_pLTServer->SendToClient(cMsg, MID_LIGHT_CYCLE_INFO, NULL, MESSAGE_GUARANTEED);

			return true;
		}
	}

	return false;
}

CTeam* CTeamMgr::AddTeam(uint32 dwTeamID, char* sTeamName, uint32 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 = debug_new(CTeam);
	if (!pTeam) return(NULL);

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


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

	m_lsTeams.InsertLast(pTeam);


	// All done...

	return(pTeam);
}