//------------------------------------------------------------------------
int CScriptBind_Inventory::Destroy(IFunctionHandler *pH)
{
CInventory *pInventory = GetInventory(pH);
CRY_ASSERT(pInventory);
pInventory->Destroy();
return pH->EndFunction();
}
//------------------------------------------------------------------------
int CScriptBind_Inventory::GetAmmoCount(IFunctionHandler *pH, const char *ammoName)
{
CInventory *pInventory = GetInventory(pH);
CRY_ASSERT(pInventory);
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ammoName);
CRY_ASSERT(pClass);
return pH->EndFunction(pInventory->GetAmmoCount(pClass));
}
//------------------------------------------------------------------------
int CScriptBind_Inventory::GetCurrentItemId(IFunctionHandler *pH)
{
CInventory *pInventory = GetInventory(pH);
CRY_ASSERT(pInventory);
EntityId currentItemId = pInventory->GetCurrentItem();
if (currentItemId)
return pH->EndFunction(ScriptHandle(currentItemId));
return pH->EndFunction();
}
//-------------------------------------------------------------------
int CScriptBind_Inventory::HasAccessory(IFunctionHandler *pH, const char *accessoryName)
{
CInventory *pInventory = GetInventory(pH);
CRY_ASSERT(pInventory);
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(accessoryName);
if(pClass)
return pH->EndFunction(pInventory->HasAccessory(pClass));
return pH->EndFunction();
}
//----------------------------------------------------------------------
int CScriptBind_Inventory::GetGrenadeWeaponByClass(IFunctionHandler *pH, const char *className)
{
CInventory *pInventory = GetInventory(pH);
CRY_ASSERT(pInventory);
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(className);
EntityId itemId = pInventory->GetItemByClass(pClass,NULL);
if (itemId)
return pH->EndFunction(ScriptHandle(itemId));
return pH->EndFunction();
}
//------------------------------------------------------------------------
int CScriptBind_Inventory::Dump(IFunctionHandler *pH)
{
#if DEBUG_INVENTORY_ENABLED
CInventory *pInventory = GetInventory(pH);
CRY_ASSERT(pInventory);
pInventory->Dump();
#endif
return pH->EndFunction();
}
//*-------------------------------------------------------------------/
/// 분리/분해후 아이템이 들어갈 자리가 충분히 있는가?
//*-------------------------------------------------------------------/
bool CSeparateDlg::HasEnoughInventoryEmptySlot( CIconItem* pItemIcon, std::vector<CSlot>& OutputItems )
{
#ifdef _NEWBREAK
//06. 08. 24 - 김주현 : 지금 분해는 재료만 나오게 되어있다. 재료탭만 체크한다.
short nEmptySlotCount[ MAX_INV_TYPE ];
CInventory* pInven = g_pAVATAR->GetInventory();
assert( pInven );
nEmptySlotCount[INV_ETC] = pInven->GetEmptyInvenSlotCount( (t_InvTYPE)INV_ETC );
if(nEmptySlotCount[INV_ETC] < 4)
return false;
return true;
#else
assert( pItemIcon );
if( pItemIcon == NULL ) return false;
///일단 모든 타입의 빈 슬롯을 구한다.
short nEmptySlotCount[ MAX_INV_TYPE ];
CInventory* pInven = g_pAVATAR->GetInventory();
assert( pInven );
for( int i = INV_WEAPON; i < MAX_INV_TYPE; ++i )
nEmptySlotCount[i] = pInven->GetEmptyInvenSlotCount( (t_InvTYPE)i );
/// 분리/분해할 아이템의 자리를 빈슬롯으로 계산한다( 개수가 없거나 개수가 있지만 1개일경우)
tagITEM& Item = pItemIcon->GetItem();
if( (Item.IsEnableDupCNT() && Item.GetQuantity() == 1 ) || !Item.IsEnableDupCNT() )
nEmptySlotCount[ CInventory::GetInvPageTYPE( Item ) ]++;
CIcon* pIcon = NULL;
CIconItem* pOutputItemIcon = NULL;
std::vector<CSlot>::iterator iter;
for( iter = OutputItems.begin(); iter != OutputItems.end(); ++iter )
{
if( pIcon = iter->GetIcon() )
{
pOutputItemIcon = ( CIconItem* )pIcon;
nEmptySlotCount[ CInventory::GetInvPageTYPE( pOutputItemIcon->GetItem() ) ]--;
if( nEmptySlotCount[ CInventory::GetInvPageTYPE( pOutputItemIcon->GetItem() ) ] < 0 )
return false;
}
}
return true;
#endif
}
void initInventoryScene()
{
map<uint32, NL3D::UInstance*>::iterator itu;
for(itu = InventoryItems.begin(); itu!=InventoryItems.end(); itu++)
{
InventoryScene->deleteInstance( (*itu).second);
}
InventoryItems.clear();
// invSelectPS->setPos (0.0f, 0.0f, 0.0f);
// invSelectPS->setScale( 1.0f, 1.0f, 1.0f );
if (ShowDebugInChat) nlinfo("InvScene cleared");
placeInList=0;
map<uint32,uint8>::iterator it;
for(it = CharacterInventory._Inventory.begin(); it!=CharacterInventory._Inventory.end(); it++)
{
if (ShowDebugInChat) nlinfo(". %d",placeInList);
placeInList++;
if ((*it).second==1)
{
// DIT dynamicObject = DynamicObjects.find ((*it).first);
// CClientDynamicObject &dynamicObjecta = dynamicObject->second; // hack
// if (dynamicObjecta.MeshName=="") dynamicObjecta.MeshName = "MagicWand01.shape";
// UInstance* dynamicInventoryItem = InventoryScene->createInstance( dynamicObjecta.MeshName );
// dynamicInventoryItem->setPos (-1.0f, 3.5f, placeInList*-0.5f);
// dynamicInventoryItem->setScale( CVector(0.2f, 0.2f, 0.2f ));
// InventoryItems.insert(make_pair (dynamicObjecta.Id, dynamicInventoryItem));
// PlaceInInventoryList.insert(make_pair (dynamicObjecta.Id, placeInList));
}
else if ((*it).second==2)
{
FIT dynamicFirearmObject = Firearms.find ((*it).first);
CClientFirearm &dynamicFirearmObjecta = dynamicFirearmObject->second; // hack
if (dynamicFirearmObjecta.MeshName=="") dynamicFirearmObjecta.MeshName = "handgun.shape";
NL3D::UInstance* dynamicInventoryItem = InventoryScene->createInstance( dynamicFirearmObjecta.MeshName );
dynamicInventoryItem->setPos (-2.0f, 4.5f, placeInList*-0.4f);
InventoryItems.insert(make_pair (dynamicFirearmObjecta.Id, dynamicInventoryItem));
PlaceInInventoryList.insert(make_pair (dynamicFirearmObjecta.Id, placeInList));
}
if ((*it).first==CharacterInventory.getSelected())
{
// nlinfo("setting select particle system");
// invSelectPS->show();
// invSelectPS->setPos (-2.0f, 4.5f, (placeInList*-1.0f)+0.7f);
// invSelectPS->setScale( 0.3f, 0.3f, 0.3f );
}
}
sendSelectedInInventory( CharacterInventory.getSelected() );
}
//------------------------------------------------------------------------
int CScriptBind_Inventory::GetCurrentItem(IFunctionHandler *pH)
{
CInventory *pInventory = GetInventory(pH);
CRY_ASSERT(pInventory);
EntityId currentItemId = pInventory->GetCurrentItem();
if (currentItemId)
{
IEntity *pEntity = m_pEntitySystem->GetEntity(currentItemId);
if (pEntity)
return pH->EndFunction(pEntity->GetScriptTable());
}
return pH->EndFunction();
}
bool CObjUSER::IsInventoryFull( std::list< tagITEM >& appendItems )
{
CInventory TempInventory;
memcpy( &TempInventory, &m_Inventory, sizeof( CInventory ) );
std::list< tagITEM >::iterator iterAppend;
short nInvenIndex = 0;
short nWeight = 0;
for( iterAppend = appendItems.begin(); iterAppend != appendItems.end(); ++iterAppend )
{
if( TempInventory.AppendITEM(*iterAppend , nWeight ) == -1 )
return true;
}
return false;
}
void updateSelected()
{
std::map<uint32, NL3D::UInstance*>::iterator itInvItems;
std::map<uint32, uint8>::iterator itInvSelItems;
itInvItems = InventoryItems.find(CharacterInventory.getSelected());
if(itInvItems!=InventoryItems.end())
{
itInvSelItems = PlaceInInventoryList.find(CharacterInventory.getSelected());
if(itInvSelItems!=PlaceInInventoryList.end())
{
// invSelectPS->setPos (-2.0f, 4.5f, ((*itInvSelItems).second*-1.0f)+0.7f);
// nlinfo("Have set inv ps pos %d", (*itInvSelItems).second);
}
}
}
bool CObjUSER::IsInventoryFull( std::list< tagITEM >& appendItems, std::list< pair<int,tagITEM> >& removeItems )
{
CInventory TempInventory;
memcpy( &TempInventory, &m_Inventory, sizeof( CInventory ) );
std::list< tagITEM >::iterator iterAppend;
std::list< pair< int, tagITEM> >::iterator iterRemove;
short nInvenIndex = 0;
short nWeight = 0;
for( iterRemove = removeItems.begin(); iterRemove != removeItems.end(); ++iterRemove )
TempInventory.SubtractITEM( iterRemove->first, iterRemove->second, nWeight );
for( iterAppend = appendItems.begin(); iterAppend != appendItems.end(); ++iterAppend )
{
if( TempInventory.AppendITEM(*iterAppend , nWeight ) == -1 )
return true;
}
return false;
}
void CScriptGameObject::ForEachInventoryItems(const luabind::functor<void> &functor)
{
CInventoryOwner* owner = smart_cast<CInventoryOwner*>(&object());
if(!owner){
ai().script_engine().script_log (ScriptStorage::eLuaMessageTypeError,"CScriptGameObject::ForEachInventoryItems non-CInventoryOwner object !!!");
return;
}
CInventory* pInv = &owner->inventory();
TIItemContainer item_list;
pInv->AddAvailableItems(item_list, true);
TIItemContainer::iterator it;
for(it = item_list.begin(); item_list.end() != it; ++it)
{
CGameObject* inv_go = smart_cast<CGameObject*>(*it);
if( inv_go ){
functor(inv_go->lua_game_object(),this);
}
}
}
//------------------------------------------------------------------------
int CScriptBind_Inventory::SetAmmoCount(IFunctionHandler *pH, const char *ammoName, int count)
{
CInventory *pInventory = GetInventory(pH);
CRY_ASSERT(pInventory);
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ammoName);
CRY_ASSERT(pClass);
if (pClass)
{
pInventory->SetAmmoCount(pClass, count);
if (gEnv->bServer)
{
pInventory->GetActor()->GetGameObject()->InvokeRMI(CInventory::Cl_SetAmmoCount(),
TRMIInventory_Ammo(ammoName, count),
eRMI_ToRemoteClients);
}
}
else
{
CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "Ammo class %s not found!", ammoName);
}
return pH->EndFunction();
}
void CInventory::CopyTo(CInventory& targetInventory)
{
// Iterate over all categories to copy stuff
for (int c = 0; c < GetNumCategories(); ++c)
{
const CInventoryCategoryPtr& category = GetCategory(c);
for (int itemIdx = 0; itemIdx < category->GetNumItems(); ++itemIdx)
{
const CInventoryItemPtr& item = category->GetItem(itemIdx);
DM_LOG(LC_INVENTORY, LT_DEBUG)LOGSTRING("Copying item %s to inventory.\r", common->Translate(item->GetName().c_str()));
// Add this item to the target inventory
targetInventory.PutItem(item, item->Category()->GetName());
}
}
}
void CInventory::CopyPersistentItemsFrom(const CInventory& sourceInventory, idEntity* newOwner)
{
// Obtain the weapon category for this inventory
CInventoryCategoryPtr weaponCategory = GetCategory(TDM_PLAYER_WEAPON_CATEGORY);
// Cycle through all categories to add them
for ( int c = 0 ; c < sourceInventory.GetNumCategories() ; ++c )
{
const CInventoryCategoryPtr& category = sourceInventory.GetCategory(c);
for ( int itemIdx = 0 ; itemIdx < category->GetNumItems() ; ++itemIdx )
{
const CInventoryItemPtr& item = category->GetItem(itemIdx);
if (item->GetPersistentCount() <= 0)
{
DM_LOG(LC_INVENTORY, LT_DEBUG)LOGSTRING(
"Item %s is not marked as persistent, won't add to player inventory.\r",
common->Translate(item->GetName().c_str()));
continue; // not marked as persistent
}
// Check if the shop handled that item already
const idDict* itemDict = item->GetSavedItemEntityDict();
if (itemDict != NULL)
{
CShopItemPtr shopItem = gameLocal.m_Shop->FindShopItemDefByClassName(itemDict->GetString("classname"));
if ( (shopItem != NULL) && (CShop::GetQuantityForItem(item) > 0) )
{
// grayman #3723 - if there's no shop in this mission,
// then we can't rely on it to process this inventory item.
if ( gameLocal.m_Shop->ShopExists() )
{
DM_LOG(LC_INVENTORY, LT_DEBUG)LOGSTRING(
"Item %s would be handled by the shop, won't add that to player inventory.\r",
common->Translate(item->GetName().c_str()));
continue;
}
}
}
// Is set to true if we should add this item.
// For weapon items with ammo this will be set to false to prevent double-additions
bool addItem = true;
// Handle weapons separately, otherwise we might end up with duplicate weapon items
CInventoryWeaponItemPtr weaponItem = boost::dynamic_pointer_cast<CInventoryWeaponItem>(item);
if (weaponItem && weaponCategory)
{
// Weapon items need special consideration. For arrow-based weapons try to merge the ammo.
for ( int w = 0 ; w < weaponCategory->GetNumItems() ; ++w )
{
CInventoryWeaponItemPtr thisWeapon = boost::dynamic_pointer_cast<CInventoryWeaponItem>(weaponCategory->GetItem(w));
if (!thisWeapon)
{
continue;
}
if (thisWeapon->GetWeaponName() == weaponItem->GetWeaponName())
{
// Prevent adding this item, we already have one
addItem = false;
// Found a matching weapon, does it use ammo?
if (thisWeapon->NeedsAmmo())
{
DM_LOG(LC_INVENTORY, LT_DEBUG)LOGSTRING(
"Adding persistent ammo %d to player weapon %s.\r",
weaponItem->GetAmmo(), thisWeapon->GetWeaponName().c_str());
// Add the persistent ammo count to this item
thisWeapon->SetAmmo(thisWeapon->GetAmmo() + weaponItem->GetAmmo());
}
else
{
// Doesn't need ammo, check enabled state
if (weaponItem->IsEnabled() && !thisWeapon->IsEnabled())
{
DM_LOG(LC_INVENTORY, LT_DEBUG)LOGSTRING(
"Enabling weapon item %s as the persistent inventory contains an enabled one.\r",
thisWeapon->GetWeaponName().c_str());
thisWeapon->SetEnabled(true);
}
}
break;
}
}
}
if (addItem)
{
DM_LOG(LC_INVENTORY, LT_DEBUG)LOGSTRING(
"Adding persistent item %s to player inventory, quantity: %d.\r",
common->Translate(item->GetName().c_str()), item->GetPersistentCount());
item->SetOwner(newOwner);
// Add this item to our inventory
PutItem(item, item->Category()->GetName());
// If we didn't have a weapon category at this point, we should be able to get one now
if (weaponItem && !weaponCategory)
{
weaponCategory = GetCategory(TDM_PLAYER_WEAPON_CATEGORY);
}
}
}
}
}
void CGameStateRecorder::OnRecordedGameplayEvent(IEntity *pEntity, const GameplayEvent &event, int currentFrame, bool bRecording)
{
EntityId id;
m_currentFrame = currentFrame;
int demo_forceGameState = 0;
if(!bRecording)
{
ICVar *pVar = gEnv->pConsole->GetCVar( "demo_force_game_state" );
if(pVar)
demo_forceGameState = pVar->GetIVal();
}
if(!pEntity || !(id = pEntity->GetId()))
return;
if(m_IgnoredEvents.size())
if(event.event == m_IgnoredEvents[0])
{
m_IgnoredEvents.erase(m_IgnoredEvents.begin());
return;
}
TGameStates::iterator itActor = m_GameStates.find(id);
if(itActor == m_GameStates.end())
{
m_GameStates.insert(std::make_pair(id,SActorGameState()));
itActor = m_GameStates.find(id);
}
if(itActor == m_GameStates.end())
{
GameWarning("TimeDemo:GameState: actor %s not found in records",pEntity->GetName());
return;
}
SActorGameState& gstate = itActor->second;
switch(event.event)
{
case eGE_HealthChanged:
{
gstate.health = event.value;
if(!m_bRecording)
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
if(m_bLogWarning)
{
if(CHECK_MISMATCH(pActor->GetHealth(), gstate.health,10))
{
if(!gstate.bHealthDifferent)
{
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - HEALTH mismatch (%d, %d)",m_currentFrame,pEntity->GetName(), static_cast<int>(pActor->GetHealth()), static_cast<int>(gstate.health));
gstate.bHealthDifferent = true;
}
}
else
gstate.bHealthDifferent = false;
}
if( demo_forceGameState)
pActor->SetHealth(gstate.health);
}
}
}
break;
case eGE_WeaponFireModeChanged:
{
TItemName sel = (event.description);
if(sel)
{
TItemContainer& Items = gstate.Items;
TItemContainer::iterator iti = Items.find(sel);
uint8 recFireModeIdx = uint8(event.value);
if(iti != Items.end())
iti->second.fireMode = recFireModeIdx;
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor && pActor->GetInventory())
{
IItem* pItem = pActor->GetInventory()->GetItemByName(sel);
CWeapon* pWeapon;
if(pItem && (pWeapon = (CWeapon*)(pItem->GetIWeapon())))
{
int fireModeIdx = pWeapon->GetCurrentFireMode();
if(m_bLogWarning)
{
CheckDifference(recFireModeIdx,fireModeIdx,"TimeDemo:GameState: Frame %d - Actor %s - FIRE MODE mismatch for weapon %s (rec:%d, cur:%d)",pEntity,pItem->GetEntity() ? pItem->GetEntity()->GetName() : "(null)");
}
if(demo_forceGameState==2 && fireModeIdx!= recFireModeIdx)
pWeapon->SetCurrentFireMode(recFireModeIdx);
}
}
}
}
break;
case eGE_WeaponReload:
{
const char* ammoType = event.description;
TAmmoContainer& ammoMags = gstate.AmmoMags;
TAmmoContainer::iterator it = ammoMags.find(ammoType);
if(it!=ammoMags.end())
{
it->second -= (uint16)event.value;
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
CInventory* pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
{
IEntityClass* pAmmoClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ammoType);
if(pAmmoClass)
{
if(m_bLogWarning)
CheckDifference(it->second,pInventory->GetAmmoCount(pAmmoClass),"TimeDemo:GameState: Frame %d - Actor %s - WEAPON RELOAD, ammo count mismatch for ammo class %s (rec:%d, cur:%d)",pEntity,ammoType);
if(demo_forceGameState == 2)
pInventory->SetAmmoCount(pAmmoClass,it->second);
}
}
}
}
}
}
break;
case eGE_ItemSelected:
{
TItemName itemName = event.description;
gstate.itemSelected = itemName;
if(itemName)
{
if( !bRecording && (event.value > 0 || demo_forceGameState==2)) // EVENT.VALUE > 0 means initialization
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor && pActor->GetInventory())
{
IItem* pItem = pActor->GetInventory()->GetItemByName(itemName);
if(pItem)
pActor->SelectItem(pItem->GetEntityId(),false);
}
}
}
if(m_bLogWarning)
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
IItem* pItem = pActor->GetCurrentItem();
const char* curItemName= pItem && pItem->GetEntity() ? pItem->GetEntity()->GetName(): NULL;
CheckDifferenceString(itemName,curItemName,"TimeDemo:GameState: Frame %d - Actor %s - SELECTED ITEM mismatch (rec:%s, cur:%s)",pEntity);
}
}
break;
}
break;
case eGE_ItemExchanged:
{
// prevent unwanted record/play mismatch error with current item during item exchanging
// two unneeded game events are sent (selecting fists)
m_IgnoredEvents.push_back(eGE_ItemSelected);
m_IgnoredEvents.push_back(eGE_ItemSelected);
}
break;
case eGE_ItemPickedUp:
{
TItemName sel = (TItemName)event.description;
// gstate.itemSelected = sel;
TItemContainer& Items = gstate.Items;
TItemContainer::iterator it = Items.find(sel);
if(it == Items.end())
{
Items.insert(std::make_pair(sel,SItemProperties()));
it = Items.find(sel);
}
if(it != Items.end())
{
it->second.count++;
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor && !m_bRecording)
{
CInventory* pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
// just check if the item is the inventory
if(m_bLogWarning && !pInventory->GetItemByName(sel))
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - Recorded PICKED UP ITEM class '%s' not found in current inventory",m_currentFrame,pEntity->GetName(),sel);
if(demo_forceGameState == 2)
{
IEntity* pItemEntity = gEnv->pEntitySystem->FindEntityByName(sel);
if(pItemEntity)
pInventory->AddItem(pItemEntity->GetId());
else
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - PICKED UP ITEM entity %s not found in level",m_currentFrame,pEntity->GetName(),sel);
}
}
}
}
else if(m_bLogWarning)
{
if(!sel)
sel = "(null)";
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - PICKED UP ITEM %s not found in recorded inventory",m_currentFrame,pEntity->GetName(),sel);
}
}
break;
case eGE_AmmoPickedUp:
{
uint16 ammoCount = (uint16)(event.value);
TItemName sel = (TItemName)event.description;
TAmmoContainer& Ammo = gstate.AmmoMags;
TAmmoContainer::iterator it = Ammo.find(sel);
if(it == Ammo.end())
Ammo.insert(std::make_pair(sel,ammoCount));
else
it->second = ammoCount;
if( !m_bRecording)
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
CInventory* pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(sel);
if(m_bLogWarning)
CheckDifference(ammoCount,pInventory->GetAmmoCount(pClass),"TimeDemo:GameState: Frame %d - Actor %s - AMMO PICKEDUP: count mismatch for ammo class %s (rec:%d, cur:%d)", pEntity,sel);
if(demo_forceGameState == 2)
pInventory->SetAmmoCount(pClass,ammoCount);
}
}
}
}
break;
case eGE_AccessoryPickedUp:
{
TItemName sel = (TItemName)event.description;
// gstate.itemSelected = sel;
TAccessoryContainer& Accessories = gstate.Accessories;
TAccessoryContainer::iterator it = Accessories.find(sel);
if(it == Accessories.end())
{
Accessories.insert(std::make_pair(sel,1));
}
else
it->second++;
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
CInventory* pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(sel);
if(m_bLogWarning && !pInventory->HasAccessory(pClass))
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - ACCESSORY PICKEDUP %s not found in current inventory", m_currentFrame, pEntity->GetName(),sel ? sel:"(null)");
if(demo_forceGameState == 2 && pClass)
pInventory->AddAccessory(pClass);// doesn't actually add it if it's there already
}
}
}
break;
case eGE_ItemDropped:
{
TItemName sel = (TItemName)event.description;
//gstate.itemSelected = sel;
TItemContainer& Items = gstate.Items;
TItemContainer::iterator it = Items.find(sel);
if(it != Items.end())
{
it->second.count--;
if(it->second.count<=0)
Items.erase(it);
if(demo_forceGameState == 2)
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
CInventory* pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(sel);
if(pClass)
{
EntityId itemId = pInventory->GetItemByClass(pClass);
if(itemId)
pInventory->RemoveItem(itemId);
}
}
}
}
}
else
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - ITEM DROPPED, wrong item selected (%s)",m_currentFrame,pEntity->GetName(),sel);
}
break;
case eGE_AmmoCount:
{
TItemContainer& Items = gstate.Items;
TItemName itemClassDesc = event.description;
TItemContainer::iterator it = Items.find(itemClassDesc);
if(it != Items.end())
{
SItemProperties& item = it->second;
const char* ammoClassDesc = (const char*)(event.extra);
if(ammoClassDesc)
{
string szAmmoClassDesc(ammoClassDesc);
bool bAmmoMag = IsAmmoGrenade(ammoClassDesc);
TAmmoContainer& itemAmmo = bAmmoMag ? gstate.AmmoMags : item.Ammo;
if(itemAmmo.find(szAmmoClassDesc)==itemAmmo.end())
itemAmmo.insert(std::make_pair(szAmmoClassDesc,int(event.value)));
else
itemAmmo[szAmmoClassDesc] = (uint16)event.value;
if(!bRecording && (m_bLogWarning || demo_forceGameState==2))
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
CInventory* pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
IItem* pItem = pInventory->GetItemByName(itemClassDesc);
if(pItem)
{
CWeapon* pWeapon = (CWeapon*)(pItem->GetIWeapon());
if(pWeapon)
{
IEntityClass* pAmmoClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ammoClassDesc);
if(pAmmoClass)
{
if(m_bLogWarning)
{
int curAmmoCount = (bAmmoMag ? pInventory->GetAmmoCount(pAmmoClass) :
pWeapon->GetAmmoCount(pAmmoClass));
CheckDifference( int(event.value),curAmmoCount,"TimeDemo:GameState: Frame %d - Actor %s - AMMO COUNT mismatch for ammo class %s (rec:%d, cur:%d)",pEntity,ammoClassDesc);
}
if(demo_forceGameState==2)
pWeapon->SetAmmoCount(pAmmoClass,int(event.value));
}
}
}
}
}
}
}
else
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - AMMO COUNT null ammoClass descriptor",m_currentFrame,pEntity->GetName());
}
else
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - AMMO COUNT wrong item selected (%s)",m_currentFrame,pEntity->GetName(),itemClassDesc);
}
break;
case eGE_AttachedAccessory:
{
// always force attachment of accessory to the current weapon
// kind of a workaround, the HUD weapon modifier menu is spawned during timedemo playback
// but it doesn't use recorded input events
if(!bRecording)
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
CInventory* pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
const char* sel = event.description;
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(sel);
if(!sel)
sel = "(null)";
if(!pInventory->HasAccessory(pClass))
{
if(m_bLogWarning)
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - ATTACHED ACCESSORY %s not found in current inventory", m_currentFrame,pEntity->GetName(),sel);
}
else
{
CItem* pCurrentItem = (CItem*)(pActor->GetCurrentItem());
if(pCurrentItem)
pCurrentItem->SwitchAccessory(sel);
}
}
}
}
}
break;
case eGE_EntityGrabbed:
{
if(demo_forceGameState==2)
{
TItemName itemName = event.description;
if(itemName)
{
IEntity * pGrabbedEntity = gEnv->pEntitySystem->FindEntityByName(itemName);
if(pGrabbedEntity)
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
IItem* pItem = GetItemOfName(pActor,itemName);
if(!pItem)
{
// it's a pickable entity, won't end up in the inventory
//(otherwise it would be managed by eGE_ItemPickedUp)
COffHand* pOffHand = static_cast<COffHand*>(pActor->GetWeaponByClass(CItem::sOffHandClass));
if(pOffHand && !pOffHand->GetPreHeldEntityId())
pOffHand->ForcePickUp(pGrabbedEntity->GetId());
}
}
}
}
}
}
break;
default:
break;
}
}
void CGameStateRecorder::DumpWholeGameState(const CActor* pActor)
{
GameplayEvent event;
IEntity* pEntity = pActor->GetEntity();
// health
float health = (float)pActor->GetHealth();
event.event = eGE_HealthChanged;
event.value = health;
SendGamePlayEvent(pEntity,event);
// Inventory
CInventory *pInventory = (CInventory*)(pActor->GetInventory());
if(!pInventory)
return;
int count = pInventory->GetCount();
for(int i=0; i<count; ++i)
{
EntityId itemId = pInventory->GetItem(i);
CItem* pItem=NULL;
TItemName itemName = GetItemName(itemId,&pItem);
if(pItem && itemName)
{
event.event = eGE_ItemPickedUp;
event.description = itemName;
SendGamePlayEvent(pEntity,event);
if(pActor->GetCurrentItem() == pItem)
{
event.event = eGE_ItemSelected;
event.description = itemName;
event.value = 1; // for initialization
SendGamePlayEvent(pEntity,event);
}
CWeapon* pWeapon = (CWeapon*)(pItem->GetIWeapon());
if(pWeapon)
{
IEntityClass* pItemClass = pWeapon->GetEntity()->GetClass();
if(pItemClass && !strcmpi(pItemClass->GetName(),"binoculars"))
continue; // no fire mode or ammo recorded for binocular (which is a weapon)
// fire mode
int fireModeIdx = pWeapon->GetCurrentFireMode();
event.event = eGE_WeaponFireModeChanged;
event.value = (float)fireModeIdx;
event.description = itemName;
SendGamePlayEvent(pEntity,event);
// count ammo
for(SWeaponAmmo weaponAmmo = pWeapon->GetFirstAmmo(); weaponAmmo.pAmmoClass ; weaponAmmo = pWeapon->GetNextAmmo())
{
const char* ammoClass;
if(weaponAmmo.pAmmoClass && (ammoClass = weaponAmmo.pAmmoClass->GetName()))
{
event.event = eGE_AmmoCount;
event.value = (float)weaponAmmo.count;
event.extra = (void*)ammoClass;
event.description = (const char*)itemName;
SendGamePlayEvent(pEntity,event);
}
}
}
}
}
count = pInventory->GetAccessoryCount();
for(int i=0; i< count; i++)
{
const char* accessory = pInventory->GetAccessory(i);
if(accessory && strlen(accessory))
{
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(accessory);
if(pClass)
{
TItemName classItem = pClass->GetName();
event.event = eGE_AccessoryPickedUp;
//event.value = classIdx;
event.description = classItem;
SendGamePlayEvent(pEntity,event);
}
}
}
int nInvAmmo = pInventory->GetAmmoPackCount();
pInventory->AmmoIteratorFirst();
for(int j=0 ; !pInventory->AmmoIteratorEnd(); j++, pInventory->AmmoIteratorNext())
{
const IEntityClass* pAmmoClass = pInventory->AmmoIteratorGetClass();
if(pAmmoClass)
{
const char* ammoClassName = pAmmoClass->GetName();
int ammoCount = pInventory->AmmoIteratorGetCount();
GameplayEvent event;
event.event = eGE_AmmoPickedUp;
event.description = ammoClassName;
event.value = (float)ammoCount;
SendGamePlayEvent(pEntity,event);
}
}
}
/*template <class EventHandlerFunc> */void CGameStateRecorder::CheckInventory(CActor* pActor, IItem *pItem)//, EventHandlerFunc eventHandler)
{
if(pActor)
{
TGameStates::iterator itGS;
if(pActor->IsPlayer())
itGS = m_itSingleActorGameState;
else if(pActor->GetEntity())
itGS = m_GameStates.find(pActor->GetEntity()->GetId());
else
return;
if(itGS != m_GameStates.end())
{
SActorGameState& gstate = itGS->second;
// items
CInventory *pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
bool bSingleItem = (pItem!=0);
int nInvItems = (bSingleItem ? 1 : pInventory->GetCount());
TItemContainer& Items = gstate.Items;
for(int i=0; i< nInvItems; i++)
{
if(!bSingleItem)
pItem = g_pGame->GetIGameFramework()->GetIItemSystem()->GetItem(pInventory->GetItem(i));
if(pItem)
{
TItemName szItemName = GetItemName(pItem->GetEntityId());
TItemContainer::iterator it = Items.find(szItemName);
if(it==Items.end())
{
it = (Items.insert(std::make_pair(szItemName,SItemProperties()))).first;
GameplayEvent event;
event.event = eGE_ItemPickedUp;
event.description = szItemName;
//eventHandler(pActor,event);
SendGamePlayEvent(pActor->GetEntity(),event);
SItemProperties& recItem = it->second;
CWeapon *pWeapon = (CWeapon*)(pItem->GetIWeapon());
if(pWeapon)
{
// ammo
for(SWeaponAmmo weaponAmmo = pWeapon->GetFirstAmmo(); weaponAmmo.pAmmoClass ; weaponAmmo = pWeapon->GetNextAmmo())
{
int ammoCount = weaponAmmo.count;
string ammoClass;
if(weaponAmmo.pAmmoClass && (ammoClass = weaponAmmo.pAmmoClass->GetName()))
{
TAmmoContainer& recAmmo = recItem.Ammo;
if(recAmmo.find(ammoClass) == recAmmo.end())
recAmmo.insert(std::make_pair(ammoClass,0));
int recAmmoCount = recAmmo[ammoClass];
if(ammoCount!=recAmmoCount)
{
GameplayEvent event;
event.event = eGE_AmmoCount;
event.value = (float)ammoCount;
event.extra = (void*)(ammoClass.c_str());
event.description = (const char*)szItemName;
//eventHandler(pActor,event);
SendGamePlayEvent(pActor->GetEntity(),event);
}
}
}
// current fire mode
int curFireModeIdx = pWeapon->GetCurrentFireMode();
int recFireModeIdx = recItem.fireMode;
if(curFireModeIdx!= recFireModeIdx)
{
GameplayEvent event;
event.event = eGE_WeaponFireModeChanged;
event.value = (float)curFireModeIdx;
event.description = (const char*)szItemName;
//eventHandler(pActor,event);
SendGamePlayEvent(pActor->GetEntity(),event);
}
}
}
}
}
/// Accessories
int nInvAccessories = pInventory->GetAccessoryCount();
TAccessoryContainer& Accessories = gstate.Accessories;
int nRecAccessories = Accessories.size();
for(int j=0 ; j< nInvAccessories; j++)
{
const char* accessory = pInventory->GetAccessory(j);
if(accessory && strlen(accessory))
{
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(accessory);
if(pClass)
{
TItemName itemClass = pClass->GetName();
TAccessoryContainer::iterator it = Accessories.find(itemClass);
if(it==Accessories.end())
{
GameplayEvent event;
event.event = eGE_AccessoryPickedUp;
//event.value = accIdx;
event.description = itemClass;
// eventHandler(pActor,event);
SendGamePlayEvent(pActor->GetEntity(),event);
}
}
}
}
/// Ammo
TAmmoContainer& Ammo = gstate.AmmoMags;
int nRecAmmo = Ammo.size();
int nInvAmmo = pInventory->GetAmmoPackCount();
pInventory->AmmoIteratorFirst();
for(int j=0 ; !pInventory->AmmoIteratorEnd(); j++, pInventory->AmmoIteratorNext())
{
TAmmoContainer& Mags = gstate.AmmoMags;
const IEntityClass* pAmmoClass = pInventory->AmmoIteratorGetClass();
if(pAmmoClass)
{
const char* ammoClassName = pAmmoClass->GetName();
int ammoCount = pInventory->AmmoIteratorGetCount();
if(Mags.find(ammoClassName) == Mags.end() || ammoCount!= Mags[ammoClassName])
{
GameplayEvent event;
event.event = eGE_AmmoPickedUp;
event.description = ammoClassName;
event.value = (float)ammoCount;
// eventHandler(pActor,event);
SendGamePlayEvent(pActor->GetEntity(),event);
}
}
}
}
}
}
}
float CGameStateRecorder::RenderInfo(float y, bool bRecording)
{
float retY = 0;
IRenderer *pRenderer = gEnv->pRenderer;
if (bRecording)
{
float fColor[4] = {1,0,0,1};
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false," Recording game state");
retY +=15;
}
else
{
const float xp = 300;
const float xr = 400;
const float xri = 600;
float fColor[4] = {0,1,0,1};
float fColorWarning[4] = {1,1,0,1};
const char* actorName = m_demo_actorInfo->GetString();
CActor *pActor = GetActorOfName(actorName);
if(pActor)
{
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false," Game state - Actor: %s --------------------------------------------------",pActor->GetEntity()? pActor->GetEntity()->GetName(): "(no entity)");
retY +=15;
if(m_itSingleActorGameState != m_GameStates.end() && pActor->GetEntity() && m_itSingleActorGameState->first == pActor->GetEntity()->GetId())
{
ICVar *pVar = gEnv->pConsole->GetCVar( "demo_force_game_state" );
if(pVar)
{
int demo_forceGameState = pVar->GetIVal();
if(demo_forceGameState)
{
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false,demo_forceGameState==1 ?
" Override mode = (health, suit energy)" : " Override mode = (all)");
retY +=15;
}
}
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, fColor,false,"Current");
pRenderer->Draw2dLabel( xr,y+retY, 1.3f, fColor,false,"Recorded");
retY +=15;
SActorGameState& gstate = m_itSingleActorGameState->second;
float recordedHealth = (float)gstate.health;
float health = (float)pActor->GetHealth();
bool bError = CHECK_MISMATCH(health, recordedHealth,10);
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false," Health:");
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, bError? fColorWarning : fColor, false,"%d",(int)health);
pRenderer->Draw2dLabel( xr,y+retY, 1.3f, bError? fColorWarning : fColor, false,"%d",(int)recordedHealth);
retY +=15;
// items
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false," Inventory ---------------------------------------------------------------------------------------");
retY +=15;
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, fColor,false,"Current");
pRenderer->Draw2dLabel( xri,y+retY, 1.3f, fColor,false,"Recorded");
retY +=15;
CInventory *pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
int nInvItems = pInventory->GetCount();
TItemContainer& Items = gstate.Items;
int nRecItems = Items.size();
int maxItems = max(nRecItems,nInvItems);
int i=0;
EntityId curSelectedId = pActor->GetCurrentItemId();
TItemName curSelClass = GetItemName(curSelectedId);
bool bSelectedError = !equal_strings(gstate.itemSelected,curSelClass);
for(; i< nInvItems; i++)
{
IItem *pItem = g_pGame->GetIGameFramework()->GetIItemSystem()->GetItem(pInventory->GetItem(i));
if(pItem)
{
TItemName szItemName = GetItemName(pItem->GetEntityId());
TItemContainer::iterator it = Items.find(szItemName);
bError = it==Items.end();
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false," %2d)",i+1);
EntityId curId = pItem->GetEntityId();
TItemName curClass = GetItemName(curId);
if(equal_strings(curClass,curSelClass) )
pRenderer->Draw2dLabel( xp-16,y+retY, 1.3f,bSelectedError ? fColorWarning:fColor, false, "[]");
if(equal_strings(szItemName, gstate.itemSelected))
pRenderer->Draw2dLabel( xri-16,y+retY, 1.3f,bSelectedError ? fColorWarning:fColor, false, "[]");
char itemName[32];
const char* originalItemName = pItem->GetEntity() ? pItem->GetEntity()->GetName():"(null)";
int length = strlen(originalItemName);
length = min(length,31);
strncpy(itemName,originalItemName,length);
itemName[length]=0;
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, bError? fColorWarning : fColor, false," %s",itemName);
if(bError)
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, fColorWarning, false, "Missing");
else
{
SItemProperties& recItem = it->second;
CWeapon *pWeapon = (CWeapon*)(pItem->GetIWeapon());
IEntityClass* pItemClass = pItem->GetEntity()->GetClass();
if(pItemClass && !strcmpi(pItemClass->GetName(),"binoculars"))
pWeapon = NULL; // no fire mode or ammo recorded for binocular (which is a weapon)
if(pWeapon)
{
int idx = 0;
// ammo
float xa = 0;
for(SWeaponAmmo weaponAmmo = pWeapon->GetFirstAmmo(); weaponAmmo.pAmmoClass ; weaponAmmo = pWeapon->GetNextAmmo())
{
int ammoCount = weaponAmmo.count;
const char* ammoClass;
if(weaponAmmo.pAmmoClass && (ammoClass = weaponAmmo.pAmmoClass->GetName()))
{
TAmmoContainer::iterator it = recItem.Ammo.find(ammoClass);
if(it!=recItem.Ammo.end())
{
int recAmmoCount = recItem.Ammo[ammoClass];
bool bError2 = ammoCount!=recAmmoCount;
pRenderer->Draw2dLabel( xp+xa,y+retY, 1.3f, bError2? fColorWarning : fColor, false,"Am%d:%d",idx,ammoCount);
pRenderer->Draw2dLabel( xri+xa,y+retY, 1.3f, bError2? fColorWarning : fColor, false,"Am%d:%d",idx,recAmmoCount);
xa += 50;
++idx;
if(idx%5 ==0)
{
xa=0;
retY+=15;
}
}
}
}
// current fire mode
int curFireModeIdx = pWeapon->GetCurrentFireMode();
int recFireModeIdx = recItem.fireMode;
bool bError3 = curFireModeIdx!= recFireModeIdx;
pRenderer->Draw2dLabel( xp+xa,y+retY, 1.3f, bError3? fColorWarning : fColor, false,"FMode:%d",curFireModeIdx);
pRenderer->Draw2dLabel( xri+xa,y+retY, 1.3f, bError3? fColorWarning : fColor, false,"FMode:%d",recFireModeIdx);
}
else
{
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, fColor, false, "Ok");
}
}
}
retY +=15;
}
/// Accessories
int nInvAccessories = pInventory->GetAccessoryCount();
TAccessoryContainer& Accessories = gstate.Accessories;
int nRecAccessories = Accessories.size();
if(nRecAccessories)
{
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, bError? fColorWarning : fColor, false," Accessories");
retY +=15;
}
for(int j=0 ; j< nInvAccessories; j++,i++)
{
const char* accessory = pInventory->GetAccessory(j);
if(accessory && strlen(accessory))
{
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(accessory);
if(pClass)
{
TItemName szItemName = pClass->GetName();
TAccessoryContainer::iterator it = Accessories.find(szItemName);
bError = it==Accessories.end();
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false," %2d)",i+1);
char itemName[32];
int length = strlen(accessory);
length = min(length,31);
strncpy(itemName,accessory,length);
itemName[length]=0;
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, bError? fColorWarning : fColor, false," %s",itemName);
if(bError)
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, fColorWarning, false, "Missing");
else
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, fColor, false, "Ok");
retY +=15;
}
}
}
/// Ammo Mags
TAmmoContainer& Ammo = gstate.AmmoMags;
int nRecAmmo = Ammo.size();
int nInvAmmo = pInventory->GetAmmoPackCount();
if(nInvAmmo)
{
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, bError? fColorWarning : fColor, false," Ammo Packs");
retY +=15;
}
pInventory->AmmoIteratorFirst();
for(int j=0 ; !pInventory->AmmoIteratorEnd(); j++, pInventory->AmmoIteratorNext())
{
TAmmoContainer& Mags = gstate.AmmoMags;
const IEntityClass* pAmmoClass = pInventory->AmmoIteratorGetClass();
if(pAmmoClass)
{
int invAmmoCount = pInventory->AmmoIteratorGetCount();
const char* ammoClassName = pAmmoClass->GetName();
bool bNotFound = Mags.find(ammoClassName) == Mags.end();
int recAmmoCount = bNotFound ? 0 :Mags[ammoClassName];
bool bError = bNotFound || invAmmoCount!= recAmmoCount;
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, bError? fColorWarning : fColor, false," %s:",ammoClassName);
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, bError? fColorWarning : fColor, false,"%d",invAmmoCount);
if(bNotFound)
pRenderer->Draw2dLabel( xr,y+retY, 1.3f, fColorWarning, false,"NotRecd");
else
pRenderer->Draw2dLabel( xr,y+retY, 1.3f, bError? fColorWarning : fColor, false,"%d",recAmmoCount);
retY +=15;
}
}
}
}
else // m_itSingleActorGameState != m_GameStates.end()
{
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false, "<<Not Recorded>>");
retY +=15;
}
}
else // pActor
{
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false, "<<Actor %s not in the map>>",actorName ? actorName:"(no name)");
retY +=15;
}
}
return retY;
}
void displayInventory()
{
float x= 8/800.0f;
float y= 8/600.0f;
float w=128/800.0f;
float h=128/600.0f;
_Clicked=0;
h=(128-42)/600.0f;
y=y+.03f;
uint8 whereInOrder = 0;
map<uint32,uint8>::iterator it;
for(it = CharacterInventory._Inventory.begin(); it!=CharacterInventory._Inventory.end(); it++)
{
whereInOrder++;
string itemname;
char Buf[20];
sprintf(Buf, "%d", (*it).first);
itemname = Buf;
uint8 itemquantity = (*it).second;
//nlinfo("displayinv: %s %d",itemname, itemquantity);
w = 64/800.0f;
h = 64/600.0f;
string filename = itemname+"Icon.tga";
// nlinfo("loading texture: %s",filename);
NL3D::UTexture *iconTexture = Driver->createTextureFile (filename);
// nlinfo("placing at %f",(1-(h+y)));
if (iconTexture!=NULL)
{
Driver->setMatrixMode2D ( CFrustum (0.0f, ScreenWidth, 0.0f, ScreenHeight, 0.0f, 1.0f, false));
// Driver->drawBitmap (10, ScreenHeight-128-10, 128, 128, *iconTexture);
// Driver->drawBitmap (ScreenWidth-128-10, ScreenHeight-16-10, 128, 16, *iconTexture);
if ((*it).first == CharacterInventory.getSelected())
{
// nlinfo("drawing quad");
// Driver->setMatrixMode2D11 ();
// Driver->drawQuad( 0.0149f, 0.96f-(whereInOrder*0.08f), 0.077f, 1.04f-(whereInOrder*0.08f) ,CRGBA(100,0,0,100));
Driver->drawBitmap (15, ScreenHeight-24-(whereInOrder*72), 64, 64, *SelectedTexture);
// nlinfo("xLeft %f yBottom %f xRight %f yTop %f", xLeft,yBottom,xRight,yTop);
// 0.1 0.8, 0.2, 0.9
}
Driver->drawBitmap (15, ScreenHeight-24-(whereInOrder*72), 64, 64, *iconTexture);
// nlinfo("drawBitmap at x %f y %f", x, y);
//_ClickMap[(1-(h+y))]=(*it).first;
}
// if ((*it).first == CharacterInventory.getSelected()) TextContext->setColor(CRGBA(255,0,255,255));
// else TextContext->setColor(CRGBA(255,255,255,255));
// TextContext->printfAt(x+.03f+w/2.0f,1.0f-h-y+.01f,"%d %s", itemquantity, itemname);
y=y+.07f;
// nlinfo("outof loop");
}
if(_Clicked)
{
float x= 8/800.0f;
float y= 8/600.0f;
float w=128/800.0f;
float h=128/600.0f;
y=y+.03f;
w = 32/800.0f;
h = 32/600.0f;
string itemname = "";
string filename = itemname+"Icon.tga";
// uint32 itemquantity = CharacterInventory.getInventory()[_Clicked];
// NL3D::UTexture *iconTexture = Driver->createTextureFile (filename);
// Driver->drawBitmap (x, 1-(h+y), w, h, *iconTexture);
// TextContext->printfAt(x+.02f+w/2.0f,(1.0f-h-y+.01f)+0.03f,"%d %s", itemquantity, itemname);
}
}
