// Copyright (C) 2007 Id Software, Inc.
//

#include "../precompiled.h"
#pragma hdrstop

#if defined( _DEBUG ) && !defined( ID_REDIRECT_NEWDELETE )
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#include "Inventory.h"

#include "../decls/DeclInvItem.h"
#include "../Player.h"
#include "../Weapon.h"
#include "../script/Script_Helper.h"
#include "../script/Script_ScriptObject.h"
#include "../proficiency/StatsTracker.h"

#include "../botai/BotThreadData.h"

/*
===============================================================================

	sdItemPoolEntry

===============================================================================
*/

/*
==============
sdItemPoolEntry::sdItemPoolEntry
==============
*/
sdItemPoolEntry::sdItemPoolEntry( void ) {
	flags.disabled	= false;
	flags.hidden	= false;
	item			= NULL;
	joint			= INVALID_JOINT;
}

/*
==============
sdItemPoolEntry::SetItem
==============
*/
void sdItemPoolEntry::SetItem( const sdDeclInvItem* _item ) {
	item = _item;

	if ( item ) {
		for ( int j = 0; j < item->GetClips().Num(); j++ ) {
			clips.Alloc() = -1;
		}
	} else {
		clips.SetNum( 0, false );
	}
}

/*
===============================================================================

	sdPlayerClassSetup

===============================================================================
*/

/*
==============
sdPlayerClassSetup::sdPlayerClassSetup
==============
*/
sdPlayerClassSetup::sdPlayerClassSetup( void ) : playerClass( NULL ) {
}

/*
==============
sdPlayerClassSetup::operator=
==============
*/
void sdPlayerClassSetup::operator=( const sdPlayerClassSetup& rhs ) {
	playerClass = rhs.playerClass;
	playerClassOptions.SetNum( rhs.playerClassOptions.Num(), false );
	for ( int i = 0; i < playerClassOptions.Num(); i++ ) {
		playerClassOptions[ i ] = rhs.playerClassOptions[ i ];
	}
}

/*
==============
sdPlayerClassSetup::SetOptions
==============
*/
void sdPlayerClassSetup::SetOptions( const idList< int >& options ) {
	if ( options.Num() != playerClassOptions.Num() ) {
		gameLocal.Warning( "sdPlayerClassSetup::SetOptions Number of options did not match" );
		return;
	}

	playerClassOptions = options;
}

/*
==============
sdPlayerClassSetup::SetClass
==============
*/
bool sdPlayerClassSetup::SetClass( const sdDeclPlayerClass* pc, bool force ) {
	if ( pc == playerClass && !force ) {
		return false;
	}

	playerClass = pc;
	if ( playerClass ) {
		playerClassOptions.Fill( playerClass->GetNumOptions(), 0 );
	} else {
		playerClassOptions.SetNum( 0, false );
	}

	return true;
}

/*
==============
sdPlayerClassSetup::SetOption
==============
*/
bool sdPlayerClassSetup::SetOption( int index, int itemIndex ) {
	if ( index < 0 || index >= playerClassOptions.Num() ) {
		return false;
	}

	if ( playerClassOptions[ index ] == itemIndex ) {
		return false;
	}

	playerClassOptions[ index ] = itemIndex;
	return true;
}


/*
============
sdPlayerClassSetup::GetOption
============
*/
int	sdPlayerClassSetup::GetOption( int index ) const {
	assert( index >= 0 && index < playerClassOptions.Num() );

	return playerClassOptions[ index ];
}

/*
===============================================================================

	sdUpgradeItemPool

===============================================================================
*/

/*
==============
sdUpgradeItemPool::OnHide
==============
*/
void sdUpgradeItemPool::OnHide( void ) {
	for ( int i = 0; i < modelItems.Num(); i++ ) {
		modelItems[ i ]->HideModel();
	}
	modelItems.SetNum( 0, false );
}

/*
==============
sdUpgradeItemPool::OnShow
==============
*/
void sdUpgradeItemPool::OnShow( void ) {
	for ( int i = 0; i < items.Num(); i++ ) {
		if ( !items[ i ].IsVisible() ) {
			continue;
		}
		ShowItem( items[ i ] );
	}
}

/*
==============
sdUpgradeItemPool::ShowItem
==============
*/
bool sdUpgradeItemPool::ShowItem( sdItemPoolEntry& item ) {
	if ( !item.GetModel().hModel ) {
		return false;
	}

	modelItems.AddUnique( &item );
	item.ShowModel();

	return true;
}

/*
==============
sdUpgradeItemPool::HideItem
==============
*/
void sdUpgradeItemPool::HideItem( sdItemPoolEntry& item ) {
	modelItems.RemoveFast( &item );
	item.HideModel();
}

/*
==============
sdUpgradeItemPool::AddItem
==============
*/
int sdUpgradeItemPool::AddItem( const sdDeclInvItem* item, bool enabled ) {
	sdItemPoolEntry& entry = items.Alloc();

	entry.SetItem( item );
	entry.SetDisabled( !enabled );

	idPlayer* player = parent->GetOwner();

	idRenderModel* model = item->GetModel();
	if ( model && enabled ) {
		renderEntity_t& entity = entry.GetModel();

		entity.spawnID						= gameLocal.GetSpawnId( player );//->entityNumber;
		entity.suppressSurfaceInViewID		= player->entityNumber + 1;
		entity.noSelfShadowInViewID			= player->entityNumber + 1;
		entity.axis.Identity();
		entity.origin.Zero();
		entity.hModel						= model;
		entity.bounds						= entity.hModel->Bounds( &entity );
		entity.maxVisDist					= item->GetData().GetInt( "maxVisDist", "2048" );

		SetupModelShadows( entry );
		ShowItem( entry );
	}

	entry.joint = player->GetAnimator()->GetJointHandle( item->GetJoint() );

	return items.Num() - 1;
}

/*
==============
sdUpgradeItemPool::ClearItem
==============
*/
void sdUpgradeItemPool::ClearItem( sdItemPoolEntry& entry ) {
	HideItem( entry );
	entry.SetItem( NULL );
}

/*
==============
sdUpgradeItemPool::Init
==============
*/
void sdUpgradeItemPool::Init( sdInventory* _parent ) {
	parent = _parent;
}

/*
==============
sdUpgradeItemPool::Clear
==============
*/
void sdUpgradeItemPool::Clear( void ) {
	for( int i = 0; i < items.Num(); i++ ) {
		ClearItem( items[ i ] );
	}
	items.Clear();
}

/*
==============
sdUpgradeItemPool::ApplyPlayerState
==============
*/
void sdUpgradeItemPool::ApplyPlayerState( const sdInventoryPlayerStateData& newState ) {
	NET_GET_NEW( sdInventoryPlayerStateData );

	for( int i = 0; i < items.Num(); i++ ) {
		sdItemPoolEntry& item = items[ i ];

		for ( int j = 0; j < item.clips.Num(); j++ ) {
			if ( item.GetItem()->GetClips()[ j ].maxAmmo <= 0 ) {
				continue;
			}

			item.clips[ j ] = newData.itemData[ i ].clips[ j ];
		}
	}
}

/*
==============
sdUpgradeItemPool::ReadPlayerState
==============
*/
void sdUpgradeItemPool::ReadPlayerState( const sdInventoryPlayerStateData& baseState, sdInventoryPlayerStateData& newState, const idBitMsg& msg ) const {
	NET_GET_STATES( sdInventoryPlayerStateData );

	newData.itemData.SetNum( items.Num() );

	for( int i = 0; i < items.Num(); i++ ) {
		const sdItemPoolEntry& item = items[ i ];

		newData.itemData[ i ].clips.SetNum( item.clips.Num() );

		for ( int j = 0; j < item.clips.Num(); j++ ) {
			if ( i < baseData.itemData.Num() && j < baseData.itemData[ i ].clips.Num() ) {
				newData.itemData[ i ].clips[ j ] = msg.ReadDeltaShort( baseData.itemData[ i ].clips[ j ] );
			} else {
				newData.itemData[ i ].clips[ j ] = msg.ReadShort();
			}
		}
	}
}

/*
==============
sdUpgradeItemPool::WritePlayerState
==============
*/
void sdUpgradeItemPool::WritePlayerState( const sdInventoryPlayerStateData& baseState, sdInventoryPlayerStateData& newState, idBitMsg& msg ) const {
	NET_GET_STATES( sdInventoryPlayerStateData );

	newData.itemData.SetNum( items.Num() );

	for( int i = 0; i < items.Num(); i++ ) {
		const sdItemPoolEntry& item = items[ i ];

		newData.itemData[ i ].clips.SetNum( item.clips.Num() );

		for ( int j = 0; j < item.clips.Num(); j++ ) {
			newData.itemData[ i ].clips[ j ] = item.clips[ j ];
			if ( i < baseData.itemData.Num() && j < baseData.itemData[ i ].clips.Num() ) {
				msg.WriteDeltaShort( baseData.itemData[ i ].clips[ j ], newData.itemData[ i ].clips[ j ] );
			} else {
				msg.WriteShort( newData.itemData[ i ].clips[ j ] );
			}
		}
	}
}

