C++ debug_new函数代码示例

// 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;

}

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;
}

void CIntelItemList::Load(ILTMessage_Read *pMsg)
{
	if (!pMsg) return;

	uint16 nCount = pMsg->Readuint16();
	uint16 i = 0;

	for (i=0; i < nCount; i++)
	{
		INTEL_ITEM *pItem = LTNULL;
		if (i < m_IntelArray.size())
		{
			pItem = m_IntelArray[i];
		}
		else
		{
			pItem = debug_new(INTEL_ITEM);
			m_IntelArray.push_back(pItem);
		}
		pItem->nTextId = pMsg->Readuint32();
		pItem->nPopupId = pMsg->Readuint8();
		pItem->bIsIntel = pMsg->Readbool() ? LTTRUE : LTFALSE;
		pItem->nMissionNum = pMsg->Readuint8();

	}
}

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;
}

CWeapons::CWeapons() :
	m_nCurWeapon( -1 )
	, m_pWeapons( LTNULL )
	, m_pAmmo( LTNULL )
{
	m_pVecProjectile = debug_new( CProjectile );
}

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;
}

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);
}

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;
}

CLTGUIColumnCtrl* CMenuPlayer::AddColumnCtrl(uint32 nCommand)
{
	CUIFont* pFont = g_pInterfaceResMgr->GetFont(m_FontFace);

	CLTGUIColumnCtrl* pCtrl=debug_new(CLTGUIColumnCtrl);
    if (!pCtrl->Create(nCommand,LTNULL,pFont,m_FontSize, this))
	{
		debug_delete(pCtrl);
        return LTFALSE;
	}

	pCtrl->SetBasePos(m_nextPos);

	if (nCommand > 0)
	{
		pCtrl->SetColors(m_SelectedColor,m_NonSelectedColor,m_DisabledColor);
		pCtrl->Enable(LTTRUE);
	}
	else
	{
		pCtrl->SetColors(m_NonSelectedColor,m_NonSelectedColor,m_NonSelectedColor);
		pCtrl->Enable(LTFALSE);
	}
	pCtrl->SetScale(g_pInterfaceResMgr->GetXRatio());

	m_List.AddControl(pCtrl);

	return 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;
}

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);

}

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 CDebrisMgr::Init(const char* szAttributeFile)
{
    if (g_pDebrisMgr || !szAttributeFile) return LTFALSE;
    if (!Parse(szAttributeFile)) return LTFALSE;

	g_pDebrisMgr = this;


	// Read in the properties for each debis record...

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

	while (m_buteMgr.Exist(s_aTagName))
	{
		DEBRIS* pDebris = debug_new(DEBRIS);

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

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


    return LTTRUE;
}