inventorymgr.cpp

Blood 2全套源码

		m_nLastCurrentItemCharge = nCurrentItemCharge;
	}
	if( nPrevItemCharge != m_nLastPrevItemCharge )
	{
		nChangeFlags |= ITEMF_PREVITEMCHARGE;
		m_nLastPrevItemCharge = nPrevItemCharge;
	}
	if( nNextItemCharge != m_nLastNextItemCharge )
	{
		nChangeFlags |= ITEMF_NEXTITEMCHARGE;
		m_nLastNextItemCharge = nNextItemCharge;
	}

	// Tell client to show the weapons...
	if( m_bShowItems )
	{
		m_bShowItems = DFALSE;
		nChangeFlags |= ITEMF_SHOWITEMS;
	}

	// Check if nothing changed...
	if( !nChangeFlags )
		return;

	pPlayerObj = (CPlayerObj*)g_pServerDE->HandleToObject(m_hOwner);

	hMsg = pServerDE->StartMessage( pPlayerObj->GetClient( ), SMSG_ITEMCHANGED );

	// Write the change flags...
	pServerDE->WriteToMessageByte( hMsg, nChangeFlags );
	
	// The current item
	if ( nChangeFlags & ITEMF_CURRENTITEM )
	{
		if( pCurrentItem )
		{
			pCurName = pCurrentItem->GetDisplayName();
			pServerDE->WriteToMessageString( hMsg, pCurName );
			if( pCurName )
			{
				pServerDE->WriteToMessageHString(hMsg, pCurrentItem->GetPic());
				pServerDE->WriteToMessageHString(hMsg, pCurrentItem->GetPicH());
			}
		}
		else
		{
			pServerDE->WriteToMessageString(hMsg, DNULL);
		}
	}

	// The previous item
	if ( nChangeFlags & ITEMF_PREVITEM )
	{
		if( pPrevItem )
			pServerDE->WriteToMessageHString(hMsg, pPrevItem->GetPic());
		else
			pServerDE->WriteToMessageHString(hMsg, DNULL);
	}

	// The next item
	if ( nChangeFlags & ITEMF_NEXTITEM )
	{
		if( pNextItem )
			pServerDE->WriteToMessageHString(hMsg, pNextItem->GetPic());
		else
			pServerDE->WriteToMessageHString(hMsg, DNULL);
	}

	// The current item
	if ( nChangeFlags & ITEMF_CURRENTITEMCHARGE )
	{
		pServerDE->WriteToMessageByte(hMsg, nCurrentItemCharge );
	}

	// The previous item
	if ( nChangeFlags & ITEMF_PREVITEMCHARGE )
	{
		pServerDE->WriteToMessageByte(hMsg, nPrevItemCharge );	
	}

	// The next item
	if ( nChangeFlags & ITEMF_NEXTITEMCHARGE )
	{
		pServerDE->WriteToMessageByte(hMsg, nNextItemCharge );	
	}

	pServerDE->EndMessage2( hMsg, MESSAGE_GUARANTEED | MESSAGE_NAGGLE );
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::AddInventoryWeapon()
//
//	PURPOSE:	Try to add a bomb item to our inventory
//
// ----------------------------------------------------------------------- //