/*
==============
sdUpgradeItemPool::CheckPlayerStateChanges
==============
*/
bool sdUpgradeItemPool::CheckPlayerStateChanges( const sdInventoryPlayerStateData& baseState ) const {
	NET_GET_BASE( sdInventoryPlayerStateData );

	if ( baseData.itemData.Num() != items.Num() ) {
		return true;
	}


	for( int i = 0; i < items.Num(); i++ ) {
		const sdItemPoolEntry& item = items[ i ];

		if ( baseData.itemData[ i ].clips.Num() != item.clips.Num() ) {
			return true;
		}

		for ( int j = 0; j < item.clips.Num(); j++ ) {
			if ( baseData.itemData[ i ].clips[ j ] != item.clips[ j ] ) {
				return true;
			}
		}
	}

	return false;
}

/*
==============
sdUpgradeItemPool::UpdateJoints
==============
*/
void sdUpgradeItemPool::UpdateJoints( void ) {
	idPlayer* owner = parent->GetOwner();

	for( int i = 0; i < items.Num(); i++ ) {
		items[ i ].joint = owner->GetAnimator()->GetJointHandle( items[ i ].item->GetJoint() );
	}
}

/*
==============
sdUpgradeItemPool::UpdateModels
==============
*/
void sdUpgradeItemPool::UpdateModels( void ) {
	// no need to do this in reprediction
	if ( !gameLocal.isNewFrame ) {
		return;
	}

	idPlayer* owner = parent->GetOwner();

	for ( int i = 0; i < modelItems.Num(); i++ ) {
		sdItemPoolEntry& item = *modelItems[ i ];

		renderEntity_t& entity = item.GetModel();

		entity.customSkin = owner->GetRenderEntity()->customSkin;

		owner->GetWorldOriginAxisNoUpdate( item.joint, entity.origin, entity.axis );

		item.UpdateModel();
	}
}

/*
==============
sdUpgradeItemPool::~sdUpgradeItemPool
==============
*/
sdUpgradeItemPool::~sdUpgradeItemPool( void ) {
	Clear();
}

/*
==============
sdUpgradeItemPool::SetupModelShadows
==============
*/
void sdUpgradeItemPool::SetupModelShadows( sdItemPoolEntry& entry ) {
	idPlayer* owner = parent->GetOwner();

	renderEntity_t& renderEntity = entry.GetModel();

	viewState_t state = owner->HasShadow();
	switch ( state ) {
		case VS_NONE: {
			renderEntity.suppressShadowInViewID = 0;
			renderEntity.flags.noShadow			= true;
			break;
		}
		case VS_REMOTE: {
			renderEntity.suppressShadowInViewID = owner->entityNumber + 1;
			renderEntity.flags.noShadow			= false;
			break;
		}
		case VS_FULL: {
			renderEntity.suppressShadowInViewID = 0;
			renderEntity.flags.noShadow			= false;
			break;
		}
	}
}

/*
============
sdUpgradeItemPool::UpdateModelShadows
============
*/
void sdUpgradeItemPool::UpdateModelShadows( void ) {
	for ( int i = 0; i < modelItems.Num(); i++ ) {
		SetupModelShadows( *modelItems[ i ] );
	}
}

/*
===============================================================================

	sdInventory

===============================================================================
*/

idList< int > sdInventory::slotForBank;

/*
==============
sdInventoryBroadcastData::MakeDefault
==============
*/
void sdInventoryBroadcastData::MakeDefault( void ) {
	idealWeapon					= -1;
	disabledMask.Shutdown();
	ammoMask.Shutdown();

	proficiencyData.MakeDefault();
}

/*
==============
sdInventoryBroadcastData::Write
==============
*/
void sdInventoryBroadcastData::Write( idFile* file ) const {
	file->WriteInt( idealWeapon );

	file->WriteInt( disabledMask.GetSize() );
	for ( int i = 0; i < disabledMask.GetSize(); i++ ) {
		file->WriteInt( disabledMask.GetDirect( i ) );
	}

	file->WriteInt( ammoMask.GetSize() );
	for ( int i = 0; i < ammoMask.GetSize(); i++ ) {
		file->WriteInt( ammoMask.GetDirect( i ) );
	}

	proficiencyData.Write( file );
}

/*
==============
sdInventoryBroadcastData::Read
==============
*/
void sdInventoryBroadcastData::Read( idFile* file ) {
	file->ReadInt( idealWeapon );

	int sizeDummy;

	file->ReadInt( sizeDummy );
	disabledMask.SetSize( sizeDummy );
	for ( int i = 0; i < disabledMask.GetSize(); i++ ) {
		file->ReadInt( disabledMask.GetDirect( i ) );
	}

	file->ReadInt( sizeDummy );
	ammoMask.SetSize( sizeDummy );
	for ( int i = 0; i < ammoMask.GetSize(); i++ ) {
		file->ReadInt( ammoMask.GetDirect( i ) );
	}

	proficiencyData.Read( file );
}

/*
==============
sdInventoryPlayerStateData::MakeDefault
==============
*/
void sdInventoryPlayerStateData::MakeDefault( void ) {
	ammo.SetNum( gameLocal.declAmmoTypeType.Num() );
	for ( int i = 0; i < ammo.Num(); i++ ) {
		ammo[ i ] = 0;
	}
	itemData.SetNum( 0, false );
}

/*
==============
sdInventoryPlayerStateData::Write
==============
*/
void sdInventoryPlayerStateData::Write( idFile* file ) const {
	file->WriteInt( ammo.Num() );
	for ( int i = 0; i < ammo.Num(); i++ ) {
		file->WriteShort( ammo[ i ] );
	}

	file->WriteInt( itemData.Num() );
	for ( int i = 0; i < itemData.Num(); i++ ) {
		itemData[ i ].Write( file );
	}
}

/*
==============
sdInventoryPlayerStateData::Read
==============
*/
void sdInventoryPlayerStateData::Read( idFile* file ) {
	int count;
	file->ReadInt( count );

	assert( gameLocal.declAmmoTypeType.Num() == count );

	ammo.SetNum( count );
	for ( int i = 0; i < count; i++ ) {
		file->ReadShort( ammo[ i ] );
	}

	file->ReadInt( count );

	itemData.SetNum( count );
	for ( int i = 0; i < count; i++ ) {
		itemData[ i ].Read( file );
	}
}

/*
==============
sdInventoryItemStateData::MakeDefault
==============
*/
void sdInventoryItemStateData::MakeDefault( void ) {
	clips.SetNum( 0, false );
}

/*
==============
sdInventoryItemStateData::Write
==============
*/
void sdInventoryItemStateData::Write( idFile* file ) const {
	file->WriteInt( clips.Num() );
	for ( int i = 0; i < clips.Num(); i++ ) {
		file->WriteShort( clips[ i ] );
	}
}

/*
==============
sdInventoryItemStateData::Read
==============
*/
void sdInventoryItemStateData::Read( idFile* file ) {
	int count;
	file->ReadInt( count );

	clips.SetNum( count );
	for ( int i = 0; i < count; i++ ) {
		file->ReadShort( clips[ i ] );
	}
}

/*
==============
sdInventory::GetCommandMapIcon
==============
*/
const idMaterial* sdInventory::GetCommandMapIcon( const iconType_e iconType ) const {
	const sdDeclPlayerClass* pc = playerClass.GetClass();

	if ( !pc ) {
		return NULL;
	}

	switch( iconType ) {
		case IT_CLASS:
			return pc->GetCommandmapIconClass();
		case IT_ICON:
			return pc->GetCommandmapIcon();
		case IT_UNKNOWN:
			return pc->GetCommandmapIconUnknown();
	}

	return NULL;
}

/*
==============
sdInventory::UpdateItems
==============
*/
void sdInventory::UpdateItems( void ) {
	if ( classThread ) {
		if ( classThread->Execute() ) {
			ShutdownClassThread();
		}
	}
}

/*
==============
sdInventory::Present
==============
*/
void sdInventory::Present( void ) {
	items.UpdateModels();
}


/*
==============
sdInventory::Init
==============
*/
void sdInventory::Init( idDict& dict, bool full, bool setWeapon ) {
	ammo.AssureSize( gameLocal.declAmmoTypeType.Num(), 0 );
	ammoLimits.AssureSize( gameLocal.declAmmoTypeType.Num(), 0 );

	ClearAmmo();
	items.Clear();

	currentWeapon	= -1;
	if ( !gameLocal.isClient ) {
		idealWeapon		= -1;
	}
	switchingWeapon	= -1;

	if ( !gameLocal.isClient ) {
		CheckPlayerClass( setWeapon );
	}
	SetupClassOptions( true, setWeapon );

	SetupModel();

	LogClassTime();
}

/*
==============
sdInventory::WriteDemoBaseData
==============
*/
void sdInventory::WriteDemoBaseData( idFile* file ) const {
	int playerClassIndex = playerClass.GetClass() ? playerClass.GetClass()->Index() : -1;

	file->WriteInt( playerClassIndex );
	if ( playerClassIndex != -1 ) {
		for ( int i = 0; i < playerClass.GetOptions().Num(); i++ ) {
			file->WriteInt( playerClass.GetOptions()[ i ] );
		}
	}

	int cachedPlayerClassIndex = cachedPlayerClass.GetClass() ? cachedPlayerClass.GetClass()->Index() : -1;

	file->WriteInt( cachedPlayerClassIndex );
	if ( cachedPlayerClassIndex != -1 ) {
		for ( int i = 0; i < cachedPlayerClass.GetOptions().Num(); i++ ) {
			file->WriteInt( cachedPlayerClass.GetOptions()[ i ] );
		}
	}
}

