2010-05-06 00:08:41 +00:00
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
# include "stdpch.h"
2012-04-16 04:08:12 +00:00
# include "nel/misc/cdb_leaf.h"
# include "nel/misc/cdb_branch.h"
2010-05-06 00:08:41 +00:00
# include "inventory_manager.h"
# include "interface_manager.h"
# include "bot_chat_page_trade.h"
# include "bot_chat_page_all.h"
# include "group_container.h"
# include "group_menu.h"
2012-04-16 04:08:12 +00:00
# include "nel/misc/cdb_leaf.h"
# include "nel/misc/cdb_branch.h"
2010-05-06 00:08:41 +00:00
# include "list_sheet_base.h"
# include "../net_manager.h"
# include "../user_entity.h"
# include "../global.h"
# include "nel/misc/algo.h"
// TODO: remove this ugly dependence
# include "sphrase_manager.h"
// For handlers
2012-06-08 23:37:43 +00:00
# include "nel/gui/action_handler.h"
2010-05-06 00:08:41 +00:00
# include "dbctrl_sheet.h"
# include "../sheet_manager.h"
# include "game_share/slot_equipment.h"
# include "game_share/animal_status.h"
2012-02-27 15:10:47 +00:00
# include "game_share/bot_chat_types.h"
2010-05-06 00:08:41 +00:00
# include "../client_cfg.h"
using namespace std ;
using namespace NLMISC ;
2012-02-27 15:10:47 +00:00
extern NLMISC : : CLog g_log ;
2010-05-06 00:08:41 +00:00
// Context help
extern void contextHelp ( const std : : string & help ) ;
CTempInvManager * CTempInvManager : : _Instance = NULL ;
CInventoryManager * CInventoryManager : : _Instance = NULL ;
NLMISC_REGISTER_OBJECT ( CViewBase , CDBGroupListSheetBag , std : : string , " list_sheet_bag " ) ;
NLMISC_REGISTER_OBJECT ( CViewBase , CDBGroupIconListBag , std : : string , " list_icon_bag " ) ;
NLMISC_REGISTER_OBJECT ( CViewBase , CDBGroupListSheetFilterCLMSlot , std : : string , " list_sheet_filter_clm_slot " ) ;
NLMISC_REGISTER_OBJECT ( CViewBase , CDBGroupListSheetFilterExchangeable , std : : string , " list_sheet_filter_exchangeable " ) ;
// ***************************************************************************
// db path for all the inventories (without the SERVER: prefix)
const std : : string CInventoryManager : : InventoryDBs [ ] =
{
" INVENTORY:BAG " ,
// MAX_INVENTORY_ANIMAL
" INVENTORY:PACK_ANIMAL0 " ,
" INVENTORY:PACK_ANIMAL1 " ,
" INVENTORY:PACK_ANIMAL2 " ,
" INVENTORY:PACK_ANIMAL3 " ,
" INVENTORY:TEMP " ,
" EXCHANGE:GIVE " ,
" EXCHANGE:RECEIVE " ,
" TRADING " ,
" INVENTORY:SHARE " ,
" GUILD:INVENTORY " ,
" INVENTORY:ROOM " ,
} ;
static void dummyCheck ( )
{
// if this raise, correct the 2 tables above and below
nlctassert ( MAX_INVENTORY_ANIMAL = = 4 ) ;
}
const uint CInventoryManager : : InventoryIndexes [ ] =
{
INVENTORIES : : bag ,
// MAX_INVENTORY_ANIMAL
INVENTORIES : : pet_animal1 ,
INVENTORIES : : pet_animal2 ,
INVENTORIES : : pet_animal3 ,
INVENTORIES : : pet_animal4 ,
INVENTORIES : : temporary ,
INVENTORIES : : exchange ,
INVENTORIES : : exchange_proposition ,
INVENTORIES : : trading ,
INVENTORIES : : reward_sharing ,
INVENTORIES : : guild ,
INVENTORIES : : player_room ,
} ;
const uint CInventoryManager : : NumInventories = sizeof ( CInventoryManager : : InventoryDBs ) / sizeof ( CInventoryManager : : InventoryDBs [ 0 ] ) ;
// *************************************************************************************************
CItemImage : : CItemImage ( )
{
Sheet = NULL ;
Quality = NULL ;
Quantity = NULL ;
UserColor = NULL ;
Price = NULL ;
Weight = NULL ;
NameId = NULL ;
InfoVersion = NULL ;
}
// *************************************************************************************************
void CItemImage : : build ( CCDBNodeBranch * branch )
{
if ( ! branch ) return ;
Sheet = dynamic_cast < CCDBNodeLeaf * > ( branch - > getNode ( ICDBNode : : CTextId ( " SHEET " ) , false ) ) ;
Quality = dynamic_cast < CCDBNodeLeaf * > ( branch - > getNode ( ICDBNode : : CTextId ( " QUALITY " ) , false ) ) ;
Quantity = dynamic_cast < CCDBNodeLeaf * > ( branch - > getNode ( ICDBNode : : CTextId ( " QUANTITY " ) , false ) ) ;
UserColor = dynamic_cast < CCDBNodeLeaf * > ( branch - > getNode ( ICDBNode : : CTextId ( " USER_COLOR " ) , false ) ) ;
Price = dynamic_cast < CCDBNodeLeaf * > ( branch - > getNode ( ICDBNode : : CTextId ( " PRICE " ) , false ) ) ;
Weight = dynamic_cast < CCDBNodeLeaf * > ( branch - > getNode ( ICDBNode : : CTextId ( " WEIGHT " ) , false ) ) ;
NameId = dynamic_cast < CCDBNodeLeaf * > ( branch - > getNode ( ICDBNode : : CTextId ( " NAMEID " ) , false ) ) ;
InfoVersion = dynamic_cast < CCDBNodeLeaf * > ( branch - > getNode ( ICDBNode : : CTextId ( " INFO_VERSION " ) , false ) ) ;
2012-02-27 15:10:47 +00:00
ResaleFlag = dynamic_cast < CCDBNodeLeaf * > ( branch - > getNode ( ICDBNode : : CTextId ( " RESALE_FLAG " ) , false ) ) ;
2010-05-06 00:08:41 +00:00
// Should always have at least those one:(ie all but Price)
nlassert ( Sheet & & Quality & & Quantity & & UserColor & & Weight & & NameId & & InfoVersion ) ;
}
// *************************************************************************************************
// CInventoryManager
// *************************************************************************************************
// *************************************************************************************************
CInventoryManager : : CInventoryManager ( )
{
Money = NULL ;
ServerMoney = NULL ;
uint i ;
for ( i = 0 ; i < MAX_HANDINV_ENTRIES ; + + i )
{
Hands [ i ] = ServerHands [ i ] = 0 ;
UIHands [ i ] = NULL ;
}
for ( i = 0 ; i < MAX_EQUIPINV_ENTRIES ; + + i )
{
Equip [ i ] = ServerEquip [ i ] = 0 ;
UIEquip [ i ] = NULL ;
UIEquip2 [ i ] = NULL ;
}
for ( i = 0 ; i < MAX_BAGINV_ENTRIES ; i + + )
{
BagItemEquipped [ i ] = false ;
}
nlctassert ( NumInventories = = sizeof ( InventoryIndexes ) / sizeof ( InventoryIndexes [ 0 ] ) ) ;
}
// ***************************************************************************
CInventoryManager : : ~ CInventoryManager ( )
{
}
// *************************************************************************************************
CInventoryManager * CInventoryManager : : getInstance ( )
{
if ( ! _Instance )
_Instance = new CInventoryManager ( ) ;
return _Instance ;
}
// ***************************************************************************
void CInventoryManager : : releaseInstance ( )
{
if ( _Instance )
delete _Instance ;
_Instance = NULL ;
}
// *************************************************************************************************
CItemImage & CInventoryManager : : getBagItem ( uint index )
{
nlassert ( index < MAX_BAGINV_ENTRIES ) ;
return Bag [ index ] ;
}
// *************************************************************************************************
CItemImage & CInventoryManager : : getTempItem ( uint index )
{
nlassert ( index < MAX_TEMPINV_ENTRIES ) ;
return TempInv [ index ] ;
}
// *************************************************************************************************
CItemImage * CInventoryManager : : getHandItem ( uint index )
{
nlassert ( index < MAX_HANDINV_ENTRIES ) ;
if ( Hands [ index ] ! = 0 )
return & Bag [ Hands [ index ] - 1 ] ;
else
return NULL ;
}
// *************************************************************************************************
CItemImage * CInventoryManager : : getEquipItem ( uint index )
{
nlassert ( index < MAX_EQUIPINV_ENTRIES ) ;
if ( Equip [ index ] ! = 0 )
return & Bag [ Equip [ index ] ] ;
else
return NULL ;
}
// *************************************************************************************************
CDBCtrlSheet * CInventoryManager : : getHandSheet ( uint index )
{
return UIHands [ index ] ;
}
// *************************************************************************************************
CDBCtrlSheet * CInventoryManager : : getEquipSheet ( uint index )
{
return UIEquip [ index ] ;
}
// *************************************************************************************************
CItemImage & CInventoryManager : : getServerBagItem ( uint index )
{
nlassert ( index < MAX_BAGINV_ENTRIES ) ;
return ServerBag [ index ] ;
}
// *************************************************************************************************
CItemImage & CInventoryManager : : getServerTempItem ( uint index )
{
nlassert ( index < MAX_TEMPINV_ENTRIES ) ;
return ServerTempInv [ index ] ;
}
// *************************************************************************************************
CItemImage * CInventoryManager : : getServerHandItem ( uint index )
{
nlassert ( index < MAX_HANDINV_ENTRIES ) ;
if ( ServerHands [ index ] ! = 0 )
return & ServerBag [ ServerHands [ index ] ] ;
else
return NULL ;
}
// *************************************************************************************************
CItemImage * CInventoryManager : : getServerEquipItem ( uint index )
{
nlassert ( index < MAX_EQUIPINV_ENTRIES ) ;
if ( ServerEquip [ index ] ! = 0 )
return & ServerBag [ ServerEquip [ index ] ] ;
else
return NULL ;
}
// *************************************************************************************************
uint64 CInventoryManager : : getMoney ( ) const
{
return Money ? Money - > getValue64 ( ) : 0 ;
}
// *************************************************************************************************
void CInventoryManager : : setMoney ( uint64 value )
{
if ( Money ) Money - > setValue64 ( value ) ;
}
// *************************************************************************************************
uint64 CInventoryManager : : getServerMoney ( ) const
{
return ServerMoney ? ServerMoney - > getValue64 ( ) : 0 ;
}
// *************************************************************************************************
void CInventoryManager : : setServerMoney ( uint64 value )
{
if ( ServerMoney ) ServerMoney - > setValue64 ( value ) ;
}
// *************************************************************************************************
void CInventoryManager : : init ( )
{
CInterfaceManager * im = CInterfaceManager : : getInstance ( ) ;
// LOCAL DB
initItemArray ( LOCAL_INVENTORY " :BAG " , Bag , MAX_BAGINV_ENTRIES ) ;
initItemArray ( LOCAL_INVENTORY " :TEMP " , TempInv , MAX_TEMPINV_ENTRIES ) ;
2012-05-24 03:02:24 +00:00
Money = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :MONEY " ) ;
2010-05-06 00:08:41 +00:00
initIndirection ( LOCAL_INVENTORY " :HAND: " , Hands , MAX_HANDINV_ENTRIES , true ) ;
initIndirection ( LOCAL_INVENTORY " :EQUIP: " , Equip , MAX_EQUIPINV_ENTRIES , true ) ;
// Init observers for auto equipment
{
for ( uint i = 0 ; i < MAX_BAGINV_ENTRIES ; + + i )
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :BAG: " + toString ( i ) + " :SHEET " ) ;
2010-05-06 00:08:41 +00:00
ICDBNode : : CTextId textId ;
pNL - > addObserver ( & _DBBagObs , textId ) ;
}
}
// Init Animals
for ( uint i = 0 ; i < MAX_INVENTORY_ANIMAL ; i + + )
initItemArray ( toString ( LOCAL_INVENTORY " :PACK_ANIMAL%d " , i ) , PAInv [ i ] , MAX_ANIMALINV_ENTRIES ) ;
// SERVER DB
initItemArray ( SERVER_INVENTORY " :BAG " , ServerBag , MAX_BAGINV_ENTRIES ) ;
initItemArray ( SERVER_INVENTORY " :TEMP " , ServerTempInv , MAX_TEMPINV_ENTRIES ) ;
2012-05-24 03:02:24 +00:00
ServerMoney = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( SERVER_INVENTORY " :MONEY " ) ;
2010-05-06 00:08:41 +00:00
// Init Animals
for ( uint i = 0 ; i < MAX_INVENTORY_ANIMAL ; i + + )
initItemArray ( toString ( SERVER_INVENTORY " :PACK_ANIMAL%d " , i ) , ServerPAInv [ i ] , MAX_ANIMALINV_ENTRIES ) ;
// Drag'n'Drop
DNDCurrentItem = NULL ;
DNDFrom = Nowhere ;
// Initialize interface part
2012-05-31 02:27:27 +00:00
UIHands [ 0 ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_HAND_RIGHT ) ) ;
UIHands [ 1 ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_HAND_LEFT ) ) ;
UIEquip [ SLOT_EQUIPMENT : : HEADDRESS ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWEL_HEADDRESS ) ) ;
UIEquip [ SLOT_EQUIPMENT : : EARL ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWEL_EARING_LEFT ) ) ;
UIEquip [ SLOT_EQUIPMENT : : EARR ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWEL_EARING_RIGHT ) ) ;
UIEquip [ SLOT_EQUIPMENT : : NECKLACE ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWEL_NECK ) ) ;
UIEquip [ SLOT_EQUIPMENT : : WRISTL ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWEL_BRACELET_LEFT ) ) ;
UIEquip [ SLOT_EQUIPMENT : : WRISTR ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWEL_BRACELET_RIGHT ) ) ;
UIEquip [ SLOT_EQUIPMENT : : FINGERL ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWEL_RING_LEFT ) ) ;
UIEquip [ SLOT_EQUIPMENT : : FINGERR ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWEL_RING_RIGHT ) ) ;
UIEquip [ SLOT_EQUIPMENT : : ANKLEL ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWEL_ANKLET_LEFT ) ) ;
UIEquip [ SLOT_EQUIPMENT : : ANKLER ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWEL_ANKLET_RIGHT ) ) ;
UIEquip [ SLOT_EQUIPMENT : : HEAD ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_ARMOR_HEAD ) ) ;
UIEquip [ SLOT_EQUIPMENT : : CHEST ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_ARMOR_CHEST ) ) ;
UIEquip [ SLOT_EQUIPMENT : : ARMS ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_ARMOR_ARMS ) ) ;
UIEquip [ SLOT_EQUIPMENT : : FEET ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_ARMOR_FEET ) ) ;
UIEquip [ SLOT_EQUIPMENT : : LEGS ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_ARMOR_LEGS ) ) ;
UIEquip [ SLOT_EQUIPMENT : : HANDS ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_ARMOR_HANDS ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : HEADDRESS ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWL2_HEADDRESS ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : EARL ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWL2_EARING_LEFT ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : EARR ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWL2_EARING_RIGHT ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : NECKLACE ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWL2_NECK ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : WRISTL ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWL2_BRACELET_LEFT ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : WRISTR ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWL2_BRACELET_RIGHT ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : FINGERL ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWL2_RING_LEFT ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : FINGERR ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWL2_RING_RIGHT ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : ANKLEL ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWL2_ANKLET_LEFT ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : ANKLER ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_JEWL2_ANKLET_RIGHT ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : HEAD ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_ARMR2_HEAD ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : CHEST ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_ARMR2_CHEST ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : ARMS ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_ARMR2_ARMS ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : FEET ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_ARMR2_FEET ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : LEGS ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_ARMR2_LEGS ) ) ;
UIEquip2 [ SLOT_EQUIPMENT : : HANDS ] = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_ARMR2_HANDS ) ) ;
2010-05-06 00:08:41 +00:00
// Init ItemInfoObservers
{
CCDBNodeLeaf * nodeTS ;
2012-05-24 03:02:24 +00:00
nodeTS = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " SERVER:TRADING:SESSION " , false ) ;
2010-05-06 00:08:41 +00:00
if ( nodeTS )
{
ICDBNode : : CTextId textId ;
nodeTS - > addObserver ( & _DBTradeInfoObs , textId ) ;
}
// Init All Version obs
for ( uint i = 0 ; i < NumInventories ; i + + )
{
// Don't do it for TRADING DB
if ( InventoryIndexes [ i ] ! = INVENTORIES : : trading )
{
// since different size per inventory, stop when node not found....
for ( uint j = 0 ; ; j + + )
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * nodeIV = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " SERVER: " + InventoryDBs [ i ] + " : " + toString ( j ) + " :INFO_VERSION " , false ) ;
CCDBNodeLeaf * nodeSH = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " SERVER: " + InventoryDBs [ i ] + " : " + toString ( j ) + " :SHEET " , false ) ;
2010-05-06 00:08:41 +00:00
if ( nodeIV & & nodeSH )
{
ICDBNode : : CTextId textIdIV , textIdSH ;
nodeIV - > addObserver ( & _DBInfoSlotVersionObs , textIdIV ) ;
nodeSH - > addObserver ( & _DBItemSheetObs , textIdSH ) ;
// if current value!=0, simulate a receive item info obs
if ( nodeIV - > getValue32 ( ) )
{
onReceiveItemInfoSlotVersion ( nodeIV ) ;
}
}
else
// stop here for this inventory
break ;
}
}
}
}
}
// *************************************************************************************************
void CInventoryManager : : initItemArray ( const std : : string & dbBranchName , CItemImage * dest , uint numItems )
{
nlassert ( dest ) ;
CInterfaceManager * im = CInterfaceManager : : getInstance ( ) ;
2012-05-24 03:02:24 +00:00
CCDBNodeBranch * branch = NLGUI : : CDBManager : : getInstance ( ) - > getDbBranch ( dbBranchName ) ;
2010-05-06 00:08:41 +00:00
if ( ! branch )
{
nlwarning ( " Can't init inventory image from branch %s. " , dbBranchName . c_str ( ) ) ;
return ;
}
for ( uint k = 0 ; k < numItems ; + + k )
{
CCDBNodeBranch * itemBranch = dynamic_cast < CCDBNodeBranch * > ( branch - > getNode ( ( uint16 ) k ) ) ;
if ( ! itemBranch )
{
nlwarning ( " Can't retrieve item %d of branch %s " , ( int ) k , dbBranchName . c_str ( ) ) ;
}
else
{
dest [ k ] . build ( itemBranch ) ;
}
}
}
// ***************************************************************************
void CInventoryManager : : initIndirection ( const std : : string & dbbranch , sint32 * indices , sint32 nbIndex , bool putObs )
{
CInterfaceManager * im = CInterfaceManager : : getInstance ( ) ;
for ( uint i = 0 ; i < ( uint ) nbIndex ; + + i )
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( dbbranch + toString ( i ) + " :INDEX_IN_BAG " ) ;
2010-05-06 00:08:41 +00:00
if ( putObs )
{
ICDBNode : : CTextId textId ;
pNL - > addObserver ( & _DBEquipObs , textId ) ;
}
if ( pNL ! = NULL )
indices [ i ] = pNL - > getValue32 ( ) ;
}
}
// ***************************************************************************
void CInventoryManager : : beginDrag ( CDBCtrlSheet * pCS , TFrom From )
{
DNDCurrentItem = pCS ;
if ( pCS )
CDBCtrlSheet : : setCurrSelSheet ( pCS ) ;
DNDFrom = From ;
}
// ***************************************************************************
void CInventoryManager : : endDrag ( )
{
DNDCurrentItem = NULL ;
DNDFrom = Nowhere ;
}
// ***************************************************************************
// Used for interface objects which are reference in bag (the getSheet() returns INDEX_IN_BAG)
std : : string CInventoryManager : : getDBIndexPath ( CDBCtrlSheet * pCS )
{
string sTmp ;
uint i ;
for ( i = 0 ; i < MAX_HANDINV_ENTRIES ; + + i )
{
if ( UIHands [ i ] = = pCS )
{
return string ( LOCAL_INVENTORY ) + " :HAND: " + toString ( i ) ;
}
}
for ( i = 0 ; i < MAX_EQUIPINV_ENTRIES ; + + i )
{
if ( UIEquip [ i ] = = pCS )
{
return string ( LOCAL_INVENTORY ) + " :EQUIP: " + toString ( i ) ;
}
if ( UIEquip2 [ i ] = = pCS )
{
return string ( LOCAL_INVENTORY ) + " :EQUIP: " + toString ( i ) ;
}
}
return " " ;
}
// ***************************************************************************
bool CInventoryManager : : is2HandItem ( uint32 sheetID )
{
bool result = false ;
CEntitySheet * sheet = SheetMngr . get ( CSheetId ( sheetID ) ) ;
if ( sheet & & sheet - > type ( ) = = CEntitySheet : : ITEM )
{
CItemSheet * item = ( CItemSheet * ) sheet ;
if ( item - > hasSlot ( SLOTTYPE : : TWO_HANDS ) | | item - > hasSlot ( SLOTTYPE : : RIGHT_HAND_EXCLUSIVE ) )
result = true ;
}
return result ;
}
// ***************************************************************************
bool CInventoryManager : : isMeleeWeaponItem ( uint32 sheetID )
{
bool result = false ;
CEntitySheet * sheet = SheetMngr . get ( CSheetId ( sheetID ) ) ;
if ( sheet & & sheet - > type ( ) = = CEntitySheet : : ITEM )
{
CItemSheet * item = ( CItemSheet * ) sheet ;
if ( item - > Family = = ITEMFAMILY : : MELEE_WEAPON )
result = true ;
}
return result ;
}
// ***************************************************************************
bool CInventoryManager : : isRangeWeaponItem ( uint32 sheetID )
{
bool result = false ;
CEntitySheet * sheet = SheetMngr . get ( CSheetId ( sheetID ) ) ;
if ( sheet & & sheet - > type ( ) = = CEntitySheet : : ITEM )
{
CItemSheet * item = ( CItemSheet * ) sheet ;
if ( item - > Family = = ITEMFAMILY : : RANGE_WEAPON )
result = true ;
}
return result ;
}
// ***************************************************************************
bool CInventoryManager : : isDagger ( uint32 sheetID )
{
bool result = false ;
CEntitySheet * sheet = SheetMngr . get ( CSheetId ( sheetID ) ) ;
if ( sheet & & sheet - > type ( ) = = CEntitySheet : : ITEM )
{
CItemSheet * item = ( CItemSheet * ) sheet ;
if ( item - > ItemType = = ITEM_TYPE : : DAGGER )
result = true ;
}
return result ;
}
// ***************************************************************************
bool CInventoryManager : : isSword ( uint32 sheetID )
{
bool result = false ;
CEntitySheet * sheet = SheetMngr . get ( CSheetId ( sheetID ) ) ;
if ( sheet & & sheet - > type ( ) = = CEntitySheet : : ITEM )
{
CItemSheet * item = ( CItemSheet * ) sheet ;
if ( item - > ItemType = = ITEM_TYPE : : SWORD )
result = true ;
}
return result ;
}
// ***************************************************************************
bool CInventoryManager : : isForageToolItem ( uint32 sheetID )
{
bool result = false ;
CEntitySheet * sheet = SheetMngr . get ( CSheetId ( sheetID ) ) ;
if ( sheet & & sheet - > type ( ) = = CEntitySheet : : ITEM )
{
CItemSheet * item = ( CItemSheet * ) sheet ;
if ( item - > Family = = ITEMFAMILY : : HARVEST_TOOL )
result = true ;
}
return result ;
}
// ***************************************************************************
uint32 CInventoryManager : : getHandItemSheet ( bool rightHand ) const
{
CSheetId item ;
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
string dbPropPath = toString ( " LOCAL:INVENTORY:HAND:%d:INDEX_IN_BAG " , rightHand ? 0 : 1 ) ;
// get the RightHand bag index
2012-05-24 03:02:24 +00:00
sint32 itemSlot = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( dbPropPath ) - > getValue32 ( ) ;
2010-05-06 00:08:41 +00:00
// if something in hand
if ( itemSlot > 0 )
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * node = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " LOCAL:INVENTORY:BAG: " + toString ( itemSlot - 1 ) + " :SHEET " , false ) ;
2010-05-06 00:08:41 +00:00
if ( node )
item = node - > getValue32 ( ) ;
}
return item . asInt ( ) ;
}
// ***************************************************************************
bool CInventoryManager : : isLeftHandItemCompatibleWithRightHandItem ( uint32 leftHandSheet , uint32 rightHandSheet , uint32 lastRightHandSheet )
{
CEntitySheet * pLastRight = SheetMngr . get ( CSheetId ( lastRightHandSheet ) ) ;
if ( pLastRight ! = NULL )
{
if ( pLastRight - > type ( ) ! = CEntitySheet : : ITEM ) return false ;
CItemSheet * pIsLastRight = ( CItemSheet * ) pLastRight ;
// Last item in right hand is a 2 hand item and the new item is nothing (unequip)
if ( pIsLastRight - > hasSlot ( SLOTTYPE : : TWO_HANDS ) | | pIsLastRight - > hasSlot ( SLOTTYPE : : RIGHT_HAND_EXCLUSIVE ) )
return false ;
}
if ( leftHandSheet = = 0 ) return true ;
CEntitySheet * pLeft = SheetMngr . get ( CSheetId ( leftHandSheet ) ) ;
if ( pLeft = = NULL ) return false ;
if ( pLeft - > type ( ) ! = CEntitySheet : : ITEM ) return false ;
CItemSheet * pIsLeft = ( CItemSheet * ) pLeft ;
if ( ( pIsLeft - > Family = = ITEMFAMILY : : AMMO ) & & ( rightHandSheet = = 0 ) )
return false ;
if ( ( pIsLeft - > ItemType = = ITEM_TYPE : : DAGGER ) & & ( rightHandSheet = = 0 ) )
return false ;
CEntitySheet * pRight = SheetMngr . get ( CSheetId ( rightHandSheet ) ) ;
if ( pRight = = NULL ) return true ;
if ( pRight - > type ( ) ! = CEntitySheet : : ITEM ) return true ;
CItemSheet * pIsRight = ( CItemSheet * ) pRight ;
if ( pIsRight - > Family = = ITEMFAMILY : : RANGE_WEAPON )
{
if ( pIsLeft - > Family = = ITEMFAMILY : : AMMO )
if ( pIsRight - > RangeWeapon . Skill = = pIsLeft - > Ammo . Skill )
return true ;
}
if ( pIsLeft - > ItemType = = ITEM_TYPE : : DAGGER )
{
if ( ( pIsRight - > ItemType = = ITEM_TYPE : : SWORD ) | | ( pIsRight - > ItemType = = ITEM_TYPE : : DAGGER ) )
return true ;
else
return false ;
}
if ( ! pIsRight - > hasSlot ( SLOTTYPE : : TWO_HANDS ) & & ! pIsRight - > hasSlot ( SLOTTYPE : : RIGHT_HAND_EXCLUSIVE ) )
{
return true ;
}
return false ;
}
// ***************************************************************************
static void grayItem ( const std : : string & listname , sint32 bagEntryIndex , bool gray )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
2012-05-31 02:27:27 +00:00
IListSheetBase * pList = dynamic_cast < IListSheetBase * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( listname ) ) ;
2010-05-06 00:08:41 +00:00
if ( pList ! = NULL )
{
pList - > invalidateCoords ( ) ;
2010-11-21 14:07:59 +00:00
for ( uint i = 0 ; i < MAX_BAGINV_ENTRIES ; + + i )
2010-05-06 00:08:41 +00:00
{
CDBCtrlSheet * pCS = pList - > getSheet ( i ) ;
string sTmp = pCS - > getSheet ( ) ;
sTmp = sTmp . substr ( sTmp . rfind ( ' : ' ) + 1 , sTmp . size ( ) ) ;
sint32 nTmp ;
fromString ( sTmp , nTmp ) ;
if ( nTmp = = bagEntryIndex )
pCS - > setItemWeared ( gray ) ;
}
}
}
// ***************************************************************************
void CInventoryManager : : wearBagItem ( sint32 bagEntryIndex )
{
2010-11-21 14:07:59 +00:00
if ( bagEntryIndex > = 0 & & bagEntryIndex < ( sint32 ) MAX_BAGINV_ENTRIES )
2010-05-06 00:08:41 +00:00
{
BagItemEquipped [ bagEntryIndex ] = true ;
grayItem ( LIST_BAG_TEXT , bagEntryIndex , true ) ;
grayItem ( LIST_BAG_ICONS , bagEntryIndex , true ) ;
sortBag ( ) ;
}
}
// ***************************************************************************
void CInventoryManager : : unwearBagItem ( sint32 bagEntryIndex )
{
2010-11-21 14:07:59 +00:00
if ( bagEntryIndex > = 0 & & bagEntryIndex < ( sint32 ) MAX_BAGINV_ENTRIES )
2010-05-06 00:08:41 +00:00
{
BagItemEquipped [ bagEntryIndex ] = false ;
grayItem ( LIST_BAG_TEXT , bagEntryIndex , false ) ;
grayItem ( LIST_BAG_ICONS , bagEntryIndex , false ) ;
sortBag ( ) ;
}
}
// ***************************************************************************
bool CInventoryManager : : isBagItemWeared ( sint32 bagEntryIndex )
{
2010-11-21 14:07:59 +00:00
if ( bagEntryIndex > = 0 & & bagEntryIndex < ( sint32 ) MAX_BAGINV_ENTRIES )
2010-05-06 00:08:41 +00:00
{
return BagItemEquipped [ bagEntryIndex ] ;
}
return false ;
}
// ----------------------------------------------------------------------------
static bool isSwimming ( )
{
if ( UserEntity ! = NULL )
return ( UserEntity - > mode ( ) = = MBEHAV : : SWIM | | UserEntity - > mode ( ) = = MBEHAV : : MOUNT_SWIM ) ;
else
return false ;
}
static bool isRiding ( )
{
if ( UserEntity )
return UserEntity - > isRiding ( ) ;
else
return false ;
}
static bool isStunned ( )
{
if ( UserEntity ! = NULL )
return ( UserEntity - > behaviour ( ) = = MBEHAV : : STUNNED ) ;
else
return false ;
}
static bool isDead ( )
{
if ( UserEntity ! = NULL )
return ( UserEntity - > mode ( ) = = MBEHAV : : DEATH ) ;
else
return false ;
}
// ----------------------------------------------
// equip
//
// ----------------------------------------------
void CInventoryManager : : equip ( const std : : string & bagPath , const std : : string & invPath )
{
if ( isSwimming ( ) | | isStunned ( ) | | isDead ( ) | | isRiding ( ) ) return ;
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
if ( bagPath . empty ( ) | | invPath . empty ( ) )
{
return ;
}
// Get inventory and slot
string sIndexInBag = bagPath . substr ( bagPath . rfind ( ' : ' ) + 1 , bagPath . size ( ) ) ;
uint16 indexInBag ;
fromString ( sIndexInBag , indexInBag ) ;
uint16 inventory = INVENTORIES : : UNDEFINED ;
uint16 invSlot = 0xffff ;
if ( strnicmp ( invPath . c_str ( ) , " LOCAL:INVENTORY:HAND " , 20 ) = = 0 )
{
inventory = INVENTORIES : : handling ;
fromString ( invPath . substr ( 21 , invPath . size ( ) ) , invSlot ) ;
}
else if ( strnicmp ( invPath . c_str ( ) , " LOCAL:INVENTORY:EQUIP " , 21 ) = = 0 )
{
inventory = INVENTORIES : : equipment ;
fromString ( invPath . substr ( 22 , invPath . size ( ) ) , invSlot ) ;
}
// Hands management : check if we have to unequip left hand because of incompatibility with right hand item
2012-05-24 03:02:24 +00:00
sint16 oldRightIndexInBag = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( invPath + " :INDEX_IN_BAG " ) - > getValue16 ( ) ;
2010-05-06 00:08:41 +00:00
if ( inventory = = INVENTORIES : : handling & & invSlot = = 0 )
{
2012-05-31 02:27:27 +00:00
CDBCtrlSheet * pCSLeftHand = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_HAND_LEFT ) ) ;
2010-05-06 00:08:41 +00:00
if ( pCSLeftHand = = NULL )
{
return ;
}
// get sheet of left item
uint32 leftSheet = 0 ;
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :HAND:1:INDEX_IN_BAG " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL = = NULL )
{
return ;
}
if ( pNL - > getValue32 ( ) > 0 )
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL2 = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :BAG: " + toString ( pNL - > getValue32 ( ) - 1 ) + " :SHEET " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL2 = = NULL )
{
return ;
}
leftSheet = pNL2 - > getValue32 ( ) ;
}
// get sheet of previous right hand item
uint32 lastRightSheet = 0 ;
if ( oldRightIndexInBag > 0 )
{
2012-05-24 03:02:24 +00:00
pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :BAG: " + toString ( oldRightIndexInBag - 1 ) + " :SHEET " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL = = NULL )
{
return ;
}
lastRightSheet = pNL - > getValue32 ( ) ;
}
// get sheet of new right hand item
uint32 rightSheet = 0 ;
if ( indexInBag + 1 > 0 )
{
2012-05-24 03:02:24 +00:00
pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :BAG: " + toString ( indexInBag ) + " :SHEET " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL = = NULL )
{
return ;
}
rightSheet = pNL - > getValue32 ( ) ;
}
// If incompatible -> remove
if ( ! getInventory ( ) . isLeftHandItemCompatibleWithRightHandItem ( leftSheet , rightSheet , lastRightSheet ) )
{
getInventory ( ) . unequip ( LOCAL_INVENTORY " :HAND:1 " ) ;
}
}
// update the equip DB pointer
2012-05-24 03:02:24 +00:00
NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( invPath + " :INDEX_IN_BAG " ) - > setValue16 ( indexInBag + 1 ) ;
2010-05-06 00:08:41 +00:00
// Yoyo add: when the user equip an item, the action are invalid during some time
if ( indexInBag < MAX_BAGINV_ENTRIES )
{
CItemSheet * pIS = dynamic_cast < CItemSheet * > ( SheetMngr . get ( CSheetId ( getBagItem ( indexInBag ) . getSheetID ( ) ) ) ) ;
if ( pIS )
{
CSPhraseManager * pPM = CSPhraseManager : : getInstance ( ) ;
pPM - > setEquipInvalidation ( NetMngr . getCurrentServerTick ( ) , pIS - > EquipTime ) ;
}
}
// Update trade window if any
if ( ( BotChatPageAll ! = NULL ) & & ( BotChatPageAll - > Trade ! = NULL ) )
BotChatPageAll - > Trade - > invalidateCoords ( ) ;
// Send message to the server
if ( inventory ! = INVENTORIES : : UNDEFINED )
{
CBitMemStream out ;
const string sMsg = " ITEM:EQUIP " ;
if ( GenericMsgHeaderMngr . pushNameToStream ( sMsg , out ) )
{
// Fill the message (equiped inventory, equiped inventory slot, bag slot)
out . serial ( inventory ) ;
out . serial ( invSlot ) ;
out . serial ( indexInBag ) ;
NetMngr . push ( out ) ;
pIM - > incLocalSyncActionCounter ( ) ;
//nlinfo("impulseCallBack : %s %d %d %d sent", sMsg.c_str(), inventory, invSlot, indexInBag);
}
else
{
nlwarning ( " don't know message name %s " , sMsg . c_str ( ) ) ;
}
}
}
// ----------------------------------------------
// unequip
//
// ----------------------------------------------
void CInventoryManager : : unequip ( const std : : string & invPath )
{
if ( isSwimming ( ) | | isStunned ( ) | | isDead ( ) ) return ;
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
2012-05-24 03:02:24 +00:00
sint16 oldIndexInBag = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( invPath + " :INDEX_IN_BAG " ) - > getValue16 ( ) ;
2010-05-06 00:08:41 +00:00
if ( oldIndexInBag = = 0 )
{
return ;
}
// Get inventory and slot
uint16 inventory = INVENTORIES : : UNDEFINED ;
uint16 invSlot = 0xffff ;
if ( strnicmp ( invPath . c_str ( ) , " LOCAL:INVENTORY:HAND " , 20 ) = = 0 )
{
inventory = INVENTORIES : : handling ;
fromString ( invPath . substr ( 21 , invPath . size ( ) ) , invSlot ) ;
}
else if ( strnicmp ( invPath . c_str ( ) , " LOCAL:INVENTORY:EQUIP " , 21 ) = = 0 )
{
inventory = INVENTORIES : : equipment ;
fromString ( invPath . substr ( 22 , invPath . size ( ) ) , invSlot ) ;
}
// Hands management : check if we have to unequip left hand because of incompatibility with right hand item
if ( inventory = = INVENTORIES : : handling & & invSlot = = 0 )
{
2012-05-31 02:27:27 +00:00
CDBCtrlSheet * pCSLeftHand = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_HAND_LEFT ) ) ;
2010-05-06 00:08:41 +00:00
if ( pCSLeftHand = = NULL )
{
return ;
}
// get sheet of left item
uint32 leftSheet = 0 ;
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :HAND:1:INDEX_IN_BAG " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL = = NULL )
{
return ;
}
if ( pNL - > getValue32 ( ) > 0 )
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL2 = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :BAG: " + toString ( pNL - > getValue32 ( ) - 1 ) + " :SHEET " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL2 = = NULL )
{
return ;
}
leftSheet = pNL2 - > getValue32 ( ) ;
}
// get sheet of previous right hand item
uint32 lastRightSheet = 0 ;
if ( oldIndexInBag > 0 )
{
2012-05-24 03:02:24 +00:00
pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :BAG: " + toString ( oldIndexInBag - 1 ) + " :SHEET " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL = = NULL )
{
return ;
}
lastRightSheet = pNL - > getValue32 ( ) ;
}
// sheet of new right hand item
uint32 rightSheet = 0 ;
// If incompatible -> remove
if ( ! getInventory ( ) . isLeftHandItemCompatibleWithRightHandItem ( leftSheet , rightSheet , lastRightSheet ) )
{
getInventory ( ) . unequip ( LOCAL_INVENTORY " :HAND:1 " ) ;
}
}
2012-05-24 03:02:24 +00:00
NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( invPath + " :INDEX_IN_BAG " ) - > setValue16 ( 0 ) ;
2010-05-06 00:08:41 +00:00
// Update trade window if any
if ( ( BotChatPageAll ! = NULL ) & & ( BotChatPageAll - > Trade ! = NULL ) )
BotChatPageAll - > Trade - > invalidateCoords ( ) ;
// Send message to the server
if ( inventory ! = INVENTORIES : : UNDEFINED )
{
CBitMemStream out ;
const string sMsg = " ITEM:UNEQUIP " ;
if ( GenericMsgHeaderMngr . pushNameToStream ( sMsg , out ) )
{
// Fill the message (equiped inventory, equiped inventory slot)
out . serial ( inventory ) ;
out . serial ( invSlot ) ;
NetMngr . push ( out ) ;
pIM - > incLocalSyncActionCounter ( ) ;
//nlinfo("impulseCallBack : %s %d %d sent", sMsg.c_str(), inventory, invSlot);
}
else
{
nlwarning ( " don't know message name %s " , sMsg . c_str ( ) ) ;
}
}
}
// ***************************************************************************
// Observer on DB equipment branch
// ***************************************************************************
void CInventoryManager : : CDBEquipObs : : update ( ICDBNode * node )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
string sTmp = node - > getFullName ( ) ;
string sIE , sIE2 ; // Interface Element
CCDBNodeLeaf * pNL = dynamic_cast < CCDBNodeLeaf * > ( node ) ;
if ( pNL = = NULL ) return ;
if ( strnicmp ( sTmp . c_str ( ) , " LOCAL:INVENTORY:HAND " , 20 ) = = 0 )
{
// Coming from hand
sTmp = sTmp . substr ( 21 , sTmp . size ( ) ) ;
sTmp = sTmp . substr ( 0 , sTmp . rfind ( ' : ' ) ) ;
sint index ;
fromString ( sTmp , index ) ;
if ( index = = 0 )
sIE = CTRL_HAND_RIGHT ;
else
sIE = CTRL_HAND_LEFT ;
// update Hands.
getInventory ( ) . Hands [ index ] = pNL - > getValue16 ( ) ;
}
else if ( strnicmp ( sTmp . c_str ( ) , " LOCAL:INVENTORY:EQUIP " , 21 ) = = 0 )
{
// Coming from equipement
sTmp = sTmp . substr ( 22 , sTmp . size ( ) ) ;
sTmp = sTmp . substr ( 0 , sTmp . rfind ( ' : ' ) ) ;
sint32 nTmp ;
fromString ( sTmp , nTmp ) ;
SLOT_EQUIPMENT : : TSlotEquipment index = ( SLOT_EQUIPMENT : : TSlotEquipment ) nTmp ;
switch ( index )
{
case SLOT_EQUIPMENT : : HEADDRESS : sIE = CTRL_JEWEL_HEADDRESS ;
sIE2 = CTRL_JEWL2_HEADDRESS ; break ;
case SLOT_EQUIPMENT : : EARL : sIE = CTRL_JEWEL_EARING_LEFT ;
sIE2 = CTRL_JEWL2_EARING_LEFT ; break ;
case SLOT_EQUIPMENT : : EARR : sIE = CTRL_JEWEL_EARING_RIGHT ;
sIE2 = CTRL_JEWL2_EARING_RIGHT ; break ;
case SLOT_EQUIPMENT : : NECKLACE : sIE = CTRL_JEWEL_NECK ;
sIE2 = CTRL_JEWL2_NECK ; break ;
case SLOT_EQUIPMENT : : WRISTL : sIE = CTRL_JEWEL_BRACELET_LEFT ;
sIE2 = CTRL_JEWL2_BRACELET_LEFT ; break ;
case SLOT_EQUIPMENT : : WRISTR : sIE = CTRL_JEWEL_BRACELET_RIGHT ;
sIE2 = CTRL_JEWL2_BRACELET_RIGHT ; break ;
case SLOT_EQUIPMENT : : FINGERL : sIE = CTRL_JEWEL_RING_LEFT ;
sIE2 = CTRL_JEWL2_RING_LEFT ; break ;
case SLOT_EQUIPMENT : : FINGERR : sIE = CTRL_JEWEL_RING_RIGHT ;
sIE2 = CTRL_JEWL2_RING_RIGHT ; break ;
case SLOT_EQUIPMENT : : ANKLEL : sIE = CTRL_JEWEL_ANKLET_LEFT ;
sIE2 = CTRL_JEWL2_ANKLET_LEFT ; break ;
case SLOT_EQUIPMENT : : ANKLER : sIE = CTRL_JEWEL_ANKLET_RIGHT ;
sIE2 = CTRL_JEWL2_ANKLET_RIGHT ; break ;
case SLOT_EQUIPMENT : : HEAD : sIE = CTRL_ARMOR_HEAD ;
sIE2 = CTRL_ARMR2_HEAD ; break ;
case SLOT_EQUIPMENT : : CHEST : sIE = CTRL_ARMOR_CHEST ;
sIE2 = CTRL_ARMR2_CHEST ; break ;
case SLOT_EQUIPMENT : : ARMS : sIE = CTRL_ARMOR_ARMS ;
sIE2 = CTRL_ARMR2_ARMS ; break ;
case SLOT_EQUIPMENT : : FEET : sIE = CTRL_ARMOR_FEET ;
sIE2 = CTRL_ARMR2_FEET ; break ;
case SLOT_EQUIPMENT : : LEGS : sIE = CTRL_ARMOR_LEGS ;
sIE2 = CTRL_ARMR2_LEGS ; break ;
case SLOT_EQUIPMENT : : HANDS : sIE = CTRL_ARMOR_HANDS ;
sIE2 = CTRL_ARMR2_HANDS ; break ;
default :
nlwarning ( " entry not handled " ) ;
return ;
break ;
}
// update Equips.
getInventory ( ) . Equip [ index ] = pNL - > getValue16 ( ) ;
}
else return ;
// Set database for wearing the right item
2012-05-31 02:27:27 +00:00
CDBCtrlSheet * pCS = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( sIE ) ) ;
CDBCtrlSheet * pCS2 = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( sIE2 ) ) ;
2010-05-06 00:08:41 +00:00
// Remove Last reference and update database
sint16 oldVal = pNL - > getOldValue16 ( ) ;
sint16 newVal = pNL - > getValue16 ( ) ;
if ( oldVal ! = 0 )
getInventory ( ) . unwearBagItem ( oldVal - 1 ) ;
if ( newVal ! = 0 )
getInventory ( ) . wearBagItem ( newVal - 1 ) ;
// Update Display
if ( newVal = = 0 )
{
// in some case left sheet is same than right sheet so don't clear it now (ex: 2 hands item, right hand exclusive)
if ( sIE ! = CTRL_HAND_LEFT )
{
if ( pCS ! = NULL ) pCS - > setSheet ( " " ) ;
if ( pCS2 ! = NULL ) pCS2 - > setSheet ( " " ) ;
}
}
else
{
if ( pCS ! = NULL ) pCS - > setSheet ( LOCAL_INVENTORY " :BAG: " + toString ( newVal - 1 ) ) ;
if ( pCS2 ! = NULL ) pCS2 - > setSheet ( LOCAL_INVENTORY " :BAG: " + toString ( newVal - 1 ) ) ;
}
// Hands management
if ( sIE = = CTRL_HAND_RIGHT )
{
// if nothing in left hand -> return
2012-05-31 02:27:27 +00:00
CDBCtrlSheet * pCSLeftHand = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_HAND_LEFT ) ) ;
2010-05-06 00:08:41 +00:00
if ( pCSLeftHand = = NULL )
{
return ;
}
// reset display of left hand
2012-06-01 01:41:44 +00:00
CViewRenderer & rVR = * CViewRenderer : : getInstance ( ) ;
2010-05-06 00:08:41 +00:00
pCSLeftHand - > setTextureNoItem ( rVR . getTextureIdFromName ( " hand_left.tga " ) ) ;
pCSLeftHand - > setGrayed ( false ) ;
pCSLeftHand - > setItemSlot ( SLOTTYPE : : stringToSlotType ( " LEFT_HAND " ) ) ;
pCSLeftHand - > setActionOnLeftClick ( " proc " ) ;
// If something in left hand check if we have to remove
{
uint32 leftSheet = 0 ;
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL3 = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :HAND:1:INDEX_IN_BAG " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL3 = = NULL ) return ;
if ( pNL3 - > getValue32 ( ) > 0 )
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL4 = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :BAG: " + toString ( pNL3 - > getValue32 ( ) - 1 ) + " :SHEET " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL4 = = NULL ) return ;
leftSheet = pNL4 - > getValue32 ( ) ;
}
uint32 rightSheet = 0 ;
if ( newVal > 0 )
{
2012-05-24 03:02:24 +00:00
pNL3 = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :BAG: " + toString ( newVal - 1 ) + " :SHEET " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL3 = = NULL ) return ;
rightSheet = pNL3 - > getValue32 ( ) ;
}
uint32 lastRightSheet = 0 ;
if ( oldVal > 0 )
{
2012-05-24 03:02:24 +00:00
pNL3 = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :BAG: " + toString ( oldVal - 1 ) + " :SHEET " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL3 = = NULL ) return ;
lastRightSheet = pNL3 - > getValue32 ( ) ;
}
// If incompatible -> remove
if ( ! getInventory ( ) . isLeftHandItemCompatibleWithRightHandItem ( leftSheet , rightSheet , lastRightSheet ) )
{
pCSLeftHand - > setSheet ( " " ) ;
}
// WORKAROUND: useful when an item is destroyed before it is unequipped (clean the left hand)
if ( ( leftSheet = = 0 ) & & ( rightSheet = = 0 ) )
{
pCSLeftHand - > setSheet ( " " ) ;
}
}
// update display of left hand according to new right hand item
if ( newVal > 0 )
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL2 = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :BAG: " + toString ( newVal - 1 ) + " :SHEET " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL2 = = NULL ) return ;
if ( getInventory ( ) . is2HandItem ( pNL2 - > getValue32 ( ) ) )
{
if ( getInventory ( ) . isRangeWeaponItem ( pNL2 - > getValue32 ( ) ) )
{
pCSLeftHand - > setItemSlot ( SLOTTYPE : : stringToSlotType ( " AMMO " ) ) ;
pCSLeftHand - > setTextureNoItem ( rVR . getTextureIdFromName ( " W_AM_logo.tga " ) ) ;
}
else
{
pCSLeftHand - > setSheet ( LOCAL_INVENTORY " :BAG: " + toString ( newVal - 1 ) ) ;
pCSLeftHand - > setGrayed ( true ) ;
pCSLeftHand - > setActionOnLeftClick ( " " ) ;
}
}
}
}
// left hand item is changing
if ( sIE = = CTRL_HAND_LEFT )
{
2012-05-31 02:27:27 +00:00
CDBCtrlSheet * pCSLeftHand = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_HAND_LEFT ) ) ;
2010-05-06 00:08:41 +00:00
if ( pCSLeftHand )
{
2012-06-01 01:41:44 +00:00
CViewRenderer & rVR = * CViewRenderer : : getInstance ( ) ;
2010-05-06 00:08:41 +00:00
pCSLeftHand - > setActionOnLeftClick ( " proc " ) ;
pCSLeftHand - > setGrayed ( false ) ;
// if now there is nothing in left hand
if ( newVal = = 0 )
{
// check if we clear display (have to manage 2 hands weapons for instance)
bool clearLeftHandDisplay = true ;
2012-05-31 02:27:27 +00:00
CDBCtrlSheet * pCSRightHand = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( CTRL_HAND_RIGHT ) ) ;
2010-05-06 00:08:41 +00:00
if ( pCSRightHand & & pCSRightHand - > getSheetId ( ) )
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL3 = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :HAND:0:INDEX_IN_BAG " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL3 )
{
if ( pNL3 - > getValue32 ( ) > 0 )
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL4 = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :BAG: " + toString ( pNL3 - > getValue32 ( ) - 1 ) + " :SHEET " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL4 )
{
uint32 rightSheet = pNL4 - > getValue32 ( ) ;
if ( getInventory ( ) . is2HandItem ( rightSheet ) )
{
if ( getInventory ( ) . isRangeWeaponItem ( rightSheet ) )
{
pCSLeftHand - > setItemSlot ( SLOTTYPE : : stringToSlotType ( " AMMO " ) ) ;
pCSLeftHand - > setTextureNoItem ( rVR . getTextureIdFromName ( " W_AM_logo.tga " ) ) ;
}
else
{
pCSLeftHand - > setItemSlot ( SLOTTYPE : : stringToSlotType ( " LEFT_HAND " ) ) ;
pCSLeftHand - > setTextureNoItem ( rVR . getTextureIdFromName ( " hand_left.tga " ) ) ;
clearLeftHandDisplay = false ;
}
}
}
}
}
}
if ( clearLeftHandDisplay )
{
if ( pCS ! = NULL ) pCS - > setSheet ( " " ) ;
if ( pCS2 ! = NULL ) pCS2 - > setSheet ( " " ) ;
}
}
}
}
}
// ***************************************************************************
void CInventoryManager : : CDBBagObs : : update ( ICDBNode * /* node */ )
{
if ( IngameDbMngr . initInProgress ( ) ) return ;
getInventory ( ) . checkIndexInBagIntegrity ( ) ;
// AUTO EQUIP the player with incoming item if we can put this item in an equipment slot
// if we are not initializing the DB
/*
CCDBNodeLeaf * pNL = dynamic_cast < CCDBNodeLeaf * > ( node ) ;
if ( pNL ! = NULL )
if ( pNL - > getValue32 ( ) = = 0 )
return ;
if ( IngameDbMngr . initInProgress ( ) ) return ;
sint bagEntryIndex ;
string path = node - > getFullName ( ) ;
path = path . substr ( 0 , path . rfind ( ' : ' ) ) ;
path = path . substr ( path . rfind ( ' : ' ) + 1 , path . size ( ) ) ;
fromString ( path , bagEntryIndex ) ;
// equip only if slot empty
getInventory ( ) . autoEquip ( bagEntryIndex , false ) ;
*/
}
// ***************************************************************************
bool CInventoryManager : : autoEquip ( sint bagEntryIndex , bool allowReplace )
{
uint i ;
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
2012-05-31 02:27:27 +00:00
IListSheetBase * pList = dynamic_cast < IListSheetBase * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( LIST_BAG_TEXT ) ) ;
2010-05-06 00:08:41 +00:00
CDBCtrlSheet * pCSSrc = NULL ;
if ( pList = = NULL ) return false ;
for ( i = 0 ; i < MAX_BAGINV_ENTRIES ; + + i )
{
pCSSrc = pList - > getSheet ( i ) ;
string sTmp = pCSSrc - > getSheet ( ) ;
sTmp = sTmp . substr ( sTmp . rfind ( ' : ' ) + 1 , sTmp . size ( ) ) ;
sint nTmp ;
fromString ( sTmp , nTmp ) ;
if ( nTmp = = bagEntryIndex )
break ;
}
if ( i = = MAX_BAGINV_ENTRIES ) return false ;
if ( pCSSrc = = NULL ) return false ;
for ( i = 0 ; i < MAX_HANDINV_ENTRIES ; + + i )
{
CDBCtrlSheet * pCSDst = getInventory ( ) . getHandSheet ( i ) ;
if ( pCSDst = = NULL ) continue ;
string dstPath = getInventory ( ) . getDBIndexPath ( pCSDst ) ;
2012-05-24 03:02:24 +00:00
sint32 indexDstPath = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( dstPath + " :INDEX_IN_BAG " ) - > getValue16 ( ) ;
2010-05-06 00:08:41 +00:00
// Already something in that slot?
if ( ! allowReplace & & indexDstPath > 0 )
continue ;
// Does the source and destination are items ?
if ( pCSSrc - > getType ( ) = = CCtrlSheetInfo : : SheetType_Item )
if ( pCSDst - > getType ( ) = = CCtrlSheetInfo : : SheetType_Item )
{
// Right Slot ?
if ( pCSDst - > canDropItem ( pCSSrc ) )
{
// Ok let us equip with this item
string srcPath = pCSSrc - > getSheet ( ) ;
getInventory ( ) . equip ( srcPath , dstPath ) ;
return true ;
}
}
}
for ( i = 0 ; i < MAX_EQUIPINV_ENTRIES ; + + i )
{
CDBCtrlSheet * pCSDst = getInventory ( ) . getEquipSheet ( i ) ;
if ( pCSDst = = NULL ) continue ;
string dstPath = getInventory ( ) . getDBIndexPath ( pCSDst ) ;
2012-05-24 03:02:24 +00:00
sint32 indexDstPath = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( dstPath + " :INDEX_IN_BAG " ) - > getValue16 ( ) ;
2010-05-06 00:08:41 +00:00
// Already something in that slot?
if ( ! allowReplace & & indexDstPath > 0 )
continue ;
// Does the source and destination are items ?
if ( pCSSrc - > getType ( ) = = CCtrlSheetInfo : : SheetType_Item )
if ( pCSDst - > getType ( ) = = CCtrlSheetInfo : : SheetType_Item )
{
// Right Slot ?
if ( pCSDst - > canDropItem ( pCSSrc ) )
{
// Ok let us equip with this item
string srcPath = pCSSrc - > getSheet ( ) ;
getInventory ( ) . equip ( srcPath , dstPath ) ;
return true ;
}
}
}
return false ;
}
// ***************************************************************************
void CInventoryManager : : dropOrDestroyItem ( CDBCtrlSheet * item , CBitMemStream & out , uint16 quantity )
{
if ( ! item ) return ;
uint16 inventory = ( uint16 ) item - > getInventoryIndex ( ) ;
// retrieve inventory & slot
uint16 slot = ( uint16 ) item - > getIndexInDB ( ) ;
out . serial ( inventory ) ;
out . serial ( slot ) ;
out . serial ( quantity ) ;
NetMngr . push ( out ) ;
}
// ***************************************************************************
static void checkEquipmentIntegrity ( const string & equipVal )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( equipVal + " :INDEX_IN_BAG " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL ! = NULL )
{
uint32 indexInBag = pNL - > getValue16 ( ) ;
if ( indexInBag ! = 0 )
{
string sTmp = string ( LOCAL_INVENTORY ) + " :BAG: " + toString ( indexInBag - 1 ) + " :SHEET " ;
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNLBag = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( sTmp , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNLBag ! = NULL )
{
if ( pNLBag - > getValue32 ( ) = = 0 ) // If no more item in this slot bag
{
// if (! IngameDbMngr.initInProgress()) // Commented because init is end when we received equipment
// pNL->setValue16(0); // Reset INDEX_IN_BAG
}
else
{
// If the slot was previously empty check that there is no reference on it
// else update the reference
if ( pNLBag - > getOldValue32 ( ) = = 0 )
{
for ( uint32 i = 0 ; i < MAX_EQUIPINV_ENTRIES ; + + i )
{
CDBCtrlSheet * pCSDst = getInventory ( ) . getEquipSheet ( i ) ;
if ( pCSDst = = NULL ) continue ;
string dstPath = getInventory ( ) . getDBIndexPath ( pCSDst ) ;
2012-05-24 03:02:24 +00:00
sint32 indexDstPath = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( dstPath + " :INDEX_IN_BAG " ) - > getValue16 ( ) ;
2010-05-06 00:08:41 +00:00
// Update the sheet id of the control sheet
if ( indexDstPath = = ( sint32 ) indexInBag )
{
pCSDst - > setSheetId ( pNLBag - > getValue32 ( ) ) ;
}
}
}
}
}
}
}
}
// ***************************************************************************
void CInventoryManager : : checkIndexInBagIntegrity ( )
{
string sTmp ;
uint32 i ;
for ( i = 0 ; i < MAX_HANDINV_ENTRIES ; + + i )
{
sTmp = string ( LOCAL_INVENTORY ) + " :HAND: " + toString ( i ) ;
checkEquipmentIntegrity ( sTmp ) ;
}
for ( i = 0 ; i < MAX_EQUIPINV_ENTRIES ; + + i )
{
sTmp = string ( LOCAL_INVENTORY ) + " :EQUIP: " + toString ( i ) ;
checkEquipmentIntegrity ( sTmp ) ;
}
}
// ***************************************************************************
double CInventoryManager : : getBranchBulk ( const string & basePath , uint16 startItemIndex , uint16 numItems )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
2012-05-24 03:02:24 +00:00
CCDBNodeBranch * branch = NLGUI : : CDBManager : : getInstance ( ) - > getDbBranch ( basePath ) ;
2010-05-06 00:08:41 +00:00
if ( ! branch )
{
nlwarning ( " <getBranchBulk> Branch is NULL " ) ;
return 0 ;
}
double totalBulk = 0 ;
//
uint16 lastIndexItem = std : : min ( ( uint16 ) ( startItemIndex + numItems ) , ( uint16 ) branch - > getNbNodes ( ) ) ;
for ( uint16 currItem = startItemIndex ; currItem < lastIndexItem ; + + currItem )
{
ICDBNode * node = branch - > getNode ( currItem ) ;
if ( node )
{
CCDBNodeLeaf * sheetNode = dynamic_cast < CCDBNodeLeaf * > ( node - > getNode ( ICDBNode : : CTextId ( " SHEET " ) ) ) ;
CCDBNodeLeaf * quantityNode = dynamic_cast < CCDBNodeLeaf * > ( node - > getNode ( ICDBNode : : CTextId ( " QUANTITY " ) ) ) ;
if ( sheetNode & & quantityNode )
{
// get the Sheet
CSheetId sheetId = CSheetId ( sheetNode - > getValue32 ( ) ) ;
if ( sheetId ! = CSheetId : : Unknown )
{
CItemSheet * itemSheet = dynamic_cast < CItemSheet * > ( SheetMngr . get ( sheetId ) ) ;
if ( itemSheet )
{
totalBulk + = std : : max ( ( sint32 ) 1 , quantityNode - > getValue32 ( ) ) * itemSheet - > Bulk ;
}
}
}
}
}
return totalBulk ;
}
/*
* Get the number of used and max slots
*/
void CInventoryManager : : getBranchSlotCounts ( const std : : string & basePath , uint & nbUsedSlots , uint & nbMaxSlots )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
2012-05-24 03:02:24 +00:00
CCDBNodeBranch * branch = NLGUI : : CDBManager : : getInstance ( ) - > getDbBranch ( basePath ) ;
2010-05-06 00:08:41 +00:00
if ( ! branch )
{
nlwarning ( " <getBranchSlotCounts> Branch is NULL " ) ;
return ;
}
nbMaxSlots = 0 ; // different from nbNodes, because there can be non-slots leaves (e.g. guild money...)
nbUsedSlots = 0 ;
uint nbNodes = branch - > getNbNodes ( ) ;
for ( uint i = 0 ; i ! = nbNodes ; + + i )
{
ICDBNode * node = branch - > getNode ( i ) ;
if ( node )
{
CCDBNodeLeaf * sheetNode = dynamic_cast < CCDBNodeLeaf * > ( node - > getNode ( ICDBNode : : CTextId ( " SHEET " ) ) ) ;
if ( sheetNode )
{
// Get the Sheet
CSheetId sheetId = CSheetId ( sheetNode - > getValue32 ( ) ) ;
if ( sheetId ! = CSheetId : : Unknown )
{
+ + nbUsedSlots ;
}
+ + nbMaxSlots ;
}
}
}
}
// ***************************************************************************
double CInventoryManager : : getBagBulk ( uint32 inventoryIndex )
{
nlctassert ( MAX_INVENTORY_ANIMAL = = 4 ) ;
if ( inventoryIndex = = 0 )
return getBranchBulk ( LOCAL_INVENTORY " :BAG " , 0 , MAX_BAGINV_ENTRIES ) ;
else if ( inventoryIndex = = 1 )
return getBranchBulk ( LOCAL_INVENTORY " :PACK_ANIMAL0 " , 0 , MAX_ANIMALINV_ENTRIES ) ;
else if ( inventoryIndex = = 2 )
return getBranchBulk ( LOCAL_INVENTORY " :PACK_ANIMAL1 " , 0 , MAX_ANIMALINV_ENTRIES ) ;
else if ( inventoryIndex = = 3 )
return getBranchBulk ( LOCAL_INVENTORY " :PACK_ANIMAL2 " , 0 , MAX_ANIMALINV_ENTRIES ) ;
else if ( inventoryIndex = = 4 )
return getBranchBulk ( LOCAL_INVENTORY " :PACK_ANIMAL3 " , 0 , MAX_ANIMALINV_ENTRIES ) ;
else if ( inventoryIndex = = 5 )
return 0 ;
else if ( inventoryIndex = = 6 )
return 0 ;
else if ( inventoryIndex = = 7 )
return getBranchBulk ( LOCAL_INVENTORY " :TEMP " , 0 , MAX_TEMPINV_ENTRIES ) ;
return 0 ;
}
// ***************************************************************************
double CInventoryManager : : getItemBulk ( uint32 sheetID )
{
CItemSheet * itemSheet = dynamic_cast < CItemSheet * > ( SheetMngr . get ( CSheetId ( sheetID ) ) ) ;
if ( itemSheet )
return itemSheet - > Bulk ;
return 0 ;
}
// ***************************************************************************
double CInventoryManager : : getMaxBagBulk ( uint32 inventoryIndex )
{
nlctassert ( MAX_INVENTORY_ANIMAL = = 4 ) ;
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
CCDBNodeLeaf * pNL = NULL ;
if ( inventoryIndex = = 0 )
2012-05-24 03:02:24 +00:00
pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " SERVER:STATIC_DATA:BAG_BULK_MAX " ) ;
2010-05-06 00:08:41 +00:00
else if ( inventoryIndex = = 1 )
2012-05-24 03:02:24 +00:00
pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " SERVER:PACK_ANIMAL:BEAST0:BULK_MAX " ) ;
2010-05-06 00:08:41 +00:00
else if ( inventoryIndex = = 2 )
2012-05-24 03:02:24 +00:00
pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " SERVER:PACK_ANIMAL:BEAST1:BULK_MAX " ) ;
2010-05-06 00:08:41 +00:00
else if ( inventoryIndex = = 3 )
2012-05-24 03:02:24 +00:00
pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " SERVER:PACK_ANIMAL:BEAST2:BULK_MAX " ) ;
2010-05-06 00:08:41 +00:00
else if ( inventoryIndex = = 4 )
2012-05-24 03:02:24 +00:00
pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " SERVER:PACK_ANIMAL:BEAST3:BULK_MAX " ) ;
2010-05-06 00:08:41 +00:00
if ( pNL ! = NULL )
return pNL - > getValue32 ( ) ;
return 0 ;
}
// ***************************************************************************
bool CInventoryManager : : isSpaceInAllBagsForItem ( CDBCtrlSheet * item )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
CDBCtrlSheet * pCSDst = item ;
if ( ! pCSDst - > isSheetValid ( ) ) return false ;
string sTmp = pCSDst - > getSheet ( ) ;
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( sTmp + " :SHEET " , false ) ;
CCDBNodeLeaf * pNLquantity = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( sTmp + " :QUANTITY " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL = = NULL ) return false ;
if ( pNLquantity = = NULL ) return false ;
// Check if we can find empty space for this item (or stack of item)
// in all of the bags that the player owe.
CInventoryManager * pInv = CInventoryManager : : getInstance ( ) ;
uint32 quantity = pNLquantity - > getValue32 ( ) ;
double totalBulk = quantity * pInv - > getItemBulk ( pNL - > getValue32 ( ) ) ;
// bool bPlaceFound = false;
for ( uint32 i = 0 ; i < 7 ; + + i )
{
if ( pInv - > isInventoryAvailable ( ( INVENTORIES : : TInventory ) CInventoryManager : : InventoryIndexes [ i ] ) )
if ( ( pInv - > getBagBulk ( i ) + totalBulk ) < = pInv - > getMaxBagBulk ( i ) )
return true ;
}
return false ;
}
// ***************************************************************************
bool CInventoryManager : : isSpaceInBagForItem ( CDBCtrlSheet * item , uint32 quantity , uint32 bagId )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
CDBCtrlSheet * pCSDst = item ;
if ( ! pCSDst - > isSheetValid ( ) ) return false ;
string sTmp = pCSDst - > getSheet ( ) ;
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( sTmp + " :SHEET " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL = = NULL ) return false ;
// Check if we can find empty space for this item (or stack of item)
// in a given bag that the player owe.
CInventoryManager * pInv = CInventoryManager : : getInstance ( ) ;
double totalBulk = quantity * pInv - > getItemBulk ( pNL - > getValue32 ( ) ) ;
if ( pInv - > isInventoryAvailable ( ( INVENTORIES : : TInventory ) CInventoryManager : : InventoryIndexes [ bagId ] ) )
if ( ( pInv - > getBagBulk ( bagId ) + totalBulk ) < = pInv - > getMaxBagBulk ( bagId ) )
return true ;
return false ;
}
// ***************************************************************************
// CTempInvManager
// ***************************************************************************
// Observers on DB
// ***************************************************************************
void CTempInvManager : : CDBObs : : update ( ICDBNode * /* node */ )
{
CTempInvManager : : getInstance ( ) - > update ( ) ;
}
void CTempInvManager : : CDBObsType : : update ( ICDBNode * /* node */ )
{
CTempInvManager : : getInstance ( ) - > updateType ( ) ;
}
void CTempInvManager : : CDBForageQQObs : : update ( ICDBNode * /* node */ )
{
CTempInvManager : : getInstance ( ) - > updateForageQQ ( WhichOne ) ;
}
// ***************************************************************************
CTempInvManager : : CTempInvManager ( )
{
_Mode = TEMP_INV_MODE : : Unknown ;
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
string sPath = string ( " LOCAL:INVENTORY:TEMP " ) ;
for ( uint i = 0 ; i < MAX_TEMPINV_ENTRIES ; + + i )
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( sPath + " : " + toString ( i ) + " :SHEET " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL ! = NULL )
{
ICDBNode : : CTextId textId ;
pNL - > addObserver ( & _DBObs , textId ) ;
}
}
// Add Also the Mode to observe
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( sPath + " :TYPE " , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL )
{
ICDBNode : : CTextId textId ;
pNL - > addObserver ( & _DBObsType , textId ) ;
}
// Forage
2012-05-24 03:02:24 +00:00
pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( sPath + " :ENABLE_TAKE " ) ;
2010-05-06 00:08:41 +00:00
if ( pNL ! = NULL )
{
ICDBNode : : CTextId textId ;
pNL - > addObserver ( & _DBObs , textId ) ;
}
2012-05-24 03:02:24 +00:00
pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( sPath + " :0:QUANTITY " ) ;
2010-05-06 00:08:41 +00:00
_DBForageQQObs [ 0 ] . WhichOne = 0 ;
if ( pNL ! = NULL )
{
ICDBNode : : CTextId textId ;
pNL - > addObserver ( & _DBForageQQObs [ 0 ] , textId ) ;
}
2012-05-24 03:02:24 +00:00
pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( sPath + " :0:QUALITY " ) ;
2010-05-06 00:08:41 +00:00
_DBForageQQObs [ 1 ] . WhichOne = 1 ;
if ( pNL ! = NULL )
{
ICDBNode : : CTextId textId ;
pNL - > addObserver ( & _DBForageQQObs [ 1 ] , textId ) ;
}
}
// ***************************************************************************
CTempInvManager : : ~ CTempInvManager ( )
{
}
// ***************************************************************************
void CTempInvManager : : releaseInstance ( )
{
if ( _Instance )
delete _Instance ;
_Instance = NULL ;
}
// ***************************************************************************
void CTempInvManager : : update ( )
{
bool bAllEmpty = true ;
// Check the database state
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
string sPath = string ( " LOCAL:INVENTORY:TEMP " ) ;
for ( uint i = 0 ; i < MAX_TEMPINV_ENTRIES ; i + + )
{
string sTmp = sPath + " : " + toString ( i ) + " :SHEET " ;
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( sTmp ) ;
2010-05-06 00:08:41 +00:00
// uint32 nOldSheet = pNL->getOldValue32();
uint32 nSheet = pNL - > getValue32 ( ) ;
if ( nSheet ! = 0 )
bAllEmpty = false ;
}
2012-05-24 03:02:24 +00:00
_Mode = ( TEMP_INV_MODE : : TInventoryMode ) NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " LOCAL:INVENTORY:TEMP:TYPE " ) - > getValue8 ( ) ;
2010-05-06 00:08:41 +00:00
2012-05-31 02:27:27 +00:00
CGroupContainer * pGC = dynamic_cast < CGroupContainer * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( WIN_TEMPINV ) ) ;
2010-05-06 00:08:41 +00:00
if ( pGC = = NULL )
return ;
// show/hide weight info depending on temp inventory mode
bool displayWeight = ( _Mode = = TEMP_INV_MODE : : Craft ) ;
CViewBase * weightText = dynamic_cast < CViewBase * > ( pGC - > getView ( " weight_txt " ) ) ;
if ( weightText ! = NULL )
weightText - > setActive ( displayWeight ) ;
CViewBase * weightImg = dynamic_cast < CViewBase * > ( pGC - > getView ( " weight " ) ) ;
if ( weightImg ! = NULL )
weightImg - > setActive ( displayWeight ) ;
if ( _Mode = = TEMP_INV_MODE : : Forage )
{
// Disable/enable "Take all" button
2012-05-24 03:02:24 +00:00
bool disableTake = ( NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( sPath + " :ENABLE_TAKE " ) - > getValue32 ( ) = = 0 ) ;
NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " UI:TEMP_INV:ALL_EMPTY " ) - > setValue32 ( disableTake ) ;
2010-05-06 00:08:41 +00:00
if ( disableTake )
{
// Display begin of forage
pGC - > setTitle ( WIN_TEMPINV_TITLE_WAIT_FORAGING ) ;
_DBForageQQObs [ 0 ] . FullValue = 0.0f ;
_DBForageQQObs [ 1 ] . FullValue = 0.0f ;
}
else
{
// Display forage result
pGC - > setTitle ( WIN_TEMPINV_TITLE_FORAGE_RESULT ) ;
}
}
else
{
// Write to the UI db the empty state
2012-05-24 03:02:24 +00:00
NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " UI:TEMP_INV:ALL_EMPTY " ) - > setValue32 ( bAllEmpty ) ;
2010-05-06 00:08:41 +00:00
}
if ( bAllEmpty )
{
// If all slots are empty, close the interface
pGC - > setActive ( false ) ;
2012-05-31 23:22:05 +00:00
CAHManager : : getInstance ( ) - > runActionHandler ( " phrase_update_all_memory_ctrl_regen_tick_range " , NULL ) ;
2010-05-06 00:08:41 +00:00
}
else
{
pGC - > setActive ( true ) ;
2012-05-31 23:22:05 +00:00
CAHManager : : getInstance ( ) - > runActionHandler ( " phrase_update_all_memory_ctrl_regen_tick_range " , NULL ) ;
2010-05-06 00:08:41 +00:00
// Something arrived, change text
switch ( _Mode )
{
case TEMP_INV_MODE : : Loot : pGC - > setTitle ( WIN_TEMPINV_TITLE_LOOT ) ; break ;
case TEMP_INV_MODE : : Quarter : pGC - > setTitle ( WIN_TEMPINV_TITLE_QUARTERING ) ; break ;
case TEMP_INV_MODE : : Forage : /* see above */ break ;
case TEMP_INV_MODE : : BagFull : pGC - > setTitle ( WIN_TEMPINV_TITLE_BAGFULL ) ; break ;
case TEMP_INV_MODE : : Craft : pGC - > setTitle ( WIN_TEMPINV_TITLE_CRAFT ) ; break ;
case TEMP_INV_MODE : : MissionReward : pGC - > setTitle ( WIN_TEMPINV_TITLE_MISSIONREWARD ) ; break ;
case TEMP_INV_MODE : : Crystallize : pGC - > setTitle ( WIN_TEMPINV_TITLE_CRYSTALLIZE ) ; break ;
case TEMP_INV_MODE : : Unknown :
default : pGC - > setTitle ( WIN_TEMPINV_TITLE_ERROR ) ; break ;
}
}
}
// ***************************************************************************
void CTempInvManager : : updateType ( )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
2012-05-24 03:02:24 +00:00
_Mode = ( TEMP_INV_MODE : : TInventoryMode ) NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " LOCAL:INVENTORY:TEMP:TYPE " ) - > getValue8 ( ) ;
2012-05-31 02:27:27 +00:00
CGroupContainer * pGC = dynamic_cast < CGroupContainer * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( WIN_TEMPINV ) ) ;
2010-05-06 00:08:41 +00:00
// Something arrived, change text
switch ( _Mode )
{
case TEMP_INV_MODE : : Loot : pGC - > setTitle ( WIN_TEMPINV_TITLE_LOOT ) ; break ;
case TEMP_INV_MODE : : Quarter : pGC - > setTitle ( WIN_TEMPINV_TITLE_QUARTERING ) ; break ;
case TEMP_INV_MODE : : Forage : /* see above */ break ;
case TEMP_INV_MODE : : BagFull : pGC - > setTitle ( WIN_TEMPINV_TITLE_BAGFULL ) ; break ;
case TEMP_INV_MODE : : Craft : pGC - > setTitle ( WIN_TEMPINV_TITLE_CRAFT ) ; break ;
case TEMP_INV_MODE : : MissionReward : pGC - > setTitle ( WIN_TEMPINV_TITLE_MISSIONREWARD ) ; break ;
case TEMP_INV_MODE : : Crystallize : pGC - > setTitle ( WIN_TEMPINV_TITLE_CRYSTALLIZE ) ; break ;
case TEMP_INV_MODE : : Unknown :
default : /*pGC->setTitle(WIN_TEMPINV_TITLE_ERROR);*/ // do not overwrite a locally-set title with the default one when ServerAutoCopy syncs the local db during 'make item' (craft)
break ;
}
}
// ***************************************************************************
// Called when INVENTORY:TEMP:0:QUANTITY or INVENTORY:TEMP:0:QUALITY is modified
// Reacts only if mode is Forage
void CTempInvManager : : updateForageQQ ( uint whichOne )
{
if ( _Mode ! = TEMP_INV_MODE : : Forage )
return ;
// Avoid recursion, because we can't call CCDBNodeLeaf::setValue16() without calling observers!
static bool isInUpdateForageQQ = false ;
if ( isInUpdateForageQQ )
return ;
isInUpdateForageQQ = true ;
// Display forage progress with counters
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
2012-05-24 03:02:24 +00:00
bool disableTake = ( NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " LOCAL:INVENTORY:TEMP:ENABLE_TAKE " ) - > getValue32 ( ) = = 0 ) ;
2010-05-06 00:08:41 +00:00
if ( disableTake )
{
2010-11-21 14:07:59 +00:00
float qt = 0.f , ql = 0.f ;
2010-05-06 00:08:41 +00:00
switch ( whichOne )
{
case 0 :
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * leafQt = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " LOCAL:INVENTORY:TEMP:0:QUANTITY " ) ;
2010-05-06 00:08:41 +00:00
uint16 qtX10 = ( uint16 ) ( leafQt - > getValue16 ( ) ) ;
qt = _DBForageQQObs [ whichOne ] . FullValue = ( ( ( float ) ( uint ) qtX10 ) / 10.0f ) ;
leafQt - > setValue16 ( ( sint16 ) ( sint ) qt ) ;
ql = _DBForageQQObs [ 1 - whichOne ] . FullValue ;
}
break ;
case 1 :
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * leafQl = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " LOCAL:INVENTORY:TEMP:0:QUALITY " ) ;
2010-05-06 00:08:41 +00:00
uint16 qlX10 = ( uint16 ) ( leafQl - > getValue16 ( ) ) ;
ql = _DBForageQQObs [ whichOne ] . FullValue = ( ( ( float ) ( uint ) qlX10 ) / 10.0f ) ;
leafQl - > setValue16 ( ( sint16 ) ( sint ) ql ) ;
qt = _DBForageQQObs [ 1 - whichOne ] . FullValue ;
}
break ;
default : ;
}
ucstring title = CI18N : : get ( WIN_TEMPINV_TITLE_FORAGING ) ;
strFindReplace ( title , " %qt " , toString ( " %.1f " , qt ) ) ;
strFindReplace ( title , " %ql " , toString ( " %.1f " , ql ) ) ;
2012-05-31 02:27:27 +00:00
CGroupContainer * pGC = dynamic_cast < CGroupContainer * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( WIN_TEMPINV ) ) ;
2010-05-06 00:08:41 +00:00
pGC - > setUCTitle ( title ) ;
}
isInUpdateForageQQ = false ;
}
// ***************************************************************************
void CTempInvManager : : open ( TEMP_INV_MODE : : TInventoryMode m )
{
_Mode = m ;
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
2012-05-31 02:27:27 +00:00
CGroupContainer * pGC = dynamic_cast < CGroupContainer * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( WIN_TEMPINV ) ) ;
2010-05-06 00:08:41 +00:00
// In Foraging mode, we can call open() on the inventory with the same contents (e.g. when changing Forage action)
if ( _Mode ! = TEMP_INV_MODE : : Forage )
{
string sPath = string ( " LOCAL:INVENTORY:TEMP " ) ;
for ( uint i = 0 ; i < MAX_TEMPINV_ENTRIES ; i + + )
{
string sTmp = sPath + " : " + toString ( i ) + " :SHEET " ;
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( sTmp ) ;
2010-05-06 00:08:41 +00:00
pNL - > setValue32 ( 0 ) ;
}
}
2012-05-24 03:02:24 +00:00
NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " LOCAL:INVENTORY:TEMP:TYPE " ) - > setValue8 ( ( uint8 ) _Mode ) ;
2010-05-06 00:08:41 +00:00
2012-04-22 04:45:35 +00:00
IngameDbMngr . flushObserverCalls ( ) ;
2012-05-24 03:02:24 +00:00
NLGUI : : CDBManager : : getInstance ( ) - > flushObserverCalls ( ) ;
2010-05-06 00:08:41 +00:00
if ( pGC ! = NULL )
{
switch ( _Mode )
{
case TEMP_INV_MODE : : Loot : pGC - > setTitle ( WIN_TEMPINV_TITLE_WAIT_LOOT ) ; break ;
case TEMP_INV_MODE : : Quarter : pGC - > setTitle ( WIN_TEMPINV_TITLE_WAIT_QUARTERING ) ; break ;
case TEMP_INV_MODE : : Forage : pGC - > setTitle ( WIN_TEMPINV_TITLE_WAIT_FORAGING ) ; break ;
case TEMP_INV_MODE : : BagFull : pGC - > setTitle ( WIN_TEMPINV_TITLE_WAIT_BAGFULL ) ; break ;
case TEMP_INV_MODE : : Craft : pGC - > setTitle ( WIN_TEMPINV_TITLE_WAIT_CRAFT ) ; break ;
case TEMP_INV_MODE : : MissionReward : pGC - > setTitle ( WIN_TEMPINV_TITLE_WAIT_MISSIONREWARD ) ; break ;
case TEMP_INV_MODE : : Crystallize : pGC - > setTitle ( WIN_TEMPINV_TITLE_WAIT_CRYSTALLIZE ) ; break ;
case TEMP_INV_MODE : : Unknown :
default : pGC - > setTitle ( WIN_TEMPINV_TITLE_WAIT_ERROR ) ; break ;
} ;
pGC - > setActive ( true ) ;
2012-05-31 23:22:05 +00:00
CAHManager : : getInstance ( ) - > runActionHandler ( " phrase_update_all_memory_ctrl_regen_tick_range " , NULL ) ;
2010-05-06 00:08:41 +00:00
}
}
// ***************************************************************************
void CTempInvManager : : close ( )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
string sPath = string ( " LOCAL:INVENTORY:TEMP " ) ;
// Clear temp inventory if needed
for ( uint i = 0 ; i < MAX_TEMPINV_ENTRIES ; i + + )
{
string sTmp = sPath + " : " + toString ( i ) + " :SHEET " ;
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( sTmp ) ;
2010-05-06 00:08:41 +00:00
pNL - > setValue32 ( 0 ) ;
}
2012-05-31 02:27:27 +00:00
CInterfaceGroup * pIG = dynamic_cast < CInterfaceGroup * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( WIN_TEMPINV ) ) ;
2010-05-06 00:08:41 +00:00
if ( pIG ! = NULL )
{
pIG - > setActive ( false ) ;
2012-05-31 23:22:05 +00:00
CAHManager : : getInstance ( ) - > runActionHandler ( " phrase_update_all_memory_ctrl_regen_tick_range " , NULL ) ;
2010-05-06 00:08:41 +00:00
}
}
// ***************************************************************************
bool CTempInvManager : : isOpened ( )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
2012-05-31 02:27:27 +00:00
CGroupContainer * pGC = dynamic_cast < CGroupContainer * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( WIN_TEMPINV ) ) ;
2010-05-06 00:08:41 +00:00
if ( pGC ! = NULL )
return pGC - > getActive ( ) ;
return false ;
}
// ***************************************************************************
// BAG LISTS COMMON STUFF (sort, options ...)
// ***************************************************************************
// ***************************************************************************
# define BAG_ITEM_NOT_SORTED 1000000
// Used for sorting
void initStructForItemSort ( vector < SSortStruct > & vTemp , sint32 sheetId , sint32 quality , sint32 indexInList , sint32 indexInDB )
{
// Default value is the linear pos in the db (in case its not an item)
vTemp [ indexInList ] . Pos = toString ( " %08d " , indexInDB ) ;
// if not empty
if ( sheetId ! = 0 )
{
CEntitySheet * pItem = SheetMngr . get ( CSheetId ( sheetId ) ) ;
if ( ( pItem ! = NULL ) & & ( pItem - > Type = = CEntitySheet : : ITEM ) )
{
CItemSheet * pIS = safe_cast < CItemSheet * > ( pItem ) ;
vTemp [ indexInList ] . Pos = toString ( " %02d " , pIS - > Family ) ;
vTemp [ indexInList ] . Pos + = toString ( " %03d " , pIS - > ItemType ) ;
// add some specific sort for raw material
if ( pIS - > Family = = ITEMFAMILY : : RAW_MATERIAL )
vTemp [ indexInList ] . Pos + = toString ( " %010d " , pIS - > Mp . ItemPartBF ) ;
else
vTemp [ indexInList ] . Pos + = toString ( " %010d " , 0 ) ;
// add some specific sort for teleport
if ( pIS - > Family = = ITEMFAMILY : : TELEPORT )
vTemp [ indexInList ] . Pos + = toString ( " %02d%02d " , pIS - > ItemOrigin , pIS - > Teleport . Type ) ;
else
vTemp [ indexInList ] . Pos + = toString ( " %02d%02d " , 0 , 0 ) ;
vTemp [ indexInList ] . Pos + = toString ( " %03d " , quality ) ;
2010-07-08 14:05:15 +00:00
// add sort by name
vTemp [ indexInList ] . Pos + = CSheetId ( sheetId ) . toString ( ) ;
2010-05-06 00:08:41 +00:00
// add at last the index in DB. to avoid resort for items that are exaclty the same
vTemp [ indexInList ] . Pos + = toString ( " %03d " , indexInDB ) ;
}
}
}
// ***************************************************************************
// Used for common options
bool SBagOptions : : parse ( xmlNodePtr cur , CInterfaceGroup * /* parentGroup */ )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
// read params
CXMLAutoPtr prop ;
// value
prop = xmlGetProp ( cur , ( xmlChar * ) " inv_type " ) ;
if ( prop )
{
InvType = CInventoryManager : : invTypeFromString ( prop ) ;
}
else
{
InvType = CInventoryManager : : InvUnknown ;
nlwarning ( " cannot find inventory type " ) ;
}
prop = xmlGetProp ( cur , ( xmlChar * ) " filter_armor " ) ;
2012-05-24 03:02:24 +00:00
if ( prop ) DbFilterArmor = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( prop ) ;
2010-05-06 00:08:41 +00:00
prop = xmlGetProp ( cur , ( xmlChar * ) " filter_weapon " ) ;
2012-05-24 03:02:24 +00:00
if ( prop ) DbFilterWeapon = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( prop ) ;
2010-05-06 00:08:41 +00:00
prop = xmlGetProp ( cur , ( xmlChar * ) " filter_tool " ) ;
2012-05-24 03:02:24 +00:00
if ( prop ) DbFilterTool = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( prop ) ;
2010-05-06 00:08:41 +00:00
prop = xmlGetProp ( cur , ( xmlChar * ) " filter_mp " ) ;
2012-05-24 03:02:24 +00:00
if ( prop ) DbFilterMP = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( prop ) ;
2010-05-06 00:08:41 +00:00
prop = xmlGetProp ( cur , ( xmlChar * ) " filter_missmp " ) ;
2012-05-24 03:02:24 +00:00
if ( prop ) DbFilterMissMP = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( prop ) ;
2010-05-06 00:08:41 +00:00
2012-02-27 15:10:47 +00:00
prop = xmlGetProp ( cur , ( xmlChar * ) " filter_tp " ) ;
2012-05-24 03:02:24 +00:00
if ( prop ) DbFilterTP = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( prop ) ;
2012-02-27 15:10:47 +00:00
2010-05-06 00:08:41 +00:00
return true ;
}
// ***************************************************************************
bool SBagOptions : : isSomethingChanged ( )
{
bool bRet = false ;
if ( DbFilterArmor ! = NULL )
if ( ( DbFilterArmor - > getValue8 ( ) ! = 0 ) ! = LastDbFilterArmor )
{
bRet = true ;
LastDbFilterArmor = ( DbFilterArmor - > getValue8 ( ) ! = 0 ) ;
}
if ( DbFilterWeapon ! = NULL )
if ( ( DbFilterWeapon - > getValue8 ( ) ! = 0 ) ! = LastDbFilterWeapon )
{
bRet = true ;
LastDbFilterWeapon = ( DbFilterWeapon - > getValue8 ( ) ! = 0 ) ;
}
if ( DbFilterTool ! = NULL )
if ( ( DbFilterTool - > getValue8 ( ) ! = 0 ) ! = LastDbFilterTool )
{
bRet = true ;
LastDbFilterTool = ( DbFilterTool - > getValue8 ( ) ! = 0 ) ;
}
if ( DbFilterMP ! = NULL )
if ( ( DbFilterMP - > getValue8 ( ) ! = 0 ) ! = LastDbFilterMP )
{
bRet = true ;
LastDbFilterMP = ( DbFilterMP - > getValue8 ( ) ! = 0 ) ;
}
if ( DbFilterMissMP ! = NULL )
if ( ( DbFilterMissMP - > getValue8 ( ) ! = 0 ) ! = LastDbFilterMissMP )
{
bRet = true ;
LastDbFilterMissMP = ( DbFilterMissMP - > getValue8 ( ) ! = 0 ) ;
}
2012-02-27 15:10:47 +00:00
if ( DbFilterTP ! = NULL )
if ( ( DbFilterTP - > getValue8 ( ) ! = 0 ) ! = LastDbFilterTP )
{
bRet = true ;
LastDbFilterTP = ( DbFilterTP - > getValue8 ( ) ! = 0 ) ;
}
2010-05-06 00:08:41 +00:00
return bRet ;
}
// ***************************************************************************
bool SBagOptions : : canDisplay ( CDBCtrlSheet * pCS ) const
{
bool bDisplay = true ;
bool bFilterArmor = getFilterArmor ( ) ;
bool bFilterWeapon = getFilterWeapon ( ) ;
bool bFilterTool = getFilterTool ( ) ;
bool bFilterMP = getFilterMP ( ) ;
bool bFilterMissMP = getFilterMissMP ( ) ;
2012-02-27 15:10:47 +00:00
bool bFilterTP = getFilterTP ( ) ;
2010-05-06 00:08:41 +00:00
const CItemSheet * pIS = pCS - > asItemSheet ( ) ;
if ( pIS ! = NULL )
{
// Armor
2012-02-27 15:10:47 +00:00
if ( ( pIS - > Family = = ITEMFAMILY : : ARMOR ) | |
( pIS - > Family = = ITEMFAMILY : : JEWELRY ) )
2010-05-06 00:08:41 +00:00
if ( ! bFilterArmor ) bDisplay = false ;
// Weapon
2012-02-27 15:10:47 +00:00
if ( ( pIS - > Family = = ITEMFAMILY : : SHIELD ) | |
( pIS - > Family = = ITEMFAMILY : : MELEE_WEAPON ) | |
( pIS - > Family = = ITEMFAMILY : : RANGE_WEAPON ) | |
( pIS - > Family = = ITEMFAMILY : : AMMO ) | |
( pIS - > Family = = ITEMFAMILY : : CRYSTALLIZED_SPELL ) | |
( pIS - > Family = = ITEMFAMILY : : ITEM_SAP_RECHARGE ) | |
2010-05-06 00:08:41 +00:00
( pIS - > Family = = ITEMFAMILY : : BRICK ) )
if ( ! bFilterWeapon ) bDisplay = false ;
// Tool
2012-02-27 15:10:47 +00:00
if ( ( pIS - > Family = = ITEMFAMILY : : CRAFTING_TOOL ) | |
( pIS - > Family = = ITEMFAMILY : : HARVEST_TOOL ) | |
( pIS - > Family = = ITEMFAMILY : : TAMING_TOOL ) | |
( pIS - > Family = = ITEMFAMILY : : TRAINING_TOOL ) | |
( pIS - > Family = = ITEMFAMILY : : BAG ) | |
( pIS - > Family = = ITEMFAMILY : : PET_ANIMAL_TICKET ) )
2010-05-06 00:08:41 +00:00
if ( ! bFilterTool ) bDisplay = false ;
// MP
if ( ( pIS - > Family = = ITEMFAMILY : : RAW_MATERIAL ) & & pIS - > canBuildSomeItemPart ( ) )
if ( ! bFilterMP ) bDisplay = false ;
// Mission MP
if ( ( pIS - > Family = = ITEMFAMILY : : MISSION_ITEM ) | |
2012-02-27 15:10:47 +00:00
( pIS - > Family = = ITEMFAMILY : : XP_CATALYSER ) | |
( pIS - > Family = = ITEMFAMILY : : CONSUMABLE ) | |
2010-05-06 00:08:41 +00:00
( ( pIS - > Family = = ITEMFAMILY : : RAW_MATERIAL ) & & ! pIS - > canBuildSomeItemPart ( ) ) )
if ( ! bFilterMissMP ) bDisplay = false ;
2012-02-27 15:10:47 +00:00
// Teleporter Pacts
if ( ( pIS - > Family = = ITEMFAMILY : : TELEPORT ) )
if ( ! bFilterTP ) bDisplay = false ;
2010-07-08 14:05:15 +00:00
// Jobs Items
if ( pIS - > Id . toString ( ) . substr ( 0 , 6 ) = = " rpjob_ " )
bDisplay = false ;
2010-05-06 00:08:41 +00:00
}
2010-09-20 19:58:24 +00:00
2010-05-06 00:08:41 +00:00
return bDisplay ;
}
// ***************************************************************************
// CDBGroupListSheetBag
// ***************************************************************************
// ***************************************************************************
bool CDBGroupListSheetBag : : parse ( xmlNodePtr cur , CInterfaceGroup * parentGroup )
{
if ( ! CDBGroupListSheetText : : parse ( cur , parentGroup ) )
return false ;
// Parse options (type, filters ...)
if ( ! _BO . parse ( cur , parentGroup ) )
return false ;
return true ;
}
// ***************************************************************************
void CDBGroupListSheetBag : : checkCoords ( )
{
CDBGroupListSheetText : : checkCoords ( ) ;
if ( _BO . isSomethingChanged ( ) )
invalidateCoords ( ) ;
}
// ***************************************************************************
void CDBGroupListSheetBag : : CSheetChildBag : : updateViewText ( CDBGroupListSheetText * /* pFather */ )
{
// common method to update text as item
updateViewTextAsItem ( ) ;
}
// ***************************************************************************
bool CDBGroupListSheetBag : : CSheetChildBag : : isSheetValid ( CDBGroupListSheetText * pFather )
{
if ( CSheetChild : : isSheetValid ( pFather ) )
{
// Check if the control match the filters !
CDBGroupListSheetBag * pList = dynamic_cast < CDBGroupListSheetBag * > ( pFather ) ;
if ( pList )
return pList - > canDisplay ( Ctrl ) ;
}
return false ;
}
// ***************************************************************************
void CDBGroupListSheetBag : : CSheetChildBag : : init ( CDBGroupListSheetText * pFather , uint index )
{
// init my parent
CSheetChild : : init ( pFather , index ) ;
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
// **** Bind the quality
{
// Basic quality
string db = Ctrl - > getSheet ( ) + " :QUALITY " ;
2012-05-24 03:02:24 +00:00
if ( NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( db , false ) )
2010-05-06 00:08:41 +00:00
CurrentQuality . link ( db . c_str ( ) ) ;
else
{
// dummy link to ui:.....
CurrentQuality . link ( " UI:DUMMY:QUALITY " ) ;
CurrentQuality . setSInt32 ( 0 ) ;
}
}
}
// ***************************************************************************
bool CDBGroupListSheetBag : : CSheetChildBag : : isInvalidated ( CDBGroupListSheetText * /* pFather */ )
{
// quality change
if ( CurrentQuality . getSInt32 ( ) ! = LastQuality )
return true ;
return false ;
}
// ***************************************************************************
void CDBGroupListSheetBag : : CSheetChildBag : : update ( CDBGroupListSheetText * /* pFather */ )
{
LastQuality = CurrentQuality . getSInt32 ( ) ;
}
// ***************************************************************************
void CDBGroupListSheetBag : : onSwap ( sint /* nDraggedSheet */ , sint /* nDroppedSheet */ )
{
// No more used because automatic sort
}
// ***************************************************************************
void CDBGroupListSheetBag : : sort ( )
{
vector < SSortStruct > vTemp ;
vTemp . resize ( _MaxItems ) ;
uint i ;
for ( i = 0 ; i < _MaxItems ; + + i )
{
vTemp [ i ] . SheetText = _SheetChildren [ i ] ;
CDBCtrlSheet * ctrl = _SheetChildren [ i ] - > Ctrl ;
initStructForItemSort ( vTemp , ctrl - > getSheetId ( ) , ctrl - > getQuality ( ) , i , ctrl - > getIndexInDB ( ) ) ;
}
std : : sort ( vTemp . begin ( ) , vTemp . end ( ) ) ;
for ( i = 0 ; i < _MaxItems ; + + i )
{
_SheetChildren [ i ] = vTemp [ i ] . SheetText ;
}
}
// ***************************************************************************
// CDBGroupIconListBag
// ***************************************************************************
// ***************************************************************************
bool CDBGroupIconListBag : : parse ( xmlNodePtr cur , CInterfaceGroup * parentGroup )
{
if ( ! CDBGroupListSheet : : parse ( cur , parentGroup ) )
return false ;
// Parse options (type, filters ...)
if ( ! _BO . parse ( cur , parentGroup ) )
return false ;
return true ;
}
// ***************************************************************************
void CDBGroupIconListBag : : sort ( )
{
vector < SSortStruct > vTemp ;
vTemp . resize ( _MaxItems ) ;
uint i ;
for ( i = 0 ; i < _MaxItems ; + + i )
{
vTemp [ i ] . SheetIcon = _SheetChildren [ i ] ;
CDBCtrlSheet * ctrl = _SheetChildren [ i ] - > Ctrl ;
initStructForItemSort ( vTemp , ctrl - > getSheetId ( ) , ctrl - > getQuality ( ) , i , ctrl - > getIndexInDB ( ) ) ;
}
std : : sort ( vTemp . begin ( ) , vTemp . end ( ) ) ;
for ( i = 0 ; i < _MaxItems ; + + i )
{
_SheetChildren [ i ] = vTemp [ i ] . SheetIcon ;
}
}
// ***************************************************************************
void CDBGroupIconListBag : : checkCoords ( )
{
CDBGroupListSheet : : checkCoords ( ) ;
if ( _BO . isSomethingChanged ( ) )
invalidateCoords ( ) ;
}
// ***************************************************************************
bool CDBGroupIconListBag : : CSheetChildBag : : isSheetValid ( CDBGroupListSheet * pFather )
{
if ( CSheetChild : : isSheetValid ( pFather ) )
{
// Check if the control match the filters !
CDBGroupIconListBag * pList = dynamic_cast < CDBGroupIconListBag * > ( pFather ) ;
if ( pList )
return pList - > canDisplay ( Ctrl ) ;
}
return false ;
}
// ***************************************************************************
// CDBGroupListSheetFilterCLMSlot
// ***************************************************************************
// ***************************************************************************
bool CDBGroupListSheetFilterCLMSlot : : CSheetChildFilter : : isSheetValid ( CDBGroupListSheet * pFather )
{
if ( CSheetChild : : isSheetValid ( pFather ) )
{
/* This filter look the ctrl who launch the modal where this list is displayed.
If we can drop this ChildCtrl , on the CLM control , then ok , filtered
Plus the ChildControl must not be locked
*/
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
2012-05-31 02:27:27 +00:00
CDBCtrlSheet * clmCtrl = dynamic_cast < CDBCtrlSheet * > ( CWidgetManager : : getInstance ( ) - > getCtrlLaunchingModal ( ) ) ;
2010-05-06 00:08:41 +00:00
if ( ! clmCtrl | | ! Ctrl ) return false ;
if ( clmCtrl - > getInventoryIndex ( ) = = INVENTORIES : : exchange & &
Ctrl - > getInventoryIndex ( ) = = INVENTORIES : : exchange )
{
return false ;
}
if ( ( clmCtrl - > getType ( ) = = CCtrlSheetInfo : : SheetType_Item ) & &
( Ctrl - > getType ( ) = = CCtrlSheetInfo : : SheetType_Item ) )
{
// Ok if we can put in the slot Ctrl in clmCtrl
if ( clmCtrl - > canDropItem ( Ctrl ) )
{
string sTmp = Ctrl - > getSheet ( ) ;
// Look if the source is locked
sTmp = sTmp . substr ( sTmp . rfind ( ' : ' ) + 1 , sTmp . size ( ) ) ;
sint32 nTmp ;
fromString ( sTmp , nTmp ) ;
if ( ! getInventory ( ) . isBagItemWeared ( nTmp ) )
return true ;
}
}
}
return false ;
}
// ***************************************************************************
// CDBGroupListSheetFilterExchangeable
// ***************************************************************************
// ***************************************************************************
bool CDBGroupListSheetFilterExchangeable : : CSheetChildFilter : : isSheetValid ( CDBGroupListSheet * pFather )
{
if ( CSheetChild : : isSheetValid ( pFather ) )
{
if ( ! Ctrl )
return false ;
extern bool checkCanExchangeItem ( CDBCtrlSheet * ) ;
return checkCanExchangeItem ( Ctrl ) ;
}
return false ;
}
2011-03-09 12:40:44 +00:00
// ***************************************************************************
void CDBGroupListSheetFilterExchangeable : : sort ( )
{
vector < SSortStruct > vTemp ;
vTemp . resize ( _MaxItems ) ;
uint i ;
for ( i = 0 ; i < _MaxItems ; + + i )
{
vTemp [ i ] . SheetIcon = _SheetChildren [ i ] ;
CDBCtrlSheet * ctrl = _SheetChildren [ i ] - > Ctrl ;
initStructForItemSort ( vTemp , ctrl - > getSheetId ( ) , ctrl - > getQuality ( ) , i , ctrl - > getIndexInDB ( ) ) ;
}
std : : sort ( vTemp . begin ( ) , vTemp . end ( ) ) ;
for ( i = 0 ; i < _MaxItems ; + + i )
{
_SheetChildren [ i ] = vTemp [ i ] . SheetIcon ;
}
}
// ***************************************************************************
bool CDBGroupListSheetFilterExchangeable : : parse ( xmlNodePtr cur , CInterfaceGroup * parentGroup )
{
if ( ! CDBGroupListSheet : : parse ( cur , parentGroup ) )
return false ;
// Parse options (type, filters ...)
if ( ! _BO . parse ( cur , parentGroup ) )
return false ;
return true ;
}
2010-05-06 00:08:41 +00:00
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ACTION HANDLERS
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// COMMON INVENTORIES DRAG'N'DROP
// ***************************************************************************
// ***************************************************************************
class CHandlerInvCanDrag : public IActionHandler
{
virtual void execute ( CCtrlBase * pCaller , const string & /* Params */ )
{
CDBCtrlSheet * pCSSrc = dynamic_cast < CDBCtrlSheet * > ( pCaller ) ;
if ( pCSSrc = = NULL ) return ;
// Cannot drag an item if it is completely locked
if ( pCSSrc - > getNonLockedQuantity ( ) = = 0 )
{
pCSSrc - > setTempCanDrag ( false ) ;
return ;
}
// If the item comes from an animal list which is not available -> cannot move
if ( strnicmp ( pCSSrc - > getSheet ( ) . c_str ( ) , " LOCAL:INVENTORY:PACK_ANIMAL " , 27 ) = = 0 )
{
string sTmp = pCSSrc - > getSheet ( ) . substr ( 0 , pCSSrc - > getSheet ( ) . rfind ( ' : ' ) ) ;
sTmp = sTmp . substr ( 27 , sTmp . size ( ) ) ;
uint32 nAni ;
fromString ( sTmp , nAni ) ;
INVENTORIES : : TInventory inv = ( INVENTORIES : : TInventory ) ( INVENTORIES : : pet_animal + nAni ) ;
pCSSrc - > setTempCanDrag ( getInventory ( ) . isInventoryAvailable ( inv ) ) ;
}
}
} ;
REGISTER_ACTION_HANDLER ( CHandlerInvCanDrag , " inv_can_drag " ) ;
// ***************************************************************************
class CHandlerInvDrag : public IActionHandler
{
virtual void execute ( CCtrlBase * pCaller , const string & Params )
{
CDBCtrlSheet * pCS = dynamic_cast < CDBCtrlSheet * > ( pCaller ) ;
if ( pCS = = NULL ) return ;
if ( Params = = " from_text_list " )
getInventory ( ) . beginDrag ( pCS , CInventoryManager : : TextList ) ;
else if ( Params = = " from_slot " )
getInventory ( ) . beginDrag ( pCS , CInventoryManager : : Slot ) ;
else if ( Params = = " from_icon_list " )
getInventory ( ) . beginDrag ( pCS , CInventoryManager : : IconList ) ;
else
nlwarning ( " DND not binded " ) ;
}
} ;
REGISTER_ACTION_HANDLER ( CHandlerInvDrag , " inv_drag " ) ;
// ***************************************************************************
// COMMON INVENTORIES Test if we can drop an item to a slot or a list
class CHandlerInvCanDropTo : public IActionHandler
{
virtual void execute ( CCtrlBase * pCaller , const string & Params )
{
// pCSSrc is the current dragged item
// pCSDst is a slot or a list
CInventoryManager * pInv = CInventoryManager : : getInstance ( ) ;
if ( ! pInv - > isDragging ( ) ) return ; // To prevent other things to happens
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
string src = getParam ( Params , " src " ) ;
2012-05-31 02:27:27 +00:00
CInterfaceElement * pElt = CWidgetManager : : getInstance ( ) - > getElementFromId ( src ) ;
2010-05-06 00:08:41 +00:00
CDBCtrlSheet * pCSSrc = dynamic_cast < CDBCtrlSheet * > ( pElt ) ;
if ( pCSSrc = = NULL ) return ; // Cannot do anything if the incoming sheet is not a sheet
// Special case if we want to DND an animal representation
// -------------------------------------------------------
{
const CItemSheet * pIS = pCSSrc - > asItemSheet ( ) ;
if ( ( pIS ! = NULL ) & & ( pIS - > Family = = ITEMFAMILY : : PET_ANIMAL_TICKET ) )
{
CDBCtrlSheet * pCSDst = dynamic_cast < CDBCtrlSheet * > ( pCaller ) ;
if ( pCSDst ! = NULL )
{
// The destination must be exchange or gift
if ( strnicmp ( pCSDst - > getSheet ( ) . c_str ( ) , " LOCAL:EXCHANGE:GIVE " , 19 ) = = 0 )
{
// The animal bag must be empty before giving it
if ( pIS - > Pet . Slot > 0 )
if ( pInv - > isInventoryEmpty ( ( INVENTORIES : : TInventory ) ( INVENTORIES : : pet_animal + ( pIS - > Pet . Slot - 1 ) ) ) )
pCSDst - > setCanDrop ( true ) ;
}
// Or moving in the bag (user sort)
if ( strnicmp ( pCSDst - > getSheet ( ) . c_str ( ) , " LOCAL:INVENTORY:BAG " , 19 ) = = 0 )
pCSDst - > setCanDrop ( true ) ;
}
return ;
}
}
// The destination is a slot or something like that ?
// --------------------------------------------------
CDBCtrlSheet * pCSDst = dynamic_cast < CDBCtrlSheet * > ( pCaller ) ;
if ( pCSDst ! = NULL )
{
// If we want to drop something on a reference slot (hand or equip)
if ( pInv - > getDBIndexPath ( pCSDst ) ! = " " )
{
// We must drag'n'drop an item
if ( pCSSrc & & pCSSrc - > getType ( ) = = CCtrlSheetInfo : : SheetType_Item )
if ( pCSDst & & pCSDst - > getType ( ) = = CCtrlSheetInfo : : SheetType_Item )
{
if ( pInv - > getDBIndexPath ( pCSSrc ) ! = " " )
{
// The item dragged comes from a slot check if this is the good type
if ( pCSDst - > canDropItem ( pCSSrc ) )
pCSDst - > setCanDrop ( true ) ;
}
else
{
// The source must be from the bag
if ( strnicmp ( pCSSrc - > getSheet ( ) . c_str ( ) , " LOCAL:INVENTORY:BAG " , 19 ) = = 0 )
pCSDst - > setCanDrop ( true ) ;
}
}
}
else
{
// Does the source and destination are items ?
if ( pCSSrc & & pCSSrc - > getType ( ) = = CCtrlSheetInfo : : SheetType_Item )
if ( pCSDst & & pCSDst - > getType ( ) = = CCtrlSheetInfo : : SheetType_Item )
{
// Right Slot ?
if ( pCSDst - > canDropItem ( pCSSrc ) )
pCSDst - > setCanDrop ( true ) ;
}
}
return ;
}
// The destination is a list of items ?
// ------------------------------------
CDBGroupListSheetBag * pListDstText = dynamic_cast < CDBGroupListSheetBag * > ( pCaller ) ;
CDBGroupIconListBag * pListDstIcon = dynamic_cast < CDBGroupIconListBag * > ( pCaller ) ;
if ( ( pListDstText ! = NULL ) | | ( pListDstIcon ! = NULL ) )
{
bool bCanDrop = true ;
// WE CANT DND if we want to dnd from other bag than BAG to guild bag
if ( pListDstIcon ! = NULL )
{
if ( pListDstIcon - > getInvType ( ) = = CInventoryManager : : InvGuild )
if ( strnicmp ( pCSSrc - > getSheet ( ) . c_str ( ) , " LOCAL:INVENTORY:BAG " , 19 ) ! = 0 )
bCanDrop = false ;
}
if ( pListDstText ! = NULL )
{
if ( pListDstText - > getInvType ( ) = = CInventoryManager : : InvGuild )
if ( strnicmp ( pCSSrc - > getSheet ( ) . c_str ( ) , " LOCAL:INVENTORY:BAG " , 19 ) ! = 0 )
bCanDrop = false ;
}
// WE CANT DND if we want to dnd from guild bag to other bag than BAG
if ( pListDstIcon ! = NULL )
{
if ( pListDstIcon - > getInvType ( ) ! = CInventoryManager : : InvBag )
if ( strnicmp ( pCSSrc - > getSheet ( ) . c_str ( ) , " SERVER:GUILD:INVENTORY " , 19 ) = = 0 )
bCanDrop = false ;
}
if ( pListDstText ! = NULL )
{
if ( pListDstText - > getInvType ( ) ! = CInventoryManager : : InvBag )
if ( strnicmp ( pCSSrc - > getSheet ( ) . c_str ( ) , " SERVER:GUILD:INVENTORY " , 19 ) = = 0 )
bCanDrop = false ;
}
// WE CANT DND when packer/mount is too far
if ( pListDstIcon ! = NULL )
{
if ( ( pListDstIcon - > getInvType ( ) = = CInventoryManager : : InvPA0 ) | |
( pListDstIcon - > getInvType ( ) = = CInventoryManager : : InvPA1 ) | |
( pListDstIcon - > getInvType ( ) = = CInventoryManager : : InvPA2 ) | |
( pListDstIcon - > getInvType ( ) = = CInventoryManager : : InvPA3 ) )
{
INVENTORIES : : TInventory e = ( INVENTORIES : : TInventory ) ( INVENTORIES : : pet_animal1 + ( pListDstIcon - > getInvType ( ) - CInventoryManager : : InvPA0 ) ) ;
if ( ! pInv - > isInventoryAvailable ( e ) )
bCanDrop = false ;
}
}
if ( pListDstText ! = NULL )
{
if ( ( pListDstText - > getInvType ( ) = = CInventoryManager : : InvPA0 ) | |
( pListDstText - > getInvType ( ) = = CInventoryManager : : InvPA1 ) | |
( pListDstText - > getInvType ( ) = = CInventoryManager : : InvPA2 ) | |
( pListDstText - > getInvType ( ) = = CInventoryManager : : InvPA3 ) )
{
INVENTORIES : : TInventory e = ( INVENTORIES : : TInventory ) ( INVENTORIES : : pet_animal1 + ( pListDstText - > getInvType ( ) - CInventoryManager : : InvPA0 ) ) ;
if ( ! pInv - > isInventoryAvailable ( e ) )
bCanDrop = false ;
}
}
// If the source is the equipment
if ( pListDstText ! = NULL ) pListDstText - > setCanDrop ( bCanDrop ) ;
if ( pListDstIcon ! = NULL ) pListDstIcon - > setCanDrop ( bCanDrop ) ;
}
}
} ;
REGISTER_ACTION_HANDLER ( CHandlerInvCanDropTo , " inv_can_drop " ) ;
// ***************************************************************************
class CHandlerInvDropTo : public IActionHandler
{
virtual void execute ( CCtrlBase * pCaller , const string & Params )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
// Check that we have drag'n'drop from inventory (list or slot)
// Or if we have launched the choose_bag modal
// To prevent other things to happens
if ( ! getInventory ( ) . isDragging ( ) )
{
2012-05-31 02:27:27 +00:00
CInterfaceGroup * pIG = CWidgetManager : : getInstance ( ) - > getModalWindow ( ) ;
2010-05-06 00:08:41 +00:00
if ( pIG = = NULL ) return ;
if ( pIG - > getId ( ) ! = " ui:interface:bag_choose " ) return ;
getInventory ( ) . beginDrag ( NULL , CInventoryManager : : TextList ) ;
// Special case for choose in bag dialog
string src = getParam ( Params , " src " ) ;
2012-05-31 02:27:27 +00:00
CInterfaceElement * pElt = CWidgetManager : : getInstance ( ) - > getElementFromId ( src ) ;
2010-05-06 00:08:41 +00:00
CDBCtrlSheet * pCSSrc = dynamic_cast < CDBCtrlSheet * > ( pElt ) ;
CDBCtrlSheet * pCSDst = dynamic_cast < CDBCtrlSheet * > ( pCaller ) ;
string invPath = getInventory ( ) . getDBIndexPath ( pCSSrc ) ;
string bagPath = pCSDst - > getSheet ( ) ;
if ( bagPath = = " UI:EMPTY " )
getInventory ( ) . unequip ( invPath ) ;
else
getInventory ( ) . equip ( bagPath , invPath ) ;
getInventory ( ) . endDrag ( ) ;
return ;
}
string src = getParam ( Params , " src " ) ;
2012-05-31 02:27:27 +00:00
CInterfaceElement * pElt = CWidgetManager : : getInstance ( ) - > getElementFromId ( src ) ;
2010-05-06 00:08:41 +00:00
CDBCtrlSheet * pCSSrc = dynamic_cast < CDBCtrlSheet * > ( pElt ) ;
CDBCtrlSheet * pCSDst = dynamic_cast < CDBCtrlSheet * > ( pCaller ) ;
if ( pCSSrc = = NULL ) return ;
// Is the dragged sheet comes from an inventory list
if ( getInventory ( ) . isDraggingFromTextList ( ) | | getInventory ( ) . isDraggingFromIconList ( ) )
{
// If the destination is an equipment slot ?
if ( pCSDst ! = NULL )
{
string invPath = getInventory ( ) . getDBIndexPath ( pCSDst ) ; // Get the index in the equipment
if ( ! invPath . empty ( ) )
{
// Drop to the slot ie write the database with the index of the slot
string bagPath = pCSSrc - > getSheet ( ) ; // Get the database branch of the dragged sheet
if ( pCSSrc & & pCSSrc - > getType ( ) = = CCtrlSheetInfo : : SheetType_Item )
if ( pCSDst & & pCSDst - > getType ( ) = = CCtrlSheetInfo : : SheetType_Item )
{
// If the destination slot match with the type of incoming item
if ( pCSDst - > canDropItem ( pCSSrc ) )
{
// So directly equip
getInventory ( ) . equip ( bagPath , invPath ) ;
}
else
{
// Else try to auto equip the player with the incoming item
const string sTmp = bagPath . substr ( bagPath . rfind ( ' : ' ) + 1 , bagPath . size ( ) ) ;
sint index ;
fromString ( sTmp , index ) ;
if ( ! getInventory ( ) . autoEquip ( index , false ) )
getInventory ( ) . autoEquip ( index , true ) ;
}
}
getInventory ( ) . endDrag ( ) ;
return ;
}
}
// If the destination is a list sheet
IListSheetBase * pListDst = dynamic_cast < IListSheetBase * > ( pCaller ) ;
if ( ( pListDst = = NULL ) & & ( pCSDst ! = NULL ) )
pListDst = IListSheetBase : : getListContaining ( pCSDst ) ;
IListSheetBase * pListSrc = IListSheetBase : : getListContaining ( pCSSrc ) ;
if ( ( pListDst ! = NULL ) & & ( pListSrc ! = NULL ) )
{
// If the source list and destination list are the same
if ( pListDst = = pListSrc )
{
// no op
getInventory ( ) . endDrag ( ) ;
return ;
}
else // Source list and destination list are not the same
{
// Move the item to the destination list using the procedure move_to_xxx
CDBGroupListSheetBag * pListDstText = dynamic_cast < CDBGroupListSheetBag * > ( pListDst ) ;
CDBGroupIconListBag * pListDstIcon = dynamic_cast < CDBGroupIconListBag * > ( pListDst ) ;
if ( ( ( pListDstText ! = NULL ) & & ( pListDstText - > getInvType ( ) = = CInventoryManager : : InvBag ) ) | |
( ( pListDstIcon ! = NULL ) & & ( pListDstIcon - > getInvType ( ) = = CInventoryManager : : InvBag ) ) )
{
2012-05-31 23:22:05 +00:00
CAHManager : : getInstance ( ) - > runActionHandler ( " proc " , pCSSrc , " move_to_bag " ) ;
2010-05-06 00:08:41 +00:00
}
else if ( ( ( pListDstText ! = NULL ) & & ( ( pListDstText - > getInvType ( ) = = CInventoryManager : : InvPA0 ) | |
( pListDstText - > getInvType ( ) = = CInventoryManager : : InvPA1 ) | |
( pListDstText - > getInvType ( ) = = CInventoryManager : : InvPA2 ) | |
( pListDstText - > getInvType ( ) = = CInventoryManager : : InvPA3 )
) ) | |
( ( pListDstIcon ! = NULL ) & & ( ( pListDstIcon - > getInvType ( ) = = CInventoryManager : : InvPA0 ) | |
( pListDstIcon - > getInvType ( ) = = CInventoryManager : : InvPA1 ) | |
( pListDstIcon - > getInvType ( ) = = CInventoryManager : : InvPA2 ) | |
( pListDstIcon - > getInvType ( ) = = CInventoryManager : : InvPA3 )
) ) )
{
string sTmp ;
if ( pListDstText ! = NULL ) sTmp = toString ( " %d " , pListDstText - > getInvType ( ) - CInventoryManager : : InvPA0 ) ;
if ( pListDstIcon ! = NULL ) sTmp = toString ( " %d " , pListDstIcon - > getInvType ( ) - CInventoryManager : : InvPA0 ) ;
2012-05-31 23:22:05 +00:00
CAHManager : : getInstance ( ) - > runActionHandler ( " proc " , pCSSrc , " move_to_pa| " + sTmp ) ;
2010-05-06 00:08:41 +00:00
}
else if ( ( ( pListDstText ! = NULL ) & & ( pListDstText - > getInvType ( ) = = CInventoryManager : : InvGuild ) ) | |
( ( pListDstIcon ! = NULL ) & & ( pListDstIcon - > getInvType ( ) = = CInventoryManager : : InvGuild ) ) )
{
if ( strnicmp ( pCSSrc - > getSheet ( ) . c_str ( ) , " LOCAL:INVENTORY:BAG " , 19 ) = = 0 )
2012-05-31 23:22:05 +00:00
CAHManager : : getInstance ( ) - > runActionHandler ( " proc " , pCSSrc , " move_to_guild " ) ;
2010-05-06 00:08:41 +00:00
}
else if ( ( ( pListDstText ! = NULL ) & & ( pListDstText - > getInvType ( ) = = CInventoryManager : : InvRoom ) ) | |
( ( pListDstIcon ! = NULL ) & & ( pListDstIcon - > getInvType ( ) = = CInventoryManager : : InvRoom ) ) )
{
2012-05-31 23:22:05 +00:00
CAHManager : : getInstance ( ) - > runActionHandler ( " proc " , pCSSrc , " move_to_room " ) ;
2010-05-06 00:08:41 +00:00
}
}
}
}
// Is the dragged sheet comes from another slot
if ( pCSDst ! = NULL )
if ( getInventory ( ) . isDraggingFromSlot ( ) )
{
// Yes swap the 2 indices
// Get the database branch of the dragged sheet
string invPath1 = getInventory ( ) . getDBIndexPath ( pCSSrc ) ;
// Get the index in the equipment
string invPath2 = getInventory ( ) . getDBIndexPath ( pCSDst ) ;
2012-05-24 03:02:24 +00:00
sint32 i1 = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( invPath1 + " :INDEX_IN_BAG " ) - > getValue16 ( ) ;
sint32 i2 = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( invPath2 + " :INDEX_IN_BAG " ) - > getValue16 ( ) ;
2010-05-06 00:08:41 +00:00
getInventory ( ) . unequip ( invPath1 ) ;
getInventory ( ) . unequip ( invPath2 ) ;
string sBag = LOCAL_INVENTORY " :BAG: " ;
if ( i2 ! = 0 ) getInventory ( ) . equip ( sBag + toString ( i2 - 1 ) , invPath1 ) ;
if ( i1 ! = 0 ) getInventory ( ) . equip ( sBag + toString ( i1 - 1 ) , invPath2 ) ;
}
2012-05-31 23:22:05 +00:00
CAHManager : : getInstance ( ) - > runActionHandler ( " inv_cannot_drop " , pCSSrc ) ;
2010-05-06 00:08:41 +00:00
}
} ;
REGISTER_ACTION_HANDLER ( CHandlerInvDropTo , " inv_drop " ) ;
// ***************************************************************************
// EQUIPMENT
class CHandlerInvCannotDrop : public IActionHandler
{
virtual void execute ( CCtrlBase * pCaller , const string & /* Params */ )
{
// Is the dragged sheet comes from a slot
if ( ! getInventory ( ) . isDraggingFromTextList ( ) )
{
// Unequip
CDBCtrlSheet * pCSDst = dynamic_cast < CDBCtrlSheet * > ( pCaller ) ;
string invPath = getInventory ( ) . getDBIndexPath ( pCSDst ) ;
getInventory ( ) . unequip ( invPath ) ;
}
getInventory ( ) . endDrag ( ) ;
}
} ;
REGISTER_ACTION_HANDLER ( CHandlerInvCannotDrop , " inv_cannot_drop " ) ;
// ***************************************************************************
class CHandlerInvAutoEquip : public IActionHandler
{
public :
virtual void execute ( CCtrlBase * pCaller , const string & /* Params */ )
{
CDBCtrlSheet * cs = dynamic_cast < CDBCtrlSheet * > ( pCaller ) ;
if ( cs )
{
uint index = cs - > getIndexInDB ( ) ;
if ( ! getInventory ( ) . autoEquip ( index , false ) )
getInventory ( ) . autoEquip ( index , true ) ;
}
}
} ;
REGISTER_ACTION_HANDLER ( CHandlerInvAutoEquip , " inv_auto_equip " ) ;
2012-02-27 15:10:47 +00:00
// **********************************************************************************************************
class CHandlerLockInvItem : public IActionHandler
{
void execute ( CCtrlBase * pCaller , const std : : string & sParams )
{
// get the calling item
CDBCtrlSheet * item = CDBCtrlSheet : : getCurrSelSheet ( ) ;
if ( ! item )
{
nlwarning ( " <CHandlerDestroyItem::execute> no caller sheet found " ) ;
return ;
}
string lock = " 1 " ;
if ( item - > getLockedByOwner ( ) )
{
lock = " 0 " ;
}
uint32 slot = item - > getIndexInDB ( ) ;
uint32 inv = item - > getInventoryIndex ( ) ;
INVENTORIES : : TInventory inventory = INVENTORIES : : UNDEFINED ;
inventory = ( INVENTORIES : : TInventory ) ( inv ) ;
if ( inventory = = INVENTORIES : : UNDEFINED )
{
return ;
}
NLMISC : : ICommand : : execute ( " a lockItem " + INVENTORIES : : toString ( inventory ) + " " + toString ( slot ) + " " + lock , g_log ) ;
}
} ;
REGISTER_ACTION_HANDLER ( CHandlerLockInvItem , " lock_inv_item " ) ;
2010-05-06 00:08:41 +00:00
// ***************************************************************************
// Inventory Temporary
// ***************************************************************************
// ***************************************************************************
class CHandlerInvTempToBag : public IActionHandler
{
virtual void execute ( CCtrlBase * pCaller , const string & /* Params */ )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
// Disable the direct click on item in Forage mode and Can't take all
if ( ( CTempInvManager : : getInstance ( ) - > getMode ( ) = = TEMP_INV_MODE : : Forage ) & &
2012-05-24 03:02:24 +00:00
( NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " LOCAL:INVENTORY:TEMP:ENABLE_TAKE " ) - > getValue32 ( ) = = 0 ) )
2010-05-06 00:08:41 +00:00
return ;
CDBCtrlSheet * pCSDst = dynamic_cast < CDBCtrlSheet * > ( pCaller ) ;
if ( ! pCSDst - > isSheetValid ( ) ) return ;
string sTmp = pCSDst - > getSheet ( ) ;
sTmp = sTmp . substr ( sTmp . rfind ( ' : ' ) + 1 , sTmp . size ( ) ) ;
uint16 index ;
fromString ( sTmp , index ) ;
// If we cant find place display a message and dont send the request to the server
if ( ! getInventory ( ) . isSpaceInAllBagsForItem ( pCSDst ) )
{
ucstring msg = CI18N : : get ( " msgCantPutItemInBag " ) ;
string cat = getStringCategory ( msg , msg ) ;
pIM - > displaySystemInfo ( msg , cat ) ;
return ;
}
sTmp = pCSDst - > getSheet ( ) ;
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( sTmp + " :SHEET " , false ) ;
2010-05-06 00:08:41 +00:00
pNL - > setValue32 ( 0 ) ;
CBitMemStream out ;
if ( ! GenericMsgHeaderMngr . pushNameToStream ( " ITEM:TEMP_TO_BAG " , out ) )
{
nlwarning ( " don't know message name ITEM:TEMP_TO_BAG " ) ;
}
else
{
// Fill the message (temporary inventory slot)
out . serial ( index ) ;
NetMngr . push ( out ) ;
//nlinfo("impulseCallBack : ITEM:TEMP_TO_BAG %d sent", index);
}
}
} ;
REGISTER_ACTION_HANDLER ( CHandlerInvTempToBag , " inv_temp_to_bag " ) ;
// ***************************************************************************
class CHandlerInvTempAll : public IActionHandler
{
virtual void execute ( CCtrlBase * /* pCaller */ , const string & /* Params */ )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
CInventoryManager * pInv = CInventoryManager : : getInstance ( ) ;
// Try to put all items in the DB order in all the bags of the player : (bag, pa0-3, steed)
vector < pair < double , double > > BagsBulk ;
2010-05-08 21:27:35 +00:00
BagsBulk . push_back ( pair < double , double > ( pInv - > getBagBulk ( 0 ) , pInv - > getMaxBagBulk ( 0 ) ) ) ;
2010-05-06 00:08:41 +00:00
nlctassert ( MAX_INVENTORY_ANIMAL = = 4 ) ;
if ( pInv - > isInventoryAvailable ( INVENTORIES : : pet_animal1 ) )
2012-02-27 15:10:47 +00:00
BagsBulk . push_back ( pair < double , double > ( pInv - > getBagBulk ( 1 ) , pInv - > getMaxBagBulk ( 1 ) ) ) ;
2010-05-06 00:08:41 +00:00
if ( pInv - > isInventoryAvailable ( INVENTORIES : : pet_animal2 ) )
2012-02-27 15:10:47 +00:00
BagsBulk . push_back ( pair < double , double > ( pInv - > getBagBulk ( 2 ) , pInv - > getMaxBagBulk ( 2 ) ) ) ;
2010-05-06 00:08:41 +00:00
if ( pInv - > isInventoryAvailable ( INVENTORIES : : pet_animal3 ) )
2012-02-27 15:10:47 +00:00
BagsBulk . push_back ( pair < double , double > ( pInv - > getBagBulk ( 3 ) , pInv - > getMaxBagBulk ( 3 ) ) ) ;
2010-05-06 00:08:41 +00:00
if ( pInv - > isInventoryAvailable ( INVENTORIES : : pet_animal4 ) )
2010-05-08 21:27:35 +00:00
BagsBulk . push_back ( pair < double , double > ( pInv - > getBagBulk ( 4 ) , pInv - > getMaxBagBulk ( 4 ) ) ) ;
2010-05-06 00:08:41 +00:00
bool bPlaceFound = true ;
for ( uint32 itemNb = 0 ; itemNb < MAX_TEMPINV_ENTRIES ; + + itemNb )
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :TEMP: " + toString ( itemNb ) + " :SHEET " ) ;
CCDBNodeLeaf * pNLquantity = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( LOCAL_INVENTORY " :TEMP: " + toString ( itemNb ) + " :QUANTITY " ) ;
2010-05-06 00:08:41 +00:00
if ( pNL = = NULL | | pNLquantity = = NULL ) continue ;
if ( pNL - > getValue32 ( ) = = 0 | | pNLquantity - > getValue32 ( ) = = 0 ) continue ;
double itemBulk = pNLquantity - > getValue32 ( ) * pInv - > getItemBulk ( pNL - > getValue32 ( ) ) ;
bool bLocalPlaceFound = false ;
for ( uint32 i = 0 ; i < BagsBulk . size ( ) ; + + i )
{
if ( ( BagsBulk [ i ] . first + itemBulk ) < = BagsBulk [ i ] . second )
{
BagsBulk [ i ] . first + = itemBulk ;
bLocalPlaceFound = true ;
break ;
}
}
if ( ! bLocalPlaceFound )
{
bPlaceFound = false ;
break ;
}
}
if ( ! bPlaceFound )
{
ucstring msg = CI18N : : get ( " msgCantPutItemInBag " ) ;
string cat = getStringCategory ( msg , msg ) ;
CInterfaceManager : : getInstance ( ) - > displaySystemInfo ( msg , cat ) ;
return ;
}
CBitMemStream out ;
if ( ! GenericMsgHeaderMngr . pushNameToStream ( " ITEM:ALL_TEMP " , out ) )
{
nlwarning ( " don't know message name ITEM:ALL_TEMP " ) ;
}
else
{
NetMngr . push ( out ) ;
//nlinfo("impulseCallBack : ITEM:ALL_TEMP sent");
}
CTempInvManager : : getInstance ( ) - > close ( ) ;
}
} ;
REGISTER_ACTION_HANDLER ( CHandlerInvTempAll , " inv_temp_all " ) ;
// ***************************************************************************
class CHandlerInvTempNone : public IActionHandler
{
virtual void execute ( CCtrlBase * /* pCaller */ , const string & /* Params */ )
{
CBitMemStream out ;
if ( ! GenericMsgHeaderMngr . pushNameToStream ( " ITEM:NO_TEMP " , out ) )
{
nlwarning ( " don't know message name ITEM:NO_TEMP " ) ;
}
else
{
NetMngr . push ( out ) ;
//nlinfo("impulseCallBack : ITEM:NO_TEMP sent");
}
CTempInvManager : : getInstance ( ) - > close ( ) ;
}
} ;
REGISTER_ACTION_HANDLER ( CHandlerInvTempNone , " inv_temp_none " ) ;
// ***************************************************************************
// ***************************************************************************
// ItemInfo System
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CClientItemInfo : : readFromImpulse ( const CItemInfos & itemInfo )
{
* ( CItemInfos * ) this = itemInfo ;
// Read now the version in the impulse
InfoVersionFromMsg = itemInfo . versionInfo ;
}
// ***************************************************************************
uint16 CInventoryManager : : getItemSlotId ( CDBCtrlSheet * ctrl )
{
return getItemSlotId ( ctrl - > getSheet ( ) , ctrl - > getIndexInDB ( ) ) ;
}
// ***************************************************************************
uint16 CInventoryManager : : getItemSlotId ( const std : : string & itemDb , uint slotIndex )
{
// then compare to all possible inventories (ugly)
uint inventoryIndex = 0 ;
for ( uint i = 0 ; i < NumInventories ; i + + )
{
if ( itemDb . find ( InventoryDBs [ i ] ) ! = string : : npos )
{
inventoryIndex = InventoryIndexes [ i ] ;
break ;
}
}
// and compress the slotId
return ( inventoryIndex < < CItemInfos : : SlotIdIndexBitSize ) + slotIndex ;
}
// ***************************************************************************
uint CInventoryManager : : getItemSheetForSlotId ( uint slotId ) const
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
// for all inventories
for ( uint i = 0 ; i < NumInventories ; i + + )
{
if ( InventoryIndexes [ i ] = = ( slotId > > CItemInfos : : SlotIdIndexBitSize ) )
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * node = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( toString ( " SERVER:%s:%d:SHEET " , InventoryDBs [ i ] . c_str ( ) , ( slotId & CItemInfos : : SlotIdIndexBitMask ) ) , false ) ;
2010-05-06 00:08:41 +00:00
if ( node )
return node - > getValue32 ( ) ;
else
return 0 ;
}
}
return 0 ;
}
// ***************************************************************************
const CClientItemInfo & CInventoryManager : : getItemInfo ( uint slotId ) const
{
TItemInfoMap : : const_iterator it = _ItemInfoMap . find ( slotId ) ;
static CClientItemInfo empty ;
if ( it = = _ItemInfoMap . end ( ) )
return empty ;
else
return it - > second ;
}
// ***************************************************************************
bool CInventoryManager : : isItemInfoUpToDate ( uint slotId )
{
// true if the version already matches
return getItemInfo ( slotId ) . InfoVersionFromMsg = = getItemInfo ( slotId ) . InfoVersionFromSlot ;
}
// ***************************************************************************
void CInventoryManager : : addItemInfoWaiter ( IItemInfoWaiter * waiter )
{
if ( ! waiter )
return ;
// first remove the waiter if already here
removeItemInfoWaiter ( waiter ) ;
// Then push_front (stack)
_ItemInfoWaiters . push_front ( waiter ) ;
// update server msg
updateItemInfoQueue ( ) ;
}
// ***************************************************************************
void CInventoryManager : : removeItemInfoWaiter ( IItemInfoWaiter * waiter )
{
TItemInfoWaiters : : iterator it ;
for ( it = _ItemInfoWaiters . begin ( ) ; it ! = _ItemInfoWaiters . end ( ) ; it + + )
{
if ( waiter = = * it )
{
_ItemInfoWaiters . erase ( it ) ;
break ;
}
}
}
// ***************************************************************************
void CInventoryManager : : updateItemInfoWaiters ( uint itemSlotId )
{
// First verify if the versions matches. If differ, no need to update waiters since not good.
if ( getItemInfo ( itemSlotId ) . InfoVersionFromMsg ! = getItemInfo ( itemSlotId ) . InfoVersionFromSlot )
return ;
bool isItemFromTrading = ( itemSlotId > > CItemInfos : : SlotIdIndexBitSize ) = = INVENTORIES : : trading ;
// For all waiters that wait for this item slot
TItemInfoWaiters : : iterator it ;
for ( it = _ItemInfoWaiters . begin ( ) ; it ! = _ItemInfoWaiters . end ( ) ; )
{
TItemInfoWaiters : : iterator itNext = it ;
itNext + + ;
IItemInfoWaiter * waiter = * it ;
// callback. NB: only ig the waiter agree the Sheet in the current slot id
if ( waiter - > ItemSlotId = = itemSlotId & &
( isItemFromTrading | | waiter - > ItemSheet = = getItemSheetForSlotId ( itemSlotId ) ) )
{
waiter - > infoReceived ( ) ;
}
// in case it is erased in infoReceived()
it = itNext ;
}
}
// ***************************************************************************
void CInventoryManager : : CItemInfoSlotVersionObs : : update ( ICDBNode * node )
{
getInventory ( ) . onReceiveItemInfoSlotVersion ( node ) ;
}
// ***************************************************************************
void CInventoryManager : : CItemSheetObs : : update ( ICDBNode * node )
{
getInventory ( ) . onReceiveItemSheet ( node ) ;
}
// ***************************************************************************
void CInventoryManager : : CItemInfoTradeObs : : update ( ICDBNode * /* node */ )
{
getInventory ( ) . onTradeChangeSession ( ) ;
}
// ***************************************************************************
void CInventoryManager : : onReceiveItemInfoSlotVersion ( ICDBNode * node )
{
uint itemSlotId ;
// valid only if of form 0:INFO_VERSION
if ( ! dynamic_cast < CCDBNodeLeaf * > ( node ) | | ! node - > getParent ( ) | | ! node - > getParent ( ) - > getName ( ) )
return ;
// get the slot in inventory of the item
uint slot ;
fromString ( * node - > getParent ( ) - > getName ( ) , slot ) ;
// get the slotId for this DB
itemSlotId = getItemSlotId ( node - > getFullName ( ) , slot ) ;
// update the InfoVersionFromSlot
_ItemInfoMap [ itemSlotId ] . InfoVersionFromSlot = ( ( CCDBNodeLeaf * ) node ) - > getValue8 ( ) ;
// Look for Waiters that match this item slot => update
updateItemInfoWaiters ( itemSlotId ) ;
// new msg to send, because version updated?
updateItemInfoQueue ( ) ;
}
// ***************************************************************************
void CInventoryManager : : onReceiveItemSheet ( ICDBNode * node )
{
// When a SHEET change, it may unblock some ITEM_INFO:GET calls or some info waiters update.
uint itemSlotId ;
// valid only if of form 0:INFO_VERSION
if ( ! dynamic_cast < CCDBNodeLeaf * > ( node ) | | ! node - > getParent ( ) | | ! node - > getParent ( ) - > getName ( ) )
return ;
// get the slot in inventory of the item
uint slot ;
fromString ( * node - > getParent ( ) - > getName ( ) , slot ) ;
// get the slotId for this DB
itemSlotId = getItemSlotId ( node - > getFullName ( ) , slot ) ;
// Look for Waiters that match this item slot => update
updateItemInfoWaiters ( itemSlotId ) ;
// new msg to send, because sheet ok?
updateItemInfoQueue ( ) ;
}
// ***************************************************************************
void CInventoryManager : : onReceiveItemInfo ( const CItemInfos & itemInfo )
{
uint itemSlotId ;
// update the Info
itemSlotId = itemInfo . slotId ;
// write in map, from DB.
_ItemInfoMap [ itemSlotId ] . readFromImpulse ( itemInfo ) ;
// Look for Waiters that match this item slot => update
updateItemInfoWaiters ( itemSlotId ) ;
// new msg to send?
updateItemInfoQueue ( ) ;
}
// ***************************************************************************
void CInventoryManager : : onRefreshItemInfoVersion ( uint16 slotId , uint8 infoVersion )
{
_ItemInfoMap [ slotId ] . refreshInfoVersion ( infoVersion ) ;
}
// ***************************************************************************
void CInventoryManager : : onTradeChangeSession ( )
{
// Dummy set a 255 InfoVersionMsg for all items in trade. Because Server cannot do the code.
for ( uint i = 0 ; i < TRADE_MAX_ENTRIES ; i + + )
{
uint itemSlotId = getItemSlotId ( " TRADING " , i ) ;
// Since InfoVersionFromSlot always == 0, a msg will be sent to have new version
_ItemInfoMap [ itemSlotId ] . InfoVersionFromMsg = 255 ;
_ItemInfoMap [ itemSlotId ] . InfoVersionSlotServerWaiting = 255 ;
}
// new msg to send?
updateItemInfoQueue ( ) ;
}
// ***************************************************************************
void CInventoryManager : : updateItemInfoQueue ( )
{
// For All waiters, look if one need update.
TItemInfoWaiters : : iterator it ;
for ( it = _ItemInfoWaiters . begin ( ) ; it ! = _ItemInfoWaiters . end ( ) ; it + + )
{
/* \todo yoyo remove: temp patch to be sure that the client does not send messages before the
CONNECTION : READY is sent
*/
nlassert ( ConnectionReadySent ) ;
IItemInfoWaiter * waiter = * it ;
uint itemSlotId = waiter - > ItemSlotId ;
TItemInfoMap : : iterator it = _ItemInfoMap . find ( itemSlotId ) ;
bool isItemFromTrading = ( itemSlotId > > CItemInfos : : SlotIdIndexBitSize ) = = INVENTORIES : : trading ;
if ( it ! = _ItemInfoMap . end ( ) )
{
CClientItemInfo & itemInfo = it - > second ;
// If versions differ, and if a msg was not already sent to get the new version, then ask server
// SheetId must also match
if ( itemInfo . InfoVersionFromSlot ! = itemInfo . InfoVersionFromMsg & &
itemInfo . InfoVersionFromSlot ! = itemInfo . InfoVersionSlotServerWaiting & &
( isItemFromTrading | | waiter - > ItemSheet = = getItemSheetForSlotId ( itemSlotId ) ) )
{
// Send a msg to server
if ( ! ClientCfg . Local )
{
CBitMemStream out ;
if ( GenericMsgHeaderMngr . pushNameToStream ( " ITEM_INFO:GET " , out ) )
{
uint16 slotId = itemSlotId ;
out . serial ( slotId ) ;
NetMngr . push ( out ) ;
//nlinfo("impulseCallBack : ITEM_INFO:GET %d sent", slotId);
}
else
{
nlwarning ( " unknown message name 'ITEM_INFO:GET' " ) ;
}
}
// Debug
else
{
// debug:
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
pIM - > displaySystemInfo ( toString ( " ITEM_INFO:GET, slotId: %d, slotVersion: %d " ,
itemSlotId , itemInfo . InfoVersionFromSlot ) ) ;
}
itemInfo . InfoVersionSlotServerWaiting = itemInfo . InfoVersionFromSlot ;
}
}
}
}
// ***************************************************************************
void CInventoryManager : : debugItemInfoWaiters ( )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
// For All waiters, log.
TItemInfoWaiters : : iterator it ;
for ( it = _ItemInfoWaiters . begin ( ) ; it ! = _ItemInfoWaiters . end ( ) ; it + + )
{
IItemInfoWaiter * waiter = * it ;
uint itemSlotId = waiter - > ItemSlotId ;
TItemInfoMap : : iterator itMap = _ItemInfoMap . find ( itemSlotId ) ;
if ( itMap ! = _ItemInfoMap . end ( ) )
{
CClientItemInfo & itemInfo = itMap - > second ;
pIM - > displaySystemInfo ( toString ( " ItemInfoWaiter: slotId: %d, slotVersion: %d, msgVersion: %d, msgVersionWait: %d " ,
itemSlotId , itemInfo . InfoVersionFromSlot , itemInfo . InfoVersionFromMsg , itemInfo . InfoVersionSlotServerWaiting ) ) ;
}
}
}
// ***************************************************************************
void CInventoryManager : : sortBag ( )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
CDBGroupIconListBag * pIconList ;
CDBGroupListSheetBag * pList ;
2012-05-31 02:27:27 +00:00
pIconList = dynamic_cast < CDBGroupIconListBag * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( LIST_BAG_ICONS ) ) ;
2010-05-06 00:08:41 +00:00
if ( pIconList ! = NULL ) pIconList - > needToSort ( ) ;
2012-05-31 02:27:27 +00:00
pList = dynamic_cast < CDBGroupListSheetBag * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( LIST_BAG_TEXT ) ) ;
2010-05-06 00:08:41 +00:00
if ( pList ! = NULL ) pList - > needToSort ( ) ;
2012-05-31 02:27:27 +00:00
pIconList = dynamic_cast < CDBGroupIconListBag * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( LIST_ROOM_ICONS ) ) ;
2010-05-06 00:08:41 +00:00
if ( pIconList ! = NULL ) pIconList - > needToSort ( ) ;
2012-05-31 02:27:27 +00:00
pList = dynamic_cast < CDBGroupListSheetBag * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( LIST_ROOM_TEXT ) ) ;
2010-05-06 00:08:41 +00:00
if ( pList ! = NULL ) pList - > needToSort ( ) ;
2012-05-31 02:27:27 +00:00
pIconList = dynamic_cast < CDBGroupIconListBag * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( LIST_GUILD_ICONS ) ) ;
2010-05-06 00:08:41 +00:00
if ( pIconList ! = NULL ) pIconList - > needToSort ( ) ;
2012-05-31 02:27:27 +00:00
pList = dynamic_cast < CDBGroupListSheetBag * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( LIST_GUILD_TEXT ) ) ;
2010-05-06 00:08:41 +00:00
if ( pList ! = NULL ) pList - > needToSort ( ) ;
2012-05-31 02:27:27 +00:00
pIconList = dynamic_cast < CDBGroupIconListBag * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( LIST_PA0_ICONS ) ) ;
2010-05-06 00:08:41 +00:00
if ( pIconList ! = NULL ) pIconList - > needToSort ( ) ;
2012-05-31 02:27:27 +00:00
pList = dynamic_cast < CDBGroupListSheetBag * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( LIST_PA0_TEXT ) ) ;
2010-05-06 00:08:41 +00:00
if ( pList ! = NULL ) pList - > needToSort ( ) ;
2012-05-31 02:27:27 +00:00
pIconList = dynamic_cast < CDBGroupIconListBag * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( LIST_PA1_ICONS ) ) ;
2010-05-06 00:08:41 +00:00
if ( pIconList ! = NULL ) pIconList - > needToSort ( ) ;
2012-05-31 02:27:27 +00:00
pList = dynamic_cast < CDBGroupListSheetBag * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( LIST_PA1_TEXT ) ) ;
2010-05-06 00:08:41 +00:00
if ( pList ! = NULL ) pList - > needToSort ( ) ;
2012-05-31 02:27:27 +00:00
pIconList = dynamic_cast < CDBGroupIconListBag * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( LIST_PA2_ICONS ) ) ;
2010-05-06 00:08:41 +00:00
if ( pIconList ! = NULL ) pIconList - > needToSort ( ) ;
2012-05-31 02:27:27 +00:00
pList = dynamic_cast < CDBGroupListSheetBag * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( LIST_PA2_TEXT ) ) ;
2010-05-06 00:08:41 +00:00
if ( pList ! = NULL ) pList - > needToSort ( ) ;
2012-05-31 02:27:27 +00:00
pIconList = dynamic_cast < CDBGroupIconListBag * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( LIST_PA3_ICONS ) ) ;
2010-05-06 00:08:41 +00:00
if ( pIconList ! = NULL ) pIconList - > needToSort ( ) ;
2012-05-31 02:27:27 +00:00
pList = dynamic_cast < CDBGroupListSheetBag * > ( CWidgetManager : : getInstance ( ) - > getElementFromId ( LIST_PA3_TEXT ) ) ;
2010-05-06 00:08:41 +00:00
if ( pList ! = NULL ) pList - > needToSort ( ) ;
}
// ***************************************************************************
bool CInventoryManager : : isInventoryPresent ( INVENTORIES : : TInventory invId )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
// PA present?
if ( invId > = INVENTORIES : : pet_animal & & invId < INVENTORIES : : pet_animal + MAX_INVENTORY_ANIMAL )
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * node = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( toString ( " SERVER:PACK_ANIMAL:BEAST%d:STATUS " , invId - INVENTORIES : : pet_animal ) , false ) ;
2010-05-06 00:08:41 +00:00
if ( ! node ) return false ;
uint status = node - > getValue32 ( ) ;
return ANIMAL_STATUS : : isSpawned ( ( ANIMAL_STATUS : : EAnimalStatus ) status ) ;
}
else if ( invId = = INVENTORIES : : guild )
{
2012-05-24 03:02:24 +00:00
return ( NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " UI:TEMP:INVENTORY_GUILD_OPENED " , true ) - > getValue8 ( ) ! = 0 ) ;
2010-05-06 00:08:41 +00:00
}
else if ( invId = = INVENTORIES : : player_room )
{
2012-05-24 03:02:24 +00:00
return ( NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " UI:TEMP:INVENTORY_ROOM_OPENED " , true ) - > getValue8 ( ) ! = 0 ) ;
2010-05-06 00:08:41 +00:00
}
// other inventories (Bag...) are always present
else
return true ;
}
// ***************************************************************************
bool CInventoryManager : : isInventoryAvailable ( INVENTORIES : : TInventory invId )
{
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
// PA available?
if ( invId > = INVENTORIES : : pet_animal & & invId < INVENTORIES : : pet_animal + MAX_INVENTORY_ANIMAL )
{
2012-05-24 03:02:24 +00:00
CCDBNodeLeaf * node = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( toString ( " SERVER:PACK_ANIMAL:BEAST%d:STATUS " , invId - INVENTORIES : : pet_animal ) , false ) ;
2010-05-06 00:08:41 +00:00
if ( ! node ) return false ;
uint status = node - > getValue32 ( ) ;
return ANIMAL_STATUS : : isInventoryAvailable ( ( ANIMAL_STATUS : : EAnimalStatus ) status ) ;
}
else if ( invId = = INVENTORIES : : guild )
{
2012-05-24 03:02:24 +00:00
return ( NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " UI:TEMP:INVENTORY_GUILD_OPENED " , true ) - > getValue8 ( ) ! = 0 ) ;
2010-05-06 00:08:41 +00:00
}
else if ( invId = = INVENTORIES : : player_room )
{
2012-05-24 03:02:24 +00:00
return ( NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( " UI:TEMP:INVENTORY_ROOM_OPENED " , true ) - > getValue8 ( ) ! = 0 ) ;
2010-05-06 00:08:41 +00:00
}
// other inventories (Bag...) are always available
else
return true ;
}
// ***************************************************************************
bool CInventoryManager : : isInventoryEmpty ( INVENTORIES : : TInventory invId )
{
if ( ! isInventoryPresent ( invId ) ) return true ;
CInterfaceManager * pIM = CInterfaceManager : : getInstance ( ) ;
string sPath = " SERVER:INVENTORY " ;
sint32 nNbEntries = 256 ;
// PA present?
if ( invId > = INVENTORIES : : pet_animal & & invId < INVENTORIES : : pet_animal + MAX_INVENTORY_ANIMAL )
{
nNbEntries = MAX_ANIMALINV_ENTRIES ;
sPath + = toString ( " :PACK_ANIMAL%d " , invId - INVENTORIES : : pet_animal ) ;
}
else if ( invId = = INVENTORIES : : guild )
{
nNbEntries = MAX_GUILDINV_ENTRIES ;
sPath + = " GUILD " ;
}
else if ( invId = = INVENTORIES : : player_room )
{
nNbEntries = MAX_ROOMINV_ENTRIES ;
sPath + = " ROOM " ;
}
else
return true ;
for ( uint32 i = 0 ; ( sint ) i < nNbEntries ; + + i )
{
CCDBNodeLeaf * pNL ;
2012-05-24 03:02:24 +00:00
pNL = NLGUI : : CDBManager : : getInstance ( ) - > getDbProp ( sPath + toString ( " :%d:SHEET " , i ) , false ) ;
2010-05-06 00:08:41 +00:00
if ( pNL = = NULL ) return true ;
if ( pNL - > getValue32 ( ) ! = 0 )
return false ;
}
return true ;
}
// ***************************************************************************
CItemImage & CInventoryManager : : getPAItem ( uint beastIndex , uint index )
{
nlassert ( beastIndex < MAX_INVENTORY_ANIMAL ) ;
nlassert ( index < MAX_ANIMALINV_ENTRIES ) ;
return PAInv [ beastIndex ] [ index ] ;
}
// ***************************************************************************
CItemImage & CInventoryManager : : getServerPAItem ( uint beastIndex , uint index )
{
nlassert ( beastIndex < MAX_INVENTORY_ANIMAL ) ;
nlassert ( index < MAX_ANIMALINV_ENTRIES ) ;
return ServerPAInv [ beastIndex ] [ index ] ;
}
// ***************************************************************************
CItemImage & CInventoryManager : : getLocalItem ( uint inv , uint index )
{
if ( inv = = INVENTORIES : : bag )
return getBagItem ( index ) ;
if ( inv > = INVENTORIES : : pet_animal & & inv < INVENTORIES : : pet_animal + MAX_INVENTORY_ANIMAL )
return getPAItem ( inv - INVENTORIES : : pet_animal , index ) ;
nlstop ;
static CItemImage dummy ;
return dummy ;
}
// ***************************************************************************
CItemImage & CInventoryManager : : getServerItem ( uint inv , uint index )
{
if ( inv = = INVENTORIES : : bag )
return getServerBagItem ( index ) ;
if ( inv > = INVENTORIES : : pet_animal & & inv < INVENTORIES : : pet_animal + MAX_INVENTORY_ANIMAL )
return getServerPAItem ( inv - INVENTORIES : : pet_animal , index ) ;
nlstop ;
static CItemImage dummy ;
return dummy ;
}
// ***************************************************************************
CInventoryManager : : TInvType CInventoryManager : : invTypeFromString ( const string & str )
{
string sTmp = strlwr ( str ) ;
if ( sTmp = = " inv_bag " ) return InvBag ;
if ( sTmp = = " inv_pa0 " ) return InvPA0 ;
if ( sTmp = = " inv_pa1 " ) return InvPA1 ;
if ( sTmp = = " inv_pa2 " ) return InvPA2 ;
if ( sTmp = = " inv_pa3 " ) return InvPA3 ;
if ( sTmp = = " inv_guild " ) return InvGuild ;
if ( sTmp = = " inv_room " ) return InvRoom ;
return InvUnknown ;
}