int CInventoryMgr::AddInventoryWeapon(DBYTE nWeapType, DBYTE nCount)
{
#ifdef _DEMO
		return CHWEAP_NOTAVAIL;
#else

	if(nWeapType < INV_BASEINVWEAPON || nWeapType > INV_LASTINVWEAPON)
		return CHWEAP_NOTAVAIL;

	DBYTE nWeapon = nWeapType - INV_BASEINVWEAPON;

	CWeapon *w;

	w = m_Weapons[nWeapon + SLOTCOUNT_WEAPONS];

	if (w)	// already have this one, try to add ammo instead
	{
		return AddAmmo(w->GetAmmoType(), nCount);
	}

	switch(nWeapon + WEAP_BASEINVENTORY)
	{
		case WEAP_PROXIMITYBOMB:
			w = new CWeapProximityBomb;
			break;

		case WEAP_REMOTEBOMB:
			w = new CWeapRemoteBomb;
			break;

		case WEAP_TIMEBOMB:
			w = new CWeapTimeBomb;
			break;

		default: return CHWEAP_NOTAVAIL;
	}

	w->Init(m_hOwner, this, DFALSE, m_hMuzzleFlash);
	if (m_hClient) w->SetClient(m_hClient, m_pViewModel);

	m_Weapons[nWeapon + SLOTCOUNT_WEAPONS] = w;
	AddAmmo(w->GetAmmoType(), nCount);

//	SendClientItemMsg(SMSG_NEWITEM, nWeapType);

	return CHWEAP_OK;

#endif	// !_DEMO
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::SelectInventoryWeapon()
//
//	PURPOSE:	Changes the current selected weapon
//
// ----------------------------------------------------------------------- //

int CInventoryMgr::SelectInventoryWeapon(DDWORD nWeapon)
{
	CWeapon *w;

	if(nWeapon > WEAP_MAXWEAPONTYPES || nWeapon < WEAP_BASEINVENTORY)
		return CHWEAP_NOTAVAIL;

	if(nWeapon == m_nCurWeapon)
		return CHWEAP_CURRENT;

	int nSlot = nWeapon - WEAP_BASEINVENTORY;

	w = m_Weapons[SLOTCOUNT_WEAPONS + nSlot];

	// See if we have the new weapon & enough strength;
	if(w == NULL)
		return CHWEAP_NOTAVAIL;

	if(!GetAmmoCount(w->GetAmmoType(DFALSE)))
	{
		CServerDE* pServerDE = BaseClass::GetServerDE();
		pServerDE->CPrint("No ammo for this inventory weapon...");
		return CHWEAP_NOAMMO;
	}

	// Okay, we have it, change to it
	if (m_Weapons[m_nCurWeaponSlot])
		m_Weapons[m_nCurWeaponSlot]->ShowHandModel(DFALSE);
	if (m_LWeapons[m_nCurWeaponSlot])
		m_LWeapons[m_nCurWeaponSlot]->ShowHandModel(DFALSE);
/*
	if (m_hClient)		// Only for player object owners
	{
		if (m_Weapons[m_nCurWeaponSlot])
			m_Weapons[m_nCurWeaponSlot]->Holster();
		if (m_LWeapons[m_nCurWeaponSlot])
			m_LWeapons[m_nCurWeaponSlot]->Holster();

		m_bSwitchingWeapons = DTRUE;
		m_nNextWeaponSlot = nSlot + SLOTCOUNT_WEAPONS;
	}
	else
	{*/
		// Okay, we have it, change to it
		if (m_pCurWeapon)
		{
			m_pCurWeapon->Holster();
			m_pCurWeapon->ShowHandModel(DFALSE);
		}

		m_pCurWeapon = w;
		m_nCurWeapon = nWeapon;
		m_nCurWeaponSlot = nSlot + SLOTCOUNT_WEAPONS;
//	}

	return CHWEAP_OK;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::SetActiveItem()
//
//	PURPOSE:	Sets the active inventory item
//
// ----------------------------------------------------------------------- //

int CInventoryMgr::SetActiveItem(DBYTE nItemType)
{
	if (!(nItemType > INV_NONE && nItemType <= INV_LASTINVWEAPON))
		return CHWEAP_NOTAVAIL;

	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)
		{
			_mbscpy((unsigned char*)msgbuf, (const unsigned char*)"");

			if( pItem->ActivateItem(msgbuf))
			{
				if (_mbstrlen(msgbuf))
					SendConsoleMessageToClient(msgbuf);
				return CHWEAP_OK;
			}
			break;
		}
		pLink = pLink->m_pNext;
	}
	return CHWEAP_NOTAVAIL;
}

/*
// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::DropItem(DBYTE slot)
//
//	PURPOSE:	Spawns an Item at the client location
//
// ----------------------------------------------------------------------- //
int CInventoryMgr::DropItem(DBYTE slot)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	CInvItem *iToDrop = m_InvItems[slot];

	if(!iToDrop)	return	0;

	// spawn an item pickup, and save it's handle so we don't pick it right up again.
	m_hLastDroppedItem = SpawnItemPickup(iToDrop->GetType(), m_hOwner);
	if (m_hLastDroppedItem)
		m_fLastDroppedTime = pServerDE->GetTime();

	RemoveItem(iToDrop->GetType());

	iToDrop = NULL;
	return	1;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::DeleteItem(DBYTE slot)
//
//	PURPOSE:	Spawns an Item at the client location
//
// ----------------------------------------------------------------------- //
int CInventoryMgr::DeleteItem(DBYTE slot)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	CInvItem *iToDrop = m_InvItems[slot];

	if(!iToDrop)	return	0;
	RemoveItem(iToDrop->GetType());
	iToDrop = NULL;
	return	1;
}
*/

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::RemoveItem()
//
//	PURPOSE:	Remove an Item based on type, not useful for removing keys.
//
// ----------------------------------------------------------------------- //
int CInventoryMgr::RemoveItem(DBYTE nItemType)
{
	if(nItemType <= INV_NONE || nItemType > INV_LASTINVWEAPON)
		return CHWEAP_NOTAVAIL;
	
	DLink *pLink = m_InvItemList.m_Head.m_pNext;
	CInvItem *pItem = DNULL;
	DBOOL bFound = DFALSE;
	for (unsigned long i=0; i < m_InvItemList.m_nElements; i++)
	{
		pItem = (CInvItem*) pLink->m_pData;
		if (pItem && pItem->GetType() == nItemType)
		{
			bFound = DTRUE;
			break;
		}
		pLink = pLink->m_pNext;
	}

	if( bFound && pItem )
	{
		return RemoveItem( pItem );
	}

	return CHWEAP_NOTAVAIL;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::RemoveItem()
//
//	PURPOSE:	Remove an Item
//
// ----------------------------------------------------------------------- //
int CInventoryMgr::RemoveItem( CInvItem *pItem )
{
	CPlayerObj *pOwner;

	pOwner = DNULL;
	if( IsPlayer( m_hOwner ))
	{
		pOwner = (CPlayerObj*)g_pServerDE->HandleToObject(m_hOwner);
		
		if( pItem->IsActive( ))
			SetActiveItem( pItem->GetType( ));

		// Select next item...
		if( GetCurrentItem( ) == pItem )
		{
			if( m_InvItemList.m_nElements > 1 )
				SelectNextItem();
			else
				m_pCurItem = NULL;
		}
	}
	else
	{
		pItem->Deactivate( );
	}
	
	dl_RemoveAt( &m_InvItemList, &pItem->m_Link );

	// Get rid of inventory item...
	pItem->Term();
	delete pItem;
//	delete pLink;
	
	return CHWEAP_OK;
}    


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::AddKey()
//
//	PURPOSE:	Try to add a key to our inventory
//
// ----------------------------------------------------------------------- //

int CInventoryMgr::AddKey(HSTRING hstrItemName, HSTRING hstrDisplayName, HSTRING hstrIconFile, HSTRING hstrIconFileH, DBYTE byUseCount)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE || !hstrItemName || !hstrDisplayName || !hstrIconFile || !hstrIconFileH || byUseCount ==0 ) return CHWEAP_NOMESSAGE;

	// See if we have it already
	DBOOL bAlreadyHave = DFALSE;

	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() == INV_KEY)
		{
			char *pName = pItem->GetName();
			if ( _mbsicmp((const unsigned char*)pName, (const unsigned char*)pServerDE->GetStringData(hstrItemName)) == 0 )
				return CHWEAP_ALREADYHAVE;
		}
		pLink = pLink->m_pNext;
	}

	CInvKey *pKey = new CInvKey;
	if (pKey)
	{
		pKey->Init(m_hOwner);
		pKey->Setup(hstrIconFile, hstrIconFileH, hstrItemName, hstrDisplayName, byUseCount);
		
//		pLink = new DLink;

		dl_AddTail(&m_InvItemList, &pKey->m_Link, (void*)pKey);
	}

	// TODO: Tell client about it