/*
==============
sdInventory::ReadDemoBaseData
==============
*/
void sdInventory::ReadDemoBaseData( idFile* file ) {
	int playerClassIndex;

	file->ReadInt( playerClassIndex );
	if ( playerClassIndex != -1 ) {
		const sdDeclPlayerClass* cls = gameLocal.declPlayerClassType[ playerClassIndex ];

		SetPlayerClass( cls );

		for ( int i = 0; i < playerClass.GetOptions().Num(); i++ ) {
			int itemIndex;

			file->ReadInt( itemIndex );
			playerClass.SetOption( i, itemIndex );
		}
	}

	int cachedPlayerClassIndex;

	file->ReadInt( cachedPlayerClassIndex );
	if ( cachedPlayerClassIndex != -1 ) {
		const sdDeclPlayerClass* cls = gameLocal.declPlayerClassType[ cachedPlayerClassIndex ];
		cachedPlayerClass.SetClass( cls, true );

		for ( int i = 0; i < cachedPlayerClass.GetOptions().Num(); i++ ) {
			int itemIndex;

			file->ReadInt( itemIndex );
			cachedPlayerClass.SetOption( i, itemIndex );
		}
	}

	SetupClassOptions( true, false );
}

/*
==============
sdInventory::sdInventory
==============
*/
sdInventory::sdInventory( void ) {
	weaponChanged		= false;
	classThread			= NULL;
	timeClassChanged	= 0;
	currentWeaponIndex	= -1;
	idealWeapon			= -1;


	SetOwner( NULL );

	items.Init( this );
}

/*
==============
sdInventory::SetOwner
==============
*/
void sdInventory::SetOwner( idPlayer* _owner ) {
	owner = _owner;
}

/*
==============
sdInventory::GetOwner
==============
*/
idPlayer* sdInventory::GetOwner( void ) {
	return owner;
}

/*
==============
sdInventory::~sdInventory
==============
*/
sdInventory::~sdInventory( void ) {
}

/*
==============
sdInventory::GetAmmoFraction
==============
*/
float sdInventory::GetAmmoFraction( void ) {
	if ( !playerClass.GetClass() ) {
		return 0.f;
	}

	int max = 0;
	int ammoCount = 0;
	for ( int i = 0; i < ammo.Num(); i++ ) {
		ammoCount += ammo[ i ];
		max += ammoLimits[ i ];
	}

	return ammoCount / ( float )( max );
}

/*
==============
sdInventory::BuildSlotBankLookup
==============
*/
void sdInventory::BuildSlotBankLookup( void ) {
	slotForBank.Clear();

	const sdDeclStringMap* stringMap = gameLocal.declStringMapType.LocalFind( "inventorySlots" );
	const idDict& dict = stringMap->GetDict();

	int i = 0;
	while( true ) {
		//const sdDeclInvSlot* slot = gameLocal.declInvSlotType.LocalFindByIndex( i, true );
		const char* value = dict.GetString( va( "slot%i", i ) );
		i++;
		if( value[ 0 ] == '\0' ) {
			break;
		}
		const sdDeclInvSlot* slot = gameLocal.declInvSlotType.LocalFind( value, true );

		int slotBank = slot->GetBank();
		if( slotBank == -1 ) {
			continue;
		}

		slotForBank.AssureSize( slotBank + 1, -1 );

		if( slotForBank[ slotBank ] != -1 ) {
			gameLocal.Error( "sdInventory::BuildSlotBankLookup Multiple Slots Using Weapon Bank %i", slotBank );
		}

		slotForBank[ slotBank ] = slot->Index();		
	}
}

/*
==============
sdInventory::GetSlotForWeapon
==============
*/
int sdInventory::GetSlotForWeapon( int weapon ) const {
	if ( weapon >= 0 && weapon < items.Num() ) {
		if ( CanEquip( weapon, false ) ) {

			int count = slotForBank.Num();
			for ( int i = count - 1; i >= 0; i-- ) {
				int slot = slotForBank[ i ];
				if ( slot == -1 ) {
					continue;
				}

				if ( items[ weapon ].item->UsesSlot( slot ) ) {
					return i;
				}
			}
		}
	}
	return -1;
}

/*
==============
sdInventory::GetCurrentSlot
==============
*/
int sdInventory::GetCurrentSlot( void ) const {
	return GetSlotForWeapon( idealWeapon );
}

/*
==============
sdInventory::GetSwitchingSlot
==============
*/
int sdInventory::GetSwitchingSlot( void ) const {
	return GetSlotForWeapon( switchingWeapon );
}


/*
============
sdInventory::FindBestWeapon
============
*/
int sdInventory::FindBestWeapon( bool allowCurrent ) {
	int bestIndex = -1;
	int bestRank = 9999;

	for ( int i = 0; i < items.Num(); i++ ) {
		if ( !allowCurrent ) {
			if( ( i == switchingWeapon || i == currentWeapon ) ) {
				continue;
			}
		}

		if ( !CanAutoEquip( i, true ) ) {
			continue;
		}

		const sdDeclInvItem* item = items[ i ].item;

		int rank = item->GetAutoSwitchPriority();
		if ( rank < bestRank && rank > 0 && CheckWeaponHasAmmo( item ) ) {
			bestIndex = i;
			bestRank = rank;
		}
	}

	return bestIndex;
}

/*
============
sdInventory::CycleNextSafeWeapon
============
*/
void sdInventory::SelectBestWeapon( bool allowCurrent ) {	
	int bestIndex = FindBestWeapon( allowCurrent );
	if ( bestIndex != -1 ) {
		SetIdealWeapon( bestIndex );
	}
}

/*
============
sdInventory::CycleNextSafeWeapon
============
*/
void sdInventory::CycleNextSafeWeapon( void ) {	
	int bestIndex = FindBestWeapon( false );
	if ( bestIndex != -1 ) {
		SetSwitchingWeapon( bestIndex );
	}
}

/*
==============
sdInventory::CycleWeaponsNext
==============
*/
void sdInventory::CycleWeaponsNext( int currentSlot ) {
	bool force = true;
	bool looped;
	int weapon;

	if( currentSlot == -999 ) {
		force = false;
		currentSlot = ChooseCurrentSlot();
	}
	
	weapon = CycleWeaponByPosition( currentSlot, true, looped, false, false );

	if( !looped && weapon != -1 ) {
		SetSwitchingWeapon( weapon );
		return;
	}

	int cnt = 0;
	int max = slotForBank.Num();
	for( int i = currentSlot + 1; cnt < max; cnt++ ) {
		int pos = ( i + cnt ) % max;

		weapon = CycleWeaponByPosition( pos, true, looped, false, false );
		if( weapon != -1 ) {
			SetSwitchingWeapon( weapon );
			return;
		}
	}
}

/*
==============
sdInventory::CycleWeaponsPrev
==============
*/
void sdInventory::CycleWeaponsPrev( int currentSlot ) {
	bool force = true;
	bool looped;
	int weapon;

	if( currentSlot == -999 ) {
		force = false;
		currentSlot = ChooseCurrentSlot();
	}

	weapon = CycleWeaponByPosition( currentSlot, false, looped, false, false );
	if( !looped && weapon != -1 ) {
		SetSwitchingWeapon( weapon );
		return;
	}

	int cnt = 0;
	int max = slotForBank.Num();
	for( int i = currentSlot - 1; cnt < max; cnt++ ) {
		int pos = ( ( i - cnt ) + max ) % max;

		weapon = CycleWeaponByPosition( pos, false, looped, false, false );
		if( weapon != -1 ) {
			SetSwitchingWeapon( weapon );
			return;
		}
	}
}

/*
==============
sdInventory::CycleWeaponByPosition

if "primaryOnly" == true, it will only select the first weapon in that slot, never looping to any other weapon that
may share that slot.
==============
*/
int sdInventory::CycleWeaponByPosition( int pos, bool forward, bool& looped, bool force, bool primaryOnly ) {
	if( pos < 0 || pos >= slotForBank.Num() ) {
		return false;
	}

	int slot = slotForBank[ pos ];
	if( slot == -1 ) {
		return false;
	}

	int startpos = 0;

	if ( !primaryOnly ) {
        if( ( ChooseCurrentSlot() == pos ) ) {
			if( switchingWeapon >= 0 ) {
				startpos = switchingWeapon;
			} else if( idealWeapon >= 0 ) {
				startpos = idealWeapon;
			} else {
				startpos = currentWeapon;
			}
		}
	}

	return CycleWeaponBySlot( slot, forward, looped, force, startpos );
}

/*
==============
sdInventory::UpdatePrimaryWeapon
==============
*/
void sdInventory::UpdatePrimaryWeapon( void ) {
    for ( int i = 0; i < items.Num(); i++ ) {
		
		const sdDeclInvItem* item = items[ i ].GetItem();
	
		if ( item == NULL || !item->UsesSlot( slotForBank[ GUN_SLOT ] ) ) {
			continue;
		}

		if ( !CanEquip( i, true ) ) {
			continue;
		}

		int weaponNum = item->GetData().GetInt( "player_weapon_num", "-1" );

		if ( weaponNum != 14 && weaponNum != -1 ) { //mal_FIXME: 14 = hack for the AR/Grenade Launcher combo. Need to fix this!
			botThreadData.GetGameWorldState()->clientInfo[ owner->entityNumber ].weapInfo.primaryWeapon = ( playerWeaponTypes_t ) weaponNum;
			break;
		}
	}
}

