inventorymgr.cpp

Blood 2全套源码

			return CHWEAP_NOMESSAGE;
		
		m_Weapons[slot] = NULL;

		if (w == m_pCurWeapon)
			m_pCurWeapon = DNULL;
		
	}

	// spawn a weapon pickup, and save it's handle so we don't pick it right
	// up again.
	if (w)
	{
		w->DropHandModel();

		w->Term();
		delete w;
	}
		*/

	return CHWEAP_OK;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::DropCurrentWeapon()
//
//	PURPOSE:	Drops the current weapon
//
// ----------------------------------------------------------------------- //

int CInventoryMgr::DropCurrentWeapon()
{
	CServerDE* pServerDE = BaseClass::GetServerDE();

	// Only drop weapons in single player
	if (g_pBloodServerShell->GetGameType() != GAMETYPE_SINGLE)
		return CHWEAP_NOMESSAGE;

	DBOOL bLeftHand = DFALSE;

	//sanity check
	if(m_pCurWeapon == DNULL)
		return CHWEAP_NOTAVAIL;

	// Can't drop it unless it's in your hand
	if( !m_pCurWeapon->GetHandModel( ))
		return CHWEAP_NOTAVAIL;

	// Can't drop a weapon while it's busy
	if (m_pCurWeapon && !m_pCurWeapon->IsIdle())
		return CHWEAP_WEAPONBUSY;

	// Can't drop the melee weapon
	if (m_pCurWeapon->GetType() == WEAP_MELEE)
		return CHWEAP_NOMESSAGE;


	CWeapon *w;

	// Drop the left-handed weapon if we have it.
	if (m_LWeapons[m_nCurWeaponSlot])
	{
		w = m_LWeapons[m_nCurWeaponSlot];
		m_LWeapons[m_nCurWeaponSlot] = NULL;
		bLeftHand = DTRUE;
		if (m_pLViewModel) 
			m_pLViewModel->SetVisible(DFALSE);

		if (w == m_pCurWeapon)
			m_pCurWeapon = m_Weapons[m_nCurWeaponSlot];
	}
	else
	{
		w = m_Weapons[m_nCurWeaponSlot];
		m_Weapons[m_nCurWeaponSlot] = NULL;
		if (m_pViewModel)
			m_pViewModel->SetVisible(DFALSE);

		if (w == m_pCurWeapon)
			m_pCurWeapon = DNULL;
	}

	// spawn a weapon pickup
	if (w)
	{
		w->DropHandModel();
		w->Term();
		delete w;
	}

	return CHWEAP_OK;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::HasWeapon()
//
//	PURPOSE:	Checks to see if the player has a specific weapon
//
// ----------------------------------------------------------------------- //

DBOOL CInventoryMgr::HasWeapon(DDWORD nWeapon)
{
	for(int i = 0; i < SLOTCOUNT_TOTALWEAPONS; i++)
	{
		if(m_Weapons[i] && m_Weapons[i]->GetType() == nWeapon)
			return DTRUE;
	}

	return DFALSE;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::ShowHandModels()
//
//	PURPOSE:	
//
// ----------------------------------------------------------------------- //

void CInventoryMgr::ShowHandModels(DBOOL bShow)
{
	if (m_Weapons[m_nCurWeaponSlot])
		m_Weapons[m_nCurWeaponSlot]->ShowHandModel(bShow);
	if (m_LWeapons[m_nCurWeaponSlot])
		m_LWeapons[m_nCurWeaponSlot]->ShowHandModel(bShow);
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::SetStrength()
//
//	PURPOSE:	Sets strength and checks to see if your inventory is ok.
//
// ----------------------------------------------------------------------- //

void CInventoryMgr::SetStrength(DBYTE nStrength)
{
	if (m_nAttribStrength > nStrength)	// Strength going down
	{
		DBYTE nTmpStrength = nStrength - 1;
		CLIPLOWHIGH(nTmpStrength, 0, 5);
		for (int i = AMMO_BULLET; i <= AMMO_BATTERY; i++)
			if (m_fAmmo[i] > fMaxAmmoCount[i][nTmpStrength])
				m_fAmmo[i] = fMaxAmmoCount[i][nTmpStrength];
	}
	m_nAttribStrength = nStrength;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::SetMagic()
//
//	PURPOSE:	Sets magic and checks to see if your inventory is ok.
//
// ----------------------------------------------------------------------- //

void CInventoryMgr::SetMagic(DBYTE nMagic)
{
	if (m_nAttribMagic > nMagic)	// Magic going down
	{
		DBYTE nTmpMagic = nMagic-1;
		CLIPLOWHIGH(nTmpMagic, 0, 5);
		if (m_fAmmo[AMMO_FOCUS] > fMaxAmmoCount[AMMO_FOCUS][nTmpMagic])
				m_fAmmo[AMMO_FOCUS] = fMaxAmmoCount[AMMO_FOCUS][nTmpMagic];
	}
	m_nAttribMagic = nMagic;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::SetFullAmmo()
//
//	PURPOSE:	Sets all ammo values to the max you can carry.
//
// ----------------------------------------------------------------------- //

void CInventoryMgr::SetFullAmmo()
{
	int i;

	DBYTE nTmpAttrib = m_nAttribStrength - 1;
	CLIPLOWHIGH(nTmpAttrib, 0, 5);
	for (i = AMMO_BULLET; i <= AMMO_FOCUS; i++)
	{
		if (i == AMMO_FOCUS)
		{
			nTmpAttrib = m_nAttribMagic - 1;
			CLIPLOWHIGH(nTmpAttrib, 0, 5);
			m_fAmmo[AMMO_FOCUS] = fMaxAmmoCount[AMMO_FOCUS][nTmpAttrib];
		}
		else
		{
			m_fAmmo[i] = fMaxAmmoCount[i][nTmpAttrib];
		}
	}

	// Add bombs

#ifndef _DEMO
	for (int nItemType = INV_BASEINVWEAPON; nItemType <= INV_LASTINVWEAPON; nItemType++)
	{
		AddInventoryWeapon(nItemType, 100 );
		AddItem( nItemType, 100 );
	}
#endif

}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::AddAmmo()
//
//	PURPOSE:	Adds some ammo
//
// ----------------------------------------------------------------------- //

int CInventoryMgr::AddAmmo(DBYTE nAmmoType, DFLOAT fAmmoCount)
{
	if(nAmmoType <= AMMO_NONE || nAmmoType > AMMO_MAXAMMOTYPES)
		return CHWEAP_NOMESSAGE;

	// Get the appropriate attribute
	DBYTE nAttrib = (nAmmoType == AMMO_FOCUS) ? m_nAttribMagic : m_nAttribStrength;
	nAttrib -= 1;	// Subtract 1 to use as index into array
	CLIPLOWHIGH(nAttrib, 0, 5);

	if (fMaxAmmoCount[nAmmoType][nAttrib] > m_fAmmo[nAmmoType])	// Room for more!
	{
		m_fAmmo[nAmmoType] += fAmmoCount;
		if (m_fAmmo[nAmmoType] > fMaxAmmoCount[nAmmoType][nAttrib])
			m_fAmmo[nAmmoType] = fMaxAmmoCount[nAmmoType][nAttrib]; 
		return CHWEAP_OK;
	}

	return CHWEAP_NOMESSAGE;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::AddItem()
//
//	PURPOSE:	Try to add an item to our inventory
//
// ----------------------------------------------------------------------- //

int CInventoryMgr::AddItem(DBYTE nItemType, DBYTE nValue )
{
	// Check if valid type...
	if (nItemType <= INV_NONE || nItemType > INV_LASTINVWEAPON)
		return CHWEAP_NOTAVAIL;
	
	DBOOL bAlreadyHave = DFALSE;

#ifdef _DEMO
	if(nItemType == INV_TIMEBOMB || nItemType == INV_PROXIMITY || nItemType == INV_REMOTE)
	{
		return(CHWEAP_NOTAVAIL);
	}
#endif

	DLink *pLink = m_InvItemList.m_Head.m_pNext;
	CInvItem *pItem = DNULL;
	for (unsigned long i=0; i < m_InvItemList.m_nElements; i++)
	{
		pItem = (CInvItem*) pLink->m_pData;
		if (pItem && pItem->GetType() == nItemType)
		{
			bAlreadyHave = DTRUE;
			break;
		}
		pLink = pLink->m_pNext;
	}

	// Create the item
	if (!bAlreadyHave)
	{
		switch(nItemType)
		{
			case INV_FLASHLIGHT:
				pItem = new CInvFlashlight;
				break;

			case INV_MEDKIT:
				pItem = new CInvMedkit;
				break;

			case INV_NIGHTGOGGLES:
				pItem = new CInvNightGoggles;
				break;

			case INV_BINOCULARS:
				pItem = new CInvBinoculars;
				break;

			case INV_THEEYE:
				pItem = new CInvTheEye;
				break;

			case INV_PROXIMITY:
				pItem = new CInvProxBomb;
				break;

			case INV_REMOTE:
				pItem = new CInvRemoteBomb;
				break;

			case INV_TIMEBOMB:
				pItem = new CInvTimeBomb;
				break;

			default: return CHWEAP_NOMESSAGE;
		}

//		pLink = new DLink;
		dl_AddTail(&m_InvItemList, &pItem->m_Link, (void*)pItem);
		pItem->Init(m_hOwner);
	}
	else	// Try to add more of this item
	{
		assert(pItem);
		if (!pItem->AddItem( nValue ))
			return CHWEAP_ALREADYHAVE;
	}

	// If the currently selected item is NULL then select the item which
	// was just added.
	if ( m_pCurItem == NULL && pLink != NULL)
	{
		m_pCurItem = pLink;
	}

	return CHWEAP_OK;
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::GetNextItem()
//
//	PURPOSE:	Gets the next item in the inv item list
//
// ----------------------------------------------------------------------- //
CInvItem *CInventoryMgr::GetNextItem()
{
	// Find the next item in the array
	CInvItem *pItem=NULL;

	if (m_pCurItem)
	{
		DLink *pLink = m_pCurItem->m_pNext;
		if (pLink->m_pData)
			return (CInvItem*)pLink->m_pData;
	}
	else
	{
		DLink *pLink = m_InvItemList.m_Head.m_pNext;	
		if (pLink->m_pData)
			return (CInvItem*)pLink->m_pData;
	}
	return DNULL;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::GetPrevItem()
//
//	PURPOSE:	Gets the previous item in the array
//
// ----------------------------------------------------------------------- //
CInvItem *CInventoryMgr::GetPrevItem()
{
	// Find the prev item in the array
	CInvItem *pItem=NULL;

	if (m_pCurItem)
	{
		DLink *pLink = m_pCurItem->m_pPrev;
		if (pLink->m_pData)
			return (CInvItem*)pLink->m_pData;
	}
	else
	{
		DLink *pLink = m_InvItemList.m_Head.m_pPrev;	
		if (pLink->m_pData)
			return (CInvItem*)pLink->m_pData;
	}
	return DNULL;
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::SelectNextItem()
//
//	PURPOSE:	Selects the next item in the array
//
// ----------------------------------------------------------------------- //

void CInventoryMgr::SelectNextItem()
{
	// Find the next item in the array
	DLink *pLink = NULL;

	// Get the next item in inventory...
	if (m_pCurItem)
	{
		pLink = m_pCurItem->m_pNext;
	}
	
	// No next item, so select first item...
	if( !pLink || !pLink->m_pData )
	{
		pLink = m_InvItemList.m_Head.m_pNext;	
	}

	if (pLink && pLink->m_pData)
	{
		m_bShowItems = DTRUE;
		m_pCurItem = pLink;
	}
	else
		m_pCurItem = NULL;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::SelectPrevItem()
//
//	PURPOSE:	Selects the previous item in the array
//
// ----------------------------------------------------------------------- //

void CInventoryMgr::SelectPrevItem()
{
	// Find the prev item in the array
	DLink *pLink = NULL;

	// Get the previous item in inventory...
	if (m_pCurItem)
	{
		pLink = m_pCurItem->m_pPrev;
	}

	// No previous item, so select last item...
	if( !pLink || !pLink->m_pData )
	{
		pLink = m_InvItemList.m_Head.m_pPrev;	
	}

	// Don't select if it's the head
	if (pLink && pLink->m_pData)
	{
		m_bShowItems = DTRUE;
		m_pCurItem = pLink;
	}
	else
		m_pCurItem = NULL;
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::SelectItem()
//
//	PURPOSE:	Selects the current item
//
// ----------------------------------------------------------------------- //
void CInventoryMgr::SelectItem(int nItemType )
{	
	DLink *pLink = m_InvItemList.m_Head.m_pNext;
	CInvItem *pItem = DNULL;
	for (unsigned long i=0; i < m_InvItemList.m_nElements; i++)
	{
		pItem = (CInvItem*) pLink->m_pData;
		if (pItem && pItem->GetType() == nItemType)
		{
			m_pCurItem = pLink;
			break;
		}
		pLink = pLink->m_pNext;
	}
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::UpdateClient()
//
//	PURPOSE:	Sends messages to the client saying that the currently
//				selected item has changed.
//
// ----------------------------------------------------------------------- //

void CInventoryMgr::UpdateClient( )
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	DBYTE nCurrentItemCharge, nPrevItemCharge, nNextItemCharge;
	CInvItem *pCurrentItem, *pPrevItem, *pNextItem;
	DBYTE nChangeFlags;
	HMESSAGEWRITE hMsg;
	CPlayerObj *pPlayerObj;
	char *pCurName;

	if( !IsPlayer( m_hOwner ))
		return;

	// Get the current settings...
	if( m_pCurItem )
		pCurrentItem = (CInvItem*)m_pCurItem->m_pData;
	else
		pCurrentItem = DNULL;
	pPrevItem=GetPrevItem();
	pNextItem=GetNextItem();

	nCurrentItemCharge = ( pCurrentItem ) ? GetItemCharges( pCurrentItem ) : 0;
	nPrevItemCharge = ( pPrevItem ) ? GetItemCharges( pPrevItem ) : 0;
	nNextItemCharge = ( pNextItem ) ? GetItemCharges( pNextItem ) : 0;

	nChangeFlags = 0;

	// Check for changes...
	if( pCurrentItem != m_pLastCurrentItem )
	{
		nChangeFlags |= ITEMF_CURRENTITEM;
		m_pLastCurrentItem = pCurrentItem;
	}
	if( pPrevItem != m_pLastPrevItem )
	{
		nChangeFlags |= ITEMF_PREVITEM;
		m_pLastPrevItem = pPrevItem;
	}
	if( pNextItem != m_pLastNextItem )
	{
		nChangeFlags |= ITEMF_NEXTITEM;
		m_pLastNextItem = pNextItem;
	}
	if( nCurrentItemCharge != m_nLastCurrentItemCharge )
	{
		nChangeFlags |= ITEMF_CURRENTITEMCHARGE;