//	DBYTE nKeyType = 0;
//	SendClientItemMsg(SMSG_NEWKEY, nKeyType);

	// 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::RemoveKey()
//
//	PURPOSE:	Try to remove a key from our inventory
//
// ----------------------------------------------------------------------- //

int CInventoryMgr::RemoveKey(HSTRING hstrItemName)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE || !hstrItemName) return CHWEAP_NOMESSAGE;

	// See if we have it
	int i;
	for (i=0; i<SLOTCOUNT_KEYS; i++)
	{
		if (m_KeyItems[i] && pServerDE->CompareStringsUpper(hstrItemName, m_KeyItems[i]->m_hstrItemName))
		{
			// Found it
			delete m_KeyItems[i];
			m_KeyItems[i] = DNULL;

			break;
		}
	}
	
	DBYTE nKeyType = 0;
//	SendClientItemMsg(SMSG_REMOVEKEY, nKeyType);
	return CHWEAP_OK;
}
*/

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::QueryKey()
//
//	PURPOSE:	See if we have a key in our inventory
//
// ----------------------------------------------------------------------- //

int CInventoryMgr::QueryKey(HSTRING hstrItemName)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE || !hstrItemName) return CHWEAP_NOMESSAGE;

	// See if we have it
	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() == INV_KEY)
		{
			char *pName = pItem->GetName();
			char *pOldName = pServerDE->GetStringData(hstrItemName);
			if ( _mbsicmp((const unsigned char*)pName, (const unsigned char*)pOldName) == 0 )
			{
				// Found it, decrement it's use
				DBYTE byCount = pItem->GetCount();
				byCount--;
				pItem->SetCount(byCount);
				if (byCount == 0)
				{
					return RemoveItem( pItem );
				}
				return CHWEAP_OK;
			}
		}
		pLink = pLink->m_pNext;
	}
	return CHWEAP_NOTAVAIL;
}

/*
// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CInventoryMgr::AddSpell()
//
//	PURPOSE:	Try to add an spell to our inventory
//
// ----------------------------------------------------------------------- //

int CInventoryMgr::AddSpell(DBYTE nSpellType, int slot)
{
	if(nSpellType < INV_BASESPELL || nSpellType > INV_LASTSPELL)
		return CHWEAP_NOTAVAIL;

	CInvItem *item = DNULL;
	int emptyslot = -1;
	DBOOL bAlreadyHave = DFALSE;

	// See if a particular slot is requested
	if (slot != -1)
	{
		item = m_InvSpells[slot];
		if (!item)
			emptyslot = slot;
	}

	// Don't have a slot yet, iterate through them to find one.
	if (emptyslot == -1)
	{
		for (int i=0; i < SLOTCOUNT_SPELLS; i++)
		{
			item = m_InvSpells[i];
			if (item && (item->GetType() == nSpellType) )		// See if we already have it..
			{
				bAlreadyHave = DTRUE;
				break;
			}
			else if (!item && emptyslot == -1) // Empty slot, mark it..
			{
				emptyslot = i;