/*
==============
sdInventory::CheckWeaponSlotHasAmmo
==============
*/
bool sdInventory::CheckWeaponSlotHasAmmo( int slot ) {
	bool hasAmmo = false;
	int i, ammoInClip, clipSize;

	clientInfo_t &client = botThreadData.GetGameWorldState()->clientInfo[ owner->entityNumber ];

    for ( i = 0; i < items.Num(); i++ ) {
		
		const sdDeclInvItem* item = items[ i ].GetItem();
	
		if ( item == NULL || !item->UsesSlot( slotForBank[ slot ] ) ) {
			continue;
		}

		if ( !CanEquip( i, true ) ) {
			continue;
		}

		if ( CheckWeaponHasAmmo( item ) ) {
			hasAmmo = true;

			if ( slot == GUN_SLOT ) { //mal: if this is our primary gun we're checking, see if it needs ammo.
				const idList< itemClip_t >& itemClips = item->GetClips();
				int ammoFraction;
				int maxAmmo, curAmmo;

				if ( !itemClips.Num() ) {
					break;
				}

				if ( client.team == GDF ) {
					if ( client.classType == SOLDIER && client.weapInfo.primaryWeapon == SMG ) {
                        ammoFraction = 4; //mal: GDF soldiers with assault rifle get as much ammo as strogg!
					} else {
						ammoFraction = 2;
					}
				} else {
					if ( client.weapInfo.primaryWeapon == ROCKET ) {
						ammoFraction = 2;
					} else {
						ammoFraction = 4; //mal: non-rocket launcher strogg have SO much more ammo then GDF.
					}
				}

				maxAmmo = GetMaxAmmo( itemClips[ MAIN_GUN ].ammoType );
				curAmmo = GetAmmo( itemClips[ MAIN_GUN ].ammoType );

//mal: while we're here, lets check if our primary weapon needs a reload, so we can use all of the stuff we've already calc'd
				if ( client.team == STROGG && client.weapInfo.primaryWeapon != ROCKET ) {
					client.weapInfo.primaryWeapNeedsReload = false;
					client.weapInfo.primaryWeapClipEmpty = false;
				} else {
					ammoInClip = GetClip( i, MAIN_GUN );
					clipSize = GetClipSize( i, MAIN_GUN );

					if ( ammoInClip == 0 || ammoInClip < clipSize ) {
						client.weapInfo.primaryWeapNeedsReload = true;
					} else {
						client.weapInfo.primaryWeapNeedsReload = false;
					}

					if ( ammoInClip == 0 ) {
						client.weapInfo.primaryWeapClipEmpty = true;
					} else {
						client.weapInfo.primaryWeapClipEmpty = false;
					}

					if ( curAmmo > clipSize ) {
						client.weapInfo.hasAmmoForReload = true;
					} else {
						client.weapInfo.hasAmmoForReload = false;
					}
				}

				if ( ( maxAmmo / ammoFraction ) > curAmmo ) {
					botThreadData.GetGameWorldState()->clientInfo[ owner->entityNumber ].weapInfo.primaryWeapNeedsAmmo = true;
				} else {
					botThreadData.GetGameWorldState()->clientInfo[ owner->entityNumber ].weapInfo.primaryWeapNeedsAmmo = false;
				}
			}
			break;
		}
	}

	return hasAmmo;
}

/*
==============
sdInventory::CyleWeaponBySlot
==============
*/
int sdInventory::CycleWeaponBySlot( int slot, bool forward, bool& looped, bool force, int startingpos ) {
	looped = false;

	int i = startingpos;// + ( forward ? 1 : -1 );
	int j;
	int max = items.Num();

	for( j = 0; j < max; j++ ) {
		if( forward ) {
			i++;
			if( i >= max ) { looped = true;	i -= max;}
		} else {
			i--;
			if( i < 0 ) { looped = true; i += max; }
		}

//		if ( !force ) {
//
//			if( /*!looped && */( i == switchingWeapon || i == currentWeapon )) {
//				continue;
//			}
//		}

		if ( !CanAutoEquip( i, false ) ) {
			continue;
		}

		const sdDeclInvItem* item = items[ i ].item;
		if ( !item->UsesSlot( slot ) ) {
			continue;
		}

		if ( !item->GetSelectWhenEmpty() && !CheckWeaponHasAmmo( item )) {
			continue;
		}

		return i;
	}

	return -1;
}

/*
==============
sdInventory::SelectWeaponByName
==============
*/
void sdInventory::SelectWeaponByName( const char* weaponName, bool ignoreInhibit ) {
	if ( !ignoreInhibit  ) {
		if ( owner->InhibitWeaponSwitch() ) {
			return;
		}
	}

	int weaponIndex = FindWeapon( weaponName );
	if ( weaponIndex == -1 ) {
		return;
	}

	if ( !CanEquip( weaponIndex, true ) ) {
		return;
	}

	SetIdealWeapon( weaponIndex );
}

/*
==============
sdInventory::SelectWeaponByNumber
==============
*/
void sdInventory::SelectWeaponByNumber( const playerWeaponTypes_t weaponNum ) {
	if ( owner->InhibitWeaponSwitch() ) {
		return;
	}

	int weaponIndex = FindWeaponNum( weaponNum );
	if ( weaponIndex == -1 ) {
		return;
	}

	if ( !CanEquip( weaponIndex, true ) ) {
		return;
	}

	SetIdealWeapon( weaponIndex );
}

/*
==============
sdInventory::CanEquip
==============
*/
bool sdInventory::CanEquip( int index, bool checkRequirements ) const {
	if ( index < 0 || index >= items.Num() ) {
		return false;
	}

	const sdDeclInvItem* item = items[ index ].item;
	if ( item == NULL ) {
		assert( false );
		return false;
	}

	if ( items[ index ].IsDisabled() ) {
		return false;
	}

	if ( owner->GetProxyEntity() != NULL ) {
		if( !item->GetType()->IsVehicleEquipable() ) {
			return false;
		}
	} else {
		if( !item->GetType()->IsEquipable() ) {
			return false;
		}
	}

	if ( checkRequirements ) {
		if ( !item->GetUsageRequirements().Check( owner ) ) {
			return false;
		}
	}

	return true;
}

/*
==============
sdInventory::CanAutoEquip
==============
*/
bool sdInventory::CanAutoEquip( int index, bool checkExplosive ) const {
	if ( !CanEquip( index, true ) ) {
		return false;
	}

	const sdDeclInvItem* item = items[ index ].item;
	if ( item->GetWeaponMenuIgnore() ) {
		return false;
	}

	if ( checkExplosive ) {
		if ( item->GetAutoSwitchIsExplosive() && owner->userInfo.ignoreExplosiveWeapons ) {
			return false;
		}
	}

	return true;
}

/*
==============
sdInventory::FindWeapon
==============
*/
int sdInventory::FindWeapon( const char* weaponName ) {
	for( int i = 0; i < items.Num(); i++ ) {
		if ( !CanEquip( i, true ) ) {
			continue;
		}

		const sdDeclInvItem* item = items[ i ].item;
		if ( !idStr::Icmp( item->GetName(), weaponName ) ) {
			return i;
		}
	}
	return -1;
}

/*
==============
sdInventory::FindWeaponNum

A handy function that lets the player pick a specific weapon, without cycling thru the slots.
==============
*/
int sdInventory::FindWeaponNum( const playerWeaponTypes_t weaponNum ) {
	for( int i = 0; i < items.Num(); i++ ) {
		if ( !CanEquip( i, true ) ) {
			continue;
		}

		const sdDeclInvItem* weapItem = items[ i ].item;

		if ( weapItem->GetData().GetInt( "player_weapon_num", "-1" ) == weaponNum ) {
			return i;
		}
	}
	return -1;
}

/*
==============
sdInventory::SetIdealWeapon
==============
*/
void sdInventory::SetIdealWeapon( int pos, bool force ) {
	if ( pos < -1 || pos >= items.Num() ) {
		return;
	}

	bool set = force || pos == -1;
	if ( !set ) {
		if ( pos == currentWeapon ) {
			set = items[ pos ].item->Index() != currentWeaponIndex;
		} else if ( pos != idealWeapon ) {
			set = true;
		}
	}

	if ( set ) {
		idealWeapon = pos;
		weaponChanged = true;

		if ( pos != -1 ) {		
			currentWeaponIndex = items[ pos ].item->Index();
			owner->SpawnToolTip( items[ pos ].item->GetToolTip() );
		} else {
			currentWeaponIndex = -1;
		}
	}

	CancelWeaponSwitch();
}

/*
==============
sdInventory::GetClip
==============
*/
int	sdInventory::GetClip( int index, int modIndex ) const {
	if ( index >= items.Num() || modIndex >= items[ index ].clips.Num() ) {
		return 0;
	}
	return items[ index ].clips[ modIndex ];
}


/*
============
sdInventory::GetClipSize
============
*/
int	sdInventory::GetClipSize( int index, int modIndex ) const {
	if ( index >= items.Num() || modIndex >= items[ index ].clips.Num() ) {
		return 0;
	}
	return items[ index ].GetItem()->GetClips()[ modIndex ].maxAmmo;
}

/*
==============
sdInventory::SetClip
==============
*/
void sdInventory::SetClip( int index, int modIndex, int count ) {
	if ( index >= items.Num() || modIndex >= items[ index ].clips.Num() ) {
		return;
	}
	items[ index ].clips[ modIndex ] = count;
}

/*
==============
sdInventory::IsWeaponValid
==============
*/
bool sdInventory::IsWeaponValid( int weapon ) const {
	if ( weapon < 0 || weapon >= items.Num() ) {
		return false;
	}

	return CanEquip( weapon, false );
}

/*
==============
sdInventory::IsWeaponBankValid
0-based weapon bank (0 is fists, 1 is pistol, etc)
==============
*/
bool sdInventory::IsWeaponBankValid( int slot ) const {
	if( slot < 0 || slot >= slotForBank.Num() ) {
		return false;
	}
	
	bool allValid = false;
	for ( int i = 0; i < items.Num(); i++ ) {
		if ( !CanEquip( i, true ) ) {
			continue;
		}

		const sdDeclInvItem* item = items[ i ].GetItem();
		if ( !item->UsesSlot( slotForBank[ slot ] )) {
			continue;
		}

		if ( CheckWeaponHasAmmo( item ) || item->GetSelectWhenEmpty() ) {
			allValid = true;
			break;
		}
	}

	return allValid;
}


/*
============
sdInventory::NumValidWeaponBanks
============
*/
int sdInventory::NumValidWeaponBanks() const {
	int numValid = 0;
	int max = slotForBank.Num();
	for( int i = 0; i < max; i++ ) {
		if( IsWeaponBankValid( i )) {
			numValid++;
		}
	}

	return numValid;
}

/*
==============
sdInventory::GetActivePlayer
==============
*/
idPlayer* sdInventory::GetActivePlayer( void ) const {
	idPlayer* modelPlayer = NULL;

	int disguiseClient = owner->GetDisguiseClient();
	if ( disguiseClient != -1 ) {
		modelPlayer = gameLocal.EntityForSpawnId( disguiseClient )->Cast< idPlayer >();
	}
	if ( modelPlayer == NULL ) {
		modelPlayer = owner;
	}
	return modelPlayer;
}

/*
==============
sdInventory::GetActivePlayerClass
==============
*/
const sdDeclPlayerClass* sdInventory::GetActivePlayerClass( void ) const {
	if ( owner->IsDisguised() ) {
		return owner->GetDisguiseClass();
	}
	return playerClass.GetClass();
}

/*
==============
sdInventory::SetupModel
==============
*/
void sdInventory::SetupModel( void ) {
	SetupModel( GetActivePlayerClass() );
}

/*
==============
sdInventory::GetPlayerJoint
==============
*/
jointHandle_t sdInventory::GetPlayerJoint( const idDict& dict, const char* name ) {
	const char* value = dict.GetString( name );
	jointHandle_t handle = owner->GetAnimator()->GetJointHandle( value );
	if ( handle == INVALID_JOINT ) {
		gameLocal.Error( "sdInventory::GetPlayerJoint '%s' not found for '%s' on '%s'", value, name, owner->name.c_str() );
	}
	return handle;
}

/*
==============
sdInventory::SkinForClass
==============
*/
const idDeclSkin* sdInventory::SkinForClass( const sdDeclPlayerClass* cls ) {
	if ( gameLocal.mapSkinPool != NULL ) {
		const char* skinKey = cls->GetClimateSkinKey();
		if ( *skinKey != '\0' ) {
			const char* skinName = gameLocal.mapSkinPool->GetDict().GetString( va( "skin_%s", skinKey ) );
			if ( *skinName == '\0' ) {
				gameLocal.Warning( "sdInventory::SetupModel No Skin Set For '%s'", skinKey );
			} else {
				const idDeclSkin* skin = gameLocal.declSkinType[ skinName ];
				if ( skin == NULL ) {
					gameLocal.Warning( "sdScriptEntity::Spawn Skin '%s' Not Found", skinName );
				} else {
					return skin;
				}
			}
		}
	}

	return NULL;
}

/*
==============
sdInventory::SetupModel
==============
*/
void sdInventory::SetupModel( const sdDeclPlayerClass* cls ) {
	owner->SetSkin( NULL );

	if ( cls == NULL ) {
		owner->SetModel( "" );
		owner->UpdateShadows();
		owner->SetHipJoint( INVALID_JOINT );
		owner->SetTorsoJoint( INVALID_JOINT );
		owner->SetHeadJoint( INVALID_JOINT );

		items.UpdateJoints();

		return;
	}

	if( !cls->GetModel() ) {
		gameLocal.Error( "sdInventory::SetupModel NULL model for class '%s'", cls->GetName() );
	}

	const idDict& dict = cls->GetModelData();
	
	owner->SetModel( cls->GetModel()->GetName() );
	owner->UpdateShadows();

	const idDeclSkin* skin = SkinForClass( cls );
	if ( skin != NULL ) {
		owner->SetSkin( skin );
	}

	owner->SetHipJoint( GetPlayerJoint( dict, "bone_hips" ) );
	owner->SetHeadJoint( GetPlayerJoint( dict, "bone_head" ) );
	owner->SetChestJoint( GetPlayerJoint( dict, "bone_chest" ) );
	owner->SetTorsoJoint( GetPlayerJoint( dict, "bone_torso" ) );
	owner->SetShoulderJoint( 0, GetPlayerJoint( dict, "bone_left_shoulder" ) );
	owner->SetElbowJoint( 0, GetPlayerJoint( dict, "bone_left_elbow" ) );
	owner->SetHandJoint( 0, GetPlayerJoint( dict, "bone_left_hand" ) );
	owner->SetFootJoint( 0, GetPlayerJoint( dict, "bone_left_foot" ) );
	owner->SetShoulderJoint( 1, GetPlayerJoint( dict, "bone_right_shoulder" ) );
	owner->SetElbowJoint( 1, GetPlayerJoint( dict, "bone_right_elbow" ) );
	owner->SetHandJoint( 1, GetPlayerJoint( dict, "bone_right_hand" ) );
	owner->SetFootJoint( 1, GetPlayerJoint( dict, "bone_right_foot" ) );

	owner->SetHeadModelJoint( GetPlayerJoint( dict, "bone_head_model" ) );
	owner->SetHeadModelOffset( dict.GetVector( "head_offset" ) );

	SetupLocationalDamage( dict );

	sdScriptHelper h;
	owner->CallNonBlockingScriptEvent( owner->GetScriptFunction( "OnNewModel" ), h );

	items.UpdateJoints();
}

/*
============
sdInventory::SetupLocationalDamage
============
*/
void sdInventory::SetupLocationalDamage( const idDict& dict ) {
	owner->RemoveLocationalDamageInfo();

	locationalDamageInfo_t info;
	int	numLocationDamageJoints = dict.GetInt( "loc_damage_joint_num", "6" );
	for( int i = 0; i < numLocationDamageJoints; i++ ) {
		const char* jointName = dict.GetString( va( "loc_damage_joint_%d", i ), "" );
		info.joint = owner->GetAnimator()->GetJointHandle( jointName );
		if( info.joint == INVALID_JOINT ) {
			gameLocal.Warning( "Invalid locational damage joint %d", i );
			continue;
		}
		
		if( !owner->GetAnimator()->GetJointTransform( info.joint, gameLocal.time, info.pos ) ) {
			gameLocal.Warning( "Invalid local transform for locational damage joint %d", i );
			continue;
		}

		info.area = owner->LocationalDamageAreaForString( dict.GetString( va( "loc_damage_area_%d", i ), "" ) );
		if( info.area == LDA_INVALID ) {
			gameLocal.Warning( "Invalid locational damage area for joint %d", i );
			continue;
		}

//		gameLocal.Printf( "Adding jointPos: ( %.0f %.0f %.0f )\n", info.pos.x, info.pos.y, info.pos.z );
		owner->AddLocationalDamageInfo( info );
	}
}

/*
==============
sdInventory::CheckPlayerClass
==============
*/
void sdInventory::CheckPlayerClass( bool setWeapon ) {
	sdTeamInfo* team = owner->GetTeam();
	if ( !team ) {
		return;
	}

	const sdDeclPlayerClass* newClass = playerClass.GetClass();

	sdPlayerClassSetup oldCachedClassSetup = cachedPlayerClass;

	if ( cachedPlayerClass.GetClass() ) {
		if ( cachedPlayerClass.GetClass()->GetTeam() == team ) {
			newClass = cachedPlayerClass.GetClass();
		}

		SetCachedClass( NULL );
	}

	if ( newClass ) {
		if ( newClass->GetTeam() != team ) {
			newClass = NULL;
		}
	}

	if ( !newClass ) {
		newClass = team->GetDefaultClass();
	}

	bool sendInfo = false;

	if ( newClass != playerClass.GetClass() ) {
		sendInfo |= GiveClass( newClass, false );
	}

	if ( oldCachedClassSetup.GetClass() == playerClass.GetClass() ) {
		playerClass.SetOptions( oldCachedClassSetup.GetOptions() );
	
		SetupClassOptions( true, setWeapon );

		sendInfo = true;
	}

	if ( sendInfo ) {
		SendClassInfo( false );
	}
}

/*
==============
sdInventory::IsIdealWeaponValid
==============
*/
bool sdInventory::IsIdealWeaponValid( void ) const {
	return IsWeaponValid( idealWeapon );
}

/*
==============
sdInventory::IsCurrentWeaponValid
==============
*/
bool sdInventory::IsCurrentWeaponValid( void ) const {
	return IsWeaponValid( currentWeapon );
}

/*
==============
sdInventory::GetCurrentItem
==============
*/
const sdDeclInvItem* sdInventory::GetCurrentItem( void ) const {
	if ( currentWeapon < 0 || currentWeapon >= items.Num() ) {
		return NULL;
	}

	if ( !CanEquip( currentWeapon, false ) ) {
		return NULL;
	}

	return items[ currentWeapon ].GetItem();
}

/*
==============
sdInventory::GetCurrentWeaponName
==============
*/
const char* sdInventory::GetCurrentWeaponName( void ) {
	const sdDeclInvItem* item = GetCurrentItem();

	if ( !item ) {
		return NULL;
	}

	return item->GetData().GetString( "anim_prefix" );
}

/*
==============
sdInventory::GetCurrentWeaponClass
==============
*/
const char* sdInventory::GetCurrentWeaponClass( void ) {
	const sdDeclInvItem* item = GetCurrentItem();

	if ( !item ) {
		return NULL;
	}

	return item->GetData().GetString( "anim_prefix_class" );
}

/*
==============
sdInventory::ClearAmmo
==============
*/
void sdInventory::ClearAmmo( void ) {
	for ( int i = 0; i < ammo.Num(); i++ ) {
		ammo[ i ]		= 0;
		ammoLimits[ i ] = 0;
	}
}

/*
==============
sdInventory::GiveClass
==============
*/
bool sdInventory::GiveClass( const sdDeclPlayerClass* cls, bool sendInfo ) {
	if ( gameLocal.isClient ) {
		assert( false );
		return false;
	}

 	if ( cls == NULL ) {
		gameLocal.Error( "sdInventory::GiveClass: NULL player class" );
		return false;
	}

	if ( cls->GetPackage() == NULL ) {
		gameLocal.Error( "sdInventory::GiveClass: NULL package on player class '%s'", cls->GetName() );
		return false;
	}

	const sdTeamInfo* otherTeam = cls->GetTeam();
	if ( otherTeam != NULL && otherTeam != owner->GetGameTeam() ) {
		return false;
	}

	if ( playerClass.GetClass() == cls ) {
		return false;
	}

	idEntity* proxy = owner->GetProxyEntity();
	if ( proxy != NULL ) {
		proxy->GetUsableInterface()->OnExit( owner, true );
	}

	SetPlayerClass( cls );
	SelectBestWeapon( true );

	if ( sendInfo ) {
		SendClassInfo( false );
	}

	return true;
}

/*
==============
sdInventory::SendClassInfo
==============
*/
void sdInventory::SendClassInfo( bool cached ) {
	if ( !gameLocal.isServer ) {
		return;
	}

	sdPlayerClassSetup& setup = cached ? cachedPlayerClass : playerClass;

	const sdDeclPlayerClass* cls = setup.GetClass();

	sdEntityBroadcastEvent msg( owner, cached ? idPlayer::EVENT_SETCACHEDCLASS : idPlayer::EVENT_SETCLASS );
	msg.WriteBits( cls ? cls->Index() + 1 : 0, gameLocal.GetNumPlayerClassBits() );
	if ( cls ) {
		for ( int i = 0; i < cls->GetNumOptions(); i++ ) {
			const sdDeclPlayerClass::optionList_t& option = cls->GetOption( i );
			msg.WriteBits( setup.GetOptions()[ i ], idMath::BitsForInteger( option.Num() ) );
		}
	}
	msg.Send( true, sdReliableMessageClientInfoAll() );
}

/*
==============
sdInventory::SetupClassThread
==============
*/
void sdInventory::SetupClassThread( void ) {
	ShutdownClassThread();
	if ( playerClass.GetClass() ) {
		const char* classThreadName = playerClass.GetClass()->GetClassThreadName();
		if ( *classThreadName ) {
			classThread = gameLocal.program->CreateThread();
			classThread->SetName( idStr( owner->GetName() ) + "_classThread" );
			classThread->CallFunction( owner->scriptObject, owner->scriptObject->GetFunction( classThreadName ) );
			classThread->ManualDelete();
			classThread->ManualControl();
			classThread->DelayedStart( 0 );
		}
	}
}

/*
==============
sdInventory::ClearClass
==============
*/
void sdInventory::ClearClass( void ) {
	SetPlayerClass( NULL );
	SendClassInfo( false );
}

/*
==============
sdInventory::LogClassTime
==============
*/
void sdInventory::LogClassTime( void ) {
	const sdDeclPlayerClass* pc = playerClass.GetClass();
	if ( pc != NULL ) {
		const sdDeclPlayerClass::stats_t& stats = pc->GetStats();
		if ( stats.timePlayed ) {
			int t = MS2SEC( gameLocal.time - timeClassChanged );
			stats.timePlayed->IncreaseValue( owner->entityNumber, t );
		}
	}
	timeClassChanged = gameLocal.time;
}

/*
==============
sdInventory::SetPlayerClass
==============
*/
void sdInventory::SetPlayerClass( const sdDeclPlayerClass* cls ) {
	LogClassTime();

	if ( gameLocal.isServer ) {
		owner->DropDisguise();
	}

	SetCachedClass( NULL );

	playerClass.SetClass( cls, true );

	SetupClassOptions( true, false );
	SetupClassThread();


	sdScriptHelper h1;
	owner->CallFloatNonBlockingScriptEvent( owner->GetScriptObject()->GetFunction( "OnClassChanged" ), h1 );

	SetupModel();

	owner->UpdateRating();

	UpdatePlayerClassInfo( cls ); //mal: update this clients class info!
}

/*
==============
sdInventory::SetClassOption
==============
*/
bool sdInventory::SetClassOption( int optionIndex, int itemIndex, bool sendInfo ) {
	if ( !playerClass.SetOption( optionIndex, itemIndex ) ) {
		return false;
	}

	idEntity* proxy = owner->GetProxyEntity();
	if ( proxy != NULL ) {
		proxy->GetUsableInterface()->OnExit( owner, true );
	}

	SetupClassOptions( true, true );

	if ( sendInfo ) {
		SendClassInfo( false );
	}

	return true;
}

/*
============
sdInventory::SetCachedClass
============
*/
bool sdInventory::SetCachedClass( const sdDeclPlayerClass* pc, bool sendInfo ) {
	bool changed = cachedPlayerClass.SetClass( pc );

	if ( changed && sendInfo ) {
		SendClassInfo( true );
	}

	return changed;
}

/*
============
sdInventory::SetCachedClassOption
============
*/
bool sdInventory::SetCachedClassOption( int optionIndex, int itemIndex, bool sendInfo ) {
	if ( optionIndex < 0 || optionIndex >= cachedPlayerClass.GetOptions().Num() ) {
		return false;
	}

	bool changed = cachedPlayerClass.SetOption( optionIndex, itemIndex );

	if ( changed && sendInfo ) {
		SendClassInfo( true );
	}

	return changed;
}

/*
==============
sdInventory::AddItems
==============
*/
bool sdInventory::AddItems( const sdDeclItemPackage* package, bool enabled ) {
	const sdDeclItemPackageNode& node = package->GetItemRoot();
	return AddItemNode( node, enabled, false );
}

/*
==============
sdInventory::CheckItems
==============
*/
bool sdInventory::CheckItems( const sdDeclItemPackage* package ) {
	const sdDeclItemPackageNode& node = package->GetItemRoot();
	return AddItemNode( node, true, true );
}

/*
==============
sdInventory::AddItemNode
==============
*/
bool sdInventory::AddItemNode( const sdDeclItemPackageNode& node, bool enabled, bool testOnly ) {
	bool added = false;

	if ( !node.GetRequirements().Check( owner ) ) {
		enabled = false;
	}

	for ( int i = 0; i < node.GetItems().Num(); i++ ) {
		const sdDeclInvItem* item = node.GetItems()[ i ];
		if ( !testOnly ) {
			items.AddItem( item, enabled );
		}
		added |= enabled;
	}

	for ( int i = 0; i < node.GetNodes().Num(); i++ ) {
		added |= AddItemNode( *node.GetNodes()[ i ], enabled, testOnly );
	}

	return added;
}

/*
==============
sdInventory::SetupClassOptions
==============
*/
void sdInventory::SetupClassOptions( bool clearAmmo, bool setWeapon, bool allowCurrentWeapon ) {
	bool disguise = owner->IsDisguised();
	if ( disguise ) {
		items.Clear();

		const sdDeclPlayerClass* cls = owner->GetDisguiseClass();
		if ( cls == NULL ) {
			return;
		}

		AddItems( cls->GetDisguisePackage() );
	} else { 

		if ( clearAmmo ) {
			ClearAmmo();
		}

		items.Clear();

		const sdDeclPlayerClass* cls = playerClass.GetClass();
		if ( cls == NULL ) {
			return;
		}

		if ( clearAmmo ) {
			for ( int i = 0; i < ammoLimits.Num(); i++ ) {
				ammoLimits[ i ] = cls->GetAmmoLimit( i );
			}
		}

		const sdDeclItemPackage* package = cls->GetPackage();
		AddItems( package );
		if ( clearAmmo && !disguise ) {
			GiveConsumables( package );
		}

		for ( int i = 0; i < playerClass.GetOptions().Num(); i++ ) {
			const sdDeclPlayerClass::optionList_t& list = cls->GetOption( i );

			int index = playerClass.GetOptions()[ i ];
			if ( index < 0 || index >= list.Num() ) {
				index = 0;
			}

			if ( !CheckItems( list[ index ] ) ) {
				index = 0;
			}

			for ( int j = 0; j < list.Num(); j++ ) {
				AddItems( list[ j ], j == index );
			}

			if ( clearAmmo ) {
				GiveConsumables( list[ index ] );
			}
		}
	}

	SortClips();
	if ( !gameLocal.isClient && setWeapon ) {
		SelectBestWeapon( allowCurrentWeapon );
	}
}

/*
==============
sdInventory::HasAbility
==============
*/
bool sdInventory::HasAbility( qhandle_t handle ) const {
	const sdDeclPlayerClass* cls = playerClass.GetClass();
	return cls && cls->HasAbility( handle );
}

/*
==============
sdInventory::SortClips
==============
*/
void sdInventory::SortClips( void ) {
	for ( int i = 0; i < items.Num(); i++ ) {
		const sdDeclInvItem* item = GetItem( i );
		for( int clip = 0; clip < item->GetClips().Num(); clip++ ) {
			const itemClip_t& clipInfo = item->GetClips()[ clip ];
			
			if ( clipInfo.maxAmmo > 0 && clipInfo.ammoPerShot > 0 ) {
				int max = Min( clipInfo.maxAmmo, GetAmmo( clipInfo.ammoType ) );
				SetClip( i, clip, max );
			}
		}
	}
}

/*
==============
sdInventory::GiveConsumables
==============
*/
bool sdInventory::GiveConsumablesNode( const sdDeclItemPackageNode& node ) {
	if ( !node.GetRequirements().Check( owner ) ) {
		return false;
	}

	bool given = false;

	idList< const sdConsumable* > consumables = node.GetConsumables();
	for ( int i = 0; i < consumables.Num(); i++ ) {
		if ( !consumables[ i ]->Give( owner ) ) {
			continue;
		}
		given = true;
	}

	for ( int i = 0; i < node.GetNodes().Num(); i++ ) {
		given |= GiveConsumablesNode( *node.GetNodes()[ i ] );
	}

	return given;
}

/*
==============
sdInventory::GiveConsumables
==============
*/
bool sdInventory::GiveConsumables( const sdDeclItemPackage* package ) {
	return GiveConsumablesNode( package->GetItemRoot() );
}

/*
==============
sdInventory::GetWeaponTitle
==============
*/
const sdDeclLocStr* sdInventory::GetWeaponTitle( void ) const {
	if( IsSwitchActive() ) {
		return items[ switchingWeapon ].item->GetItemName();
	}

	if ( !IsCurrentWeaponValid() ) {
		return NULL;
	}

	return items[ currentWeapon ].item->GetItemName();
}

/*
==============
sdInventory::GetWeaponName
==============
*/
const char* sdInventory::GetWeaponName( void ) const {
	if( IsSwitchActive() ) {
		return items[ switchingWeapon ].item->GetName();
	}

	if ( !IsCurrentWeaponValid() ) {
		return "";
	}

	return items[ currentWeapon ].item->GetName();
}

/*
============
sdInventory::CheckWeaponHasAmmo
============
*/
bool sdInventory::CheckWeaponHasAmmo( const sdDeclInvItem* item ) const {
	const idList< itemClip_t >& itemClips = item->GetClips();

	if ( !itemClips.Num() ) {
		return true;
	}

	for ( int i = 0; i < itemClips.Num(); i++ ) {
		if ( GetAmmo( itemClips[ i ].ammoType ) >= itemClips[ i ].ammoPerShot ) {
			return true;
		}
	}
	return false;
}

/*
============
sdInventory::GetAmmo
============
*/
int sdInventory::GetAmmo( int index ) const {
	return ammo[ index ];
}

/*
==============
sdInventory::ShutdownClassThread
==============
*/
void sdInventory::ShutdownClassThread( void ) {
	if ( classThread != NULL ) {
		gameLocal.program->FreeThread( classThread );
		classThread = NULL;
	}
}

/*
============
sdInventory::CancelWeaponSwitch
============
*/
void sdInventory::CancelWeaponSwitch( void ) {
	switchingWeapon = -1;
}


/*
============
sdInventory::AcceptWeaponSwitch
============
*/
void sdInventory::AcceptWeaponSwitch( void ) {
	if ( CanEquip( switchingWeapon, true ) ) {
		SetIdealWeapon( switchingWeapon );
		switchingWeapon = -1;
	}
}

/*
============
sdInventory::UpdateCurrentWeapon
============
*/
void sdInventory::UpdateCurrentWeapon( void ) {
	if ( currentWeapon != idealWeapon ) {
		if ( currentWeapon >= 0 && currentWeapon < items.Num() ) {
			if ( items.ShowItem( items[ currentWeapon ] ) ) {
				items[ currentWeapon ].SetVisible( true );
			}
		}

		currentWeapon = idealWeapon;

		if ( currentWeapon >= 0 && currentWeapon < items.Num() ) {
			items[ currentWeapon ].SetVisible( false );
			items.HideItem( items[ currentWeapon ] );
		}
	}

	weaponChanged = false;
}

/*
============
sdInventory::ApplyNetworkState
============
*/
void sdInventory::ApplyNetworkState( const sdInventoryBroadcastData& newData ) {
	if ( newData.idealWeapon >= -1 && newData.idealWeapon < items.Num() ) {
		if ( newData.idealWeapon == -1 || newData.idealWeapon != idealWeapon || ( currentWeaponIndex != items[ newData.idealWeapon ].item->Index() ) ) {
			SetIdealWeapon( newData.idealWeapon, true );
		}
	}

	assert( sdBitField_Dynamic::SizeForBits( items.Num() ) == newData.disabledMask.GetSize() );
	for ( int i = 0; i < items.Num(); i++ ) {
		items[ i ].SetDisabled( newData.disabledMask.Get( i ) != 0 );
	}

	if ( !owner->ShouldReadPlayerState() ) {
		assert( sdBitField_Dynamic::SizeForBits( gameLocal.declAmmoTypeType.Num() ) == newData.ammoMask.GetSize() );
		for ( int i = 0; i < gameLocal.declAmmoTypeType.Num(); i++ ) {
			ammo[ i ] = ( newData.ammoMask[ i ] != 0 ) ? 999 : 0;
		}
	}

	owner->GetProficiencyTable().ApplyNetworkState( newData.proficiencyData );
}

/*
============
sdInventory::ReadNetworkState
============
*/
void sdInventory::ReadNetworkState( const sdInventoryBroadcastData& baseData, sdInventoryBroadcastData& newData, const idBitMsg& msg ) const {
	newData.idealWeapon				= msg.ReadDeltaLong( baseData.idealWeapon );

	newData.disabledMask.Init( items.Num() );
	for ( int i = 0; i < newData.disabledMask.GetSize(); i++ ) {
		if ( i < baseData.disabledMask.GetSize() ) {
			newData.disabledMask.GetDirect( i ) = msg.ReadDeltaLong( baseData.disabledMask.GetDirect( i ) );
		} else {
			newData.disabledMask.GetDirect( i ) = msg.ReadLong();
		}
	}

	if ( !owner->ShouldReadPlayerState() ) {
		newData.ammoMask.Init( gameLocal.declAmmoTypeType.Num() );
		for ( int i = 0; i < newData.ammoMask.GetSize(); i++ ) {
			if ( i < baseData.ammoMask.GetSize() ) {
				newData.ammoMask.GetDirect( i ) = msg.ReadDeltaLong( baseData.ammoMask.GetDirect( i ) );
			} else {
				newData.ammoMask.GetDirect( i ) = msg.ReadLong();
			}
		}
	} else {
		newData.ammoMask.SetSize( baseData.ammoMask.GetSize() );
		for ( int i = 0; i < newData.ammoMask.GetSize(); i++ ) {
			newData.ammoMask.GetDirect( i ) = baseData.ammoMask.GetDirect( i );
		}
	}

	owner->GetProficiencyTable().ReadNetworkState( baseData.proficiencyData, newData.proficiencyData, msg );
}

/*
============
sdInventory::WriteNetworkState
============
*/
void sdInventory::WriteNetworkState( const sdInventoryBroadcastData& baseData, sdInventoryBroadcastData& newData, idBitMsg& msg ) const {
	newData.idealWeapon				= idealWeapon;

	msg.WriteDeltaLong( baseData.idealWeapon, newData.idealWeapon );

	newData.disabledMask.Init( items.Num() );
	for ( int i = 0; i < items.Num(); i++ ) {
		if ( items[ i ].IsDisabled() ) {
			newData.disabledMask.Set( i );
		} else {
			newData.disabledMask.Clear( i );
		}
	}

	for ( int i = 0; i < newData.disabledMask.GetSize(); i++ ) {
		if ( i < baseData.disabledMask.GetSize() ) {
			msg.WriteDeltaLong( baseData.disabledMask.GetDirect( i ), newData.disabledMask.GetDirect( i ) );
		} else {
			msg.WriteLong( newData.disabledMask.GetDirect( i ) );
		}
	}

	if ( !owner->ShouldWritePlayerState() ) {
		int ammoCount = gameLocal.declAmmoTypeType.Num();
		newData.ammoMask.Init( ammoCount );
		for ( int i = 0; i < ammoCount; i++ ) {
			if ( ammo[ i ] != 0 ) {
				newData.ammoMask.Set( i );
			} else {
				newData.ammoMask.Clear( i );
			}
		}

		for ( int i = 0; i < newData.ammoMask.GetSize(); i++ ) {
			if ( i < baseData.ammoMask.GetSize() ) {
				msg.WriteDeltaLong( baseData.ammoMask.GetDirect( i ), newData.ammoMask.GetDirect( i ) );
			} else {
				msg.WriteLong( newData.ammoMask.GetDirect( i ) );
			}
		}
	} else {
		newData.ammoMask.SetSize( baseData.ammoMask.GetSize() );
		for ( int i = 0; i < newData.ammoMask.GetSize(); i++ ) {
			newData.ammoMask.GetDirect( i ) = baseData.ammoMask.GetDirect( i );
		}
	}

	owner->GetProficiencyTable().WriteNetworkState( baseData.proficiencyData, newData.proficiencyData, msg );
}

/*
============
sdInventory::CheckNetworkStateChanges
============
*/
bool sdInventory::CheckNetworkStateChanges( const sdInventoryBroadcastData& baseData ) const {
	NET_CHECK_FIELD( idealWeapon, idealWeapon );

	if ( sdBitField_Dynamic::SizeForBits( items.Num() ) != baseData.disabledMask.GetSize() ) {
		return true;
	}

	for ( int i = 0; i < items.Num(); i++ ) {
		if ( ( baseData.disabledMask.Get( i ) != 0 ) != items[ i ].IsDisabled() ) {
			return true;
		}
	}

	if ( !owner->ShouldWritePlayerState() ) {
		if ( baseData.ammoMask.GetSize() != sdBitField_Dynamic::SizeForBits( gameLocal.declAmmoTypeType.Num() ) ) {
			return true;
		}

		for ( int i = 0; i < gameLocal.declAmmoTypeType.Num(); i++ ) {
			if ( ( baseData.ammoMask.Get( i ) != 0 ) != ( ammo[ i ] != 0 ) ) {
				return true;
			}
		}
	}

	return owner->GetProficiencyTable().CheckNetworkStateChanges( baseData.proficiencyData );
}

/*
============
sdInventory::ApplyPlayerState
============
*/
void sdInventory::ApplyPlayerState( const sdInventoryPlayerStateData& newState ) {
	NET_GET_NEW( sdInventoryPlayerStateData );

	for ( int i = 0; i < newData.ammo.Num(); i++ ) {
		SetAmmo( i, newData.ammo[ i ] );
	}

	items.ApplyPlayerState( newData );
}

/*
============
sdInventory::ReadPlayerState
============
*/
void sdInventory::ReadPlayerState( const sdInventoryPlayerStateData& baseState, sdInventoryPlayerStateData& newState, const idBitMsg& msg ) const {
	NET_GET_STATES( sdInventoryPlayerStateData );

	newData.ammo.SetNum( gameLocal.declAmmoTypeType.Num() );
	for ( int i = 0; i < newData.ammo.Num(); i++ ) {
		newData.ammo[ i ] = msg.ReadDeltaShort( baseData.ammo[ i ] );
	}

	items.ReadPlayerState( baseState, newData, msg );
}

/*
============
sdInventory::WritePlayerState
============
*/
void sdInventory::WritePlayerState( const sdInventoryPlayerStateData& baseState, sdInventoryPlayerStateData& newState, idBitMsg& msg ) const {
	NET_GET_STATES( sdInventoryPlayerStateData );

	newData.ammo.SetNum( gameLocal.declAmmoTypeType.Num() );
	for ( int i = 0; i < newData.ammo.Num(); i++ ) {
		newData.ammo[ i ] = GetAmmo( i );
		msg.WriteDeltaShort( baseData.ammo[ i ], newData.ammo[ i ] );
	}

	items.WritePlayerState( baseState, newState, msg );
}

/*
============
sdInventory::CheckPlayerStateChanges
============
*/
bool sdInventory::CheckPlayerStateChanges( const sdInventoryPlayerStateData& baseState ) const {
	NET_GET_BASE( sdInventoryPlayerStateData );

	for ( int i = 0; i < baseData.ammo.Num(); i++ ) {
		if ( baseData.ammo[ i ] != GetAmmo( i ) ) {
			return true;
		}
	}

	return items.CheckPlayerStateChanges( baseState );
}


/*
============
sdInventory::HideCurrentItem
============
*/
void sdInventory::HideCurrentItem( bool hide ) {
	if( currentWeapon != -1 ) {
		if ( hide ) {
			items[ currentWeapon ].SetVisible( false );
			items.HideItem( items[ currentWeapon ] );
		} else {
			if ( items.ShowItem( items[ currentWeapon ] ) ) {
				items[ currentWeapon ].SetVisible( true );
			}
		}
	}
}

/*
============
sdInventory::SetClass
============
*/
bool sdInventory::SetClass( const idBitMsg& msg, bool cached ) {
	sdPlayerClassSetup& setup = cached ? cachedPlayerClass : playerClass;

	int playerClassIndex = msg.ReadBits( gameLocal.GetNumPlayerClassBits() ) - 1;
	const sdDeclPlayerClass* pc = NULL;
	if ( playerClassIndex != -1 ) {
		pc = gameLocal.declPlayerClassType[ playerClassIndex ];
	}

	if ( setup.GetClass() != pc ) {
		if ( cached ) {
			SetCachedClass( pc );
		} else {
			SetPlayerClass( pc );
		}
	}

	if ( pc ) {
		bool changed = false;
		for ( int i = 0; i < pc->GetNumOptions(); i++ ) {
			int itemIndex = msg.ReadBits( idMath::BitsForInteger( pc->GetOption( i ).Num() ) );
			if ( setup.GetOptions()[ i ] != itemIndex ) {
				setup.SetOption( i, itemIndex );
				changed = true;
			}
		}
		if ( changed && !cached ) {
			SetupClassOptions( true, false );
		}
	}

	return true;
}

/*
============
sdInventory::UpdateForDisguise
============
*/
void sdInventory::UpdateForDisguise( void ) {
	SetupClassOptions( false, true, false );
	SetupModel();
}

/*
============
sdInventory::OnHide
============
*/
void sdInventory::OnHide( void ) {
	items.OnHide();
}

/*
============
sdInventory::OnShow
============
*/
void sdInventory::OnShow( void ) {
	items.OnShow();
}

/*
============
sdInventory::LogSuicide
============
*/
void sdInventory::LogSuicide( void ) {
	const sdDeclPlayerClass* pc = playerClass.GetClass();
	if ( !pc ) {
		return;
	}

	const sdDeclPlayerClass::stats_t& stats = pc->GetStats();
	if ( stats.suicides ) {
		stats.suicides->IncreaseValue( owner->entityNumber, 1 );
	}
}

/*
============
sdInventory::LogDeath
============
*/
void sdInventory::LogDeath( void ) {
	const sdDeclPlayerClass* pc = playerClass.GetClass();
	if ( !pc ) {
		return;
	}

	const sdDeclPlayerClass::stats_t& stats = pc->GetStats();
	if ( stats.deaths != NULL ) {
		stats.deaths->IncreaseValue( owner->entityNumber, 1 );
	}
}

/*
============
sdInventory::LogRevive
============
*/
void sdInventory::LogRevive( void ) {
	const sdDeclPlayerClass* pc = playerClass.GetClass();
	if ( !pc ) {
		return;
	}

	const sdDeclPlayerClass::stats_t& stats = pc->GetStats();
	if ( stats.revived ) {
		stats.revived->IncreaseValue( owner->entityNumber, 1 );
	}
}

/*
============
sdInventory::LogTapOut
============
*/
void sdInventory::LogTapOut( void ) {
	const sdDeclPlayerClass* pc = playerClass.GetClass();
	if ( !pc ) {
		return;
	}

	const sdDeclPlayerClass::stats_t& stats = pc->GetStats();
	if ( stats.tapouts ) {
		stats.tapouts->IncreaseValue( owner->entityNumber, 1 );
	}
}

/*
============
sdInventory::LogRespawn
============
*/
void sdInventory::LogRespawn( void ) {
	const sdDeclPlayerClass* pc = playerClass.GetClass();
	if ( !pc ) {
		return;
	}

	const sdDeclPlayerClass::stats_t& stats = pc->GetStats();
	if ( stats.respawns != NULL ) {
		stats.respawns->IncreaseValue( owner->entityNumber, 1 );
	}
}

/*
============
sdInventory::UpdatePlayerClassInfo

update the players class info game side for the bots.
============
*/
void sdInventory::UpdatePlayerClassInfo( const sdDeclPlayerClass* pc ) {

 	if ( !pc ) {
		return;
	}
	
	botThreadData.GetGameWorldState()->clientInfo[ owner->entityNumber ].classType = pc->GetPlayerClassNum();
}