//-----------------------------------------------------------------------------
//
//  $Logfile:: /Quake 2 Engine/Sin/code/game/item.cpp                         $
// $Revision:: 51                                                             $
//   $Author:: Markd                                                          $
//     $Date:: 11/12/98 9:20p                                                 $
//
// Copyright (C) 1997 by Ritual Entertainment, Inc.
// All rights reserved.
//
// This source is may not be distributed and/or modified without
// expressly written permission by Ritual Entertainment, Inc.
//
// $Log:: /Quake 2 Engine/Sin/code/game/item.cpp                              $
//
// 51    11/12/98 9:20p Markd
// fixed null sounds for snd_pickup
//
// 50    10/24/98 2:07p Aldie
// Mutants can only pickup health
//
// 49    10/22/98 10:22p Markd
// Put in support for game and level item script variables
//
// 48    10/19/98 12:05a Jimdose
// made all code use fast checks for inheritance (no text lookups when
// possible)
// isSubclassOf no longer requires ::_classinfo()
// got rid of warning in Set
//
// 47    10/14/98 1:18a Jimdose
// Got cross-level persistant info working
// Added amount_override
//
// 46    10/11/98 8:57p Aldie
// Don't print out error message unecessarily
//
// 45    10/10/98 1:28a Jimdose
// items no longer drop to the floor when loading savegames
//
// 44    10/09/98 2:06a Aldie
// Updated DMFLAGS
//
// 43    10/07/98 5:51p Markd
// Fixed small sized enemies getting resized and causing fall out of level
// errors
//
// 42    10/04/98 6:15p Markd
// fixed pickup sounds
//
// 41    9/29/98 5:59p Markd
// Added dialog_needed stuff
//
// 40    9/29/98 11:05a Markd
// Added respawnsound support
//
// 39    9/15/98 6:37p Markd
// Added RotatedBounds flag support
//
// 38    9/08/98 9:29p Markd
// fixed picking things up by using them
//
// 37    9/02/98 11:53a Markd
// Put in pickup by pressing the use key
//
// 36    9/01/98 7:45p Aldie
// Added itemname
//
// 35    8/29/98 7:23p Aldie
// Added itemname to get around targetname problem.
//
// 34    8/18/98 11:08p Markd
// Added new Alias System
//
// 33    8/15/98 1:48p Aldie
// Don't turn off glow when objects are picked up
//
// 32    8/12/98 4:19p Aldie
// Fixed icons not showing up correctly
//
// 31    7/26/98 1:17a Markd
// Put in respawn sounds for items
//
// 30    7/14/98 6:57p Aldie
// Made dropped weapons fade out
//
// 29    7/14/98 3:53p Markd
// made pickup sounds work properly
//
// 28    7/12/98 4:34p Markd
// Fixed bounding boxes on items
//
// 27    7/11/98 8:19p Jimdose
// Drop now returns true or false depending upon whether the item can be
// dropped or not
//
// 26    7/10/98 2:48p Aldie
// Cleared targetname for all items to circumvent an error when removing an
// actor carrying a weapon of the same targetname as him.
//
// 25    6/26/98 11:30a Markd
// Changed ItemPickup
//
// 24    6/25/98 8:47p Markd
// Added keyed items for Triggers, Rewrote Item class, rewrote every pickup
// method
//
// 23    6/24/98 1:36p Aldie
// Implementation of inventory system and picking stuff up
//
// 22    6/17/98 1:20a Jimdose
// Moved setOwner to Item.
// Added EV_Item_Pickup
//
// 21    6/16/98 9:37p Markd
// made items capable of being orientated
//
// 20    6/16/98 4:08p Jimdose
// Gave dropping weapons velocity
//
// 19    6/04/98 7:36p Jimdose
// PlaceItem now posts the EV_Remove instead of processing it
//
// 18    6/03/98 4:37p Markd
// When picking an item up, stop glowing, when dropping it start glowing
//
// 17    5/13/98 4:45p Jimdose
// droptofloor event is now posted with 0 delay
//
// 16    5/03/98 4:50p Jimdose
// Fixed bug where items fell through ground
//
// 15    5/03/98 4:44p Jimdose
// changed Vector class
//
// 14    5/02/98 12:39a Jimdose
// Changed PlaceItem so that items only test if they can drop to the floor.  If
// they can, they're left where they were spawned so that they fall, otherwise
// they're removed
//
// 13    4/05/98 9:41p Markd
// Put in RF_GLOW
//
// 12    4/04/98 6:05p Jimdose
// ItemPickup no longer activates targets, since the item should alread have
// triggered its targets when it was touched
//
// 11    4/02/98 4:49p Jimdose
// changed droptofloor
//
// 10    3/30/98 2:32p Jimdose
// now shows model on placement
//
// 9     3/28/98 8:57p Jimdose
// changed bounding box
//
// 8     3/23/98 1:31p Jimdose
// Revamped event and command system
//
// 7     3/02/98 8:49p Jimdose
// Changed the classid parameter of CLASS_DECLARATION to a quoted string so
// that you could have a NULL classid.
//
// 6     2/19/98 2:35p Jimdose
// Updated to work with Q2 based progs
//
// 4     11/07/97 5:59p Markd
// Removed QUAKE specific sound effects
//
// 3     10/27/97 3:29p Jimdose
// Removed dependency on quakedef.h
//
// 2     9/26/97 5:30p Jimdose
// Added standard Ritual headers
//
// DESCRIPTION:
// Base class for respawnable, carryable objects.
//

#include "g_local.h"
#include "entity.h"
#include "trigger.h"
#include "item.h"
#include "inventoryitem.h"
#include "scriptmaster.h"
#include "health.h"

Event EV_Item_Pickup( "item_pickup" );
Event EV_Item_DropToFloor( "droptofloor" );
Event EV_Item_Respawn( "respawn" );
Event EV_Item_SetAmount( "amount" );
Event EV_Item_SetMaxAmount( "maxamount" );
Event EV_Item_SetIconName( "iconname" );
Event EV_Item_SetItemName( "itemname" );
Event EV_Item_RespawnSound( "respawnsound" );
Event EV_Item_DialogNeeded( "dialogneeded" );

CLASS_DECLARATION( Trigger, Item, NULL );

ResponseDef Item::Responses[] =
{
	{ &EV_Trigger_Effect, ( Response )& Item::ItemTouch },
	{ &EV_Item_DropToFloor, ( Response )& Item::DropToFloor },
	{ &EV_Item_Respawn, ( Response )& Item::Respawn },
	{ &EV_Item_SetAmount, ( Response )& Item::SetAmount },
	{ &EV_Item_SetMaxAmount, ( Response )& Item::SetMaxAmount },
	{ &EV_Item_SetIconName, ( Response )& Item::SetIconName },
	{ &EV_Item_SetItemName, ( Response )& Item::SetItemName },
	{ &EV_Item_Pickup, ( Response )& Item::Pickup },
	{ &EV_Use, ( Response )& Item::TriggerStuff },
	{ &EV_Item_RespawnSound, ( Response )& Item::RespawnSound },
	{ &EV_Item_DialogNeeded, ( Response )& Item::DialogNeeded },
	{ NULL, NULL }
};

Item::Item()
{
	str fullname;
	Vector defangles;

	setRespawnTime( 20 );
	setRespawn( false );

	setSolidType( SOLID_NOT );

	// Set default respawn behavior
	// Derived classes should use setRespawn
	// if they want to override the default behavior
	if( deathmatch->value )
	{
		setRespawn( true );
	}
	else
	{
		setRespawn( false );
	}

	edict->s.renderfx |= RF_GLOW;

	// angles
	defangles = Vector( 0, G_GetFloatArg( "angle", 0 ), 0 );
	if( defangles.y == -1 )
	{
		defangles = Vector( -90, 0, 0 );
	}
	else if( defangles.y == -2 )
	{
		defangles = Vector( 90, 0, 0 );
	}
	angles = G_GetVectorArg( "angles", defangles );
	setAngles( angles );

	//
	// we want the bounds of this model auto-rotated
	//
	flags |= FL_ROTATEDBOUNDS;

	//
	// rotate the mins and maxs for the model
	//
	if( size.length() < 10 )
		setSize( Vector( -10, -10, 0 ), Vector( 10, 10, 20 ) );

	//
	// reset the mins and maxs to pickup the FL_ROTATEDBOUNDS flag
	//
	setSize( mins, maxs );

	if( !LoadingSavegame )
	{
		// Items can't be immediately dropped to floor, because they might
		// be on an entity that hasn't spawned yet.
		PostEvent( EV_Item_DropToFloor, 0 );
	}

//### so players can pick up stuff while on a hoverbike
//	respondto = TRIGGER_PLAYERS;
	respondto = TRIGGER_PLAYERS | TRIGGER_HOVERBIKES;

	icon_name = str( "" );
	icon_index = 0;
	item_index = 0;
	maximum_amount = 1;
	playrespawn = false;

	amount_override = false;
	amount = 1;

	// FIXME
	// If the targetname is set by the spawn args, then this item
	// will have a targetname.  If we try to remove the owner of this
	// item, then we will remove the owner, then try to remove the item
	// which will already have been removed by the previous event.
	// This doesn't allow any items to have a targetname.
	SetTargetName( "" );

	// Using itemname as a temporary fix to this problem
	itemname = G_GetSpawnArg( "itemname", "" );

	if( G_GetSpawnArg( "amount" ) )
	{
		amount = G_GetIntArg( "amount" );
		if( amount >= MaxAmount() )
		{
			SetMax( amount );
		}
		amount_override = true;
	}
}

Item::~Item()
{
	if( owner )
	{
		owner->RemoveItem( this );
		owner = NULL;
	}
}

void Item::CreateSpawnArgs( void )
{
	G_SetIntArg( "amount", amount );
	G_SetSpawnArg( "model", model.c_str() );
}

/*
============
PlaceItem

Puts an item back in the world
============
*/
void Item::PlaceItem( void )
{
	setSolidType( SOLID_TRIGGER );
	setMoveType( MOVETYPE_TOSS );
	showModel();

	edict->s.renderfx |= RF_GLOW;
	groundentity = NULL;
}

/*
============
DropToFloor

plants the object on the floor
============
*/
void Item::DropToFloor( Event* ev )
{
	Vector save;

	PlaceItem();

	setOrigin( origin + Vector( 0, 0, 1 ) );
	save = origin;
	if( !droptofloor( 8192 ) )
	{
		gi.dprintf( "%s fell out of level at '%5.1f %5.1f %5.1f'\n",
					getClassID(), origin.x, origin.y, origin.z );
		PostEvent( EV_Remove, 0 );
		return;
	}
	//
	// if the our global variable doesn't exist, lets zero it out
	//
	str fullname( "playeritem_" );
	fullname += getClassname();
	if( !gameVars.VariableExists( fullname.c_str() ) )
	{
		gameVars.SetVariable( fullname.c_str(), 0 );
	}

	if( !levelVars.VariableExists( fullname.c_str() ) )
	{
		levelVars.SetVariable( fullname.c_str(), 0 );
	}

	setOrigin( save );
	groundentity = NULL;
}

qboolean Item::Drop( void )
{
	if( !owner )
	{
		return false;
	}

	setOrigin( owner->worldorigin + Vector( 0, 0, 40 ) );

	// drop the item
	PlaceItem();
	velocity = owner->velocity * 0.5 + Vector( G_CRandom( 50 ), G_CRandom( 50 ), 100 );
	setAngles( owner->angles );
	avelocity = Vector( 0, G_CRandom( 360 ), 0 );

	trigger_time = level.time + 1;

	if( owner->isClient() )
	{
		spawnflags |= DROPPED_PLAYER_ITEM;
	}
	else
	{
		spawnflags |= DROPPED_ITEM;
	}

	// Remove this from the owner's item list
	owner->RemoveItem( this );
	owner = NULL;

	return true;
}


void Item::ItemTouch( Event* ev )
{
	Entity* other;
	Event*      e;

	if( owner )
	{
		// Don't respond to trigger events after item is picked up.
		gi.dprintf( "%s with targetname of %s was triggered unexpectedly.\n", getClassID(), TargetName() );
		return;
	}

	other = ev->GetEntity( 1 );

	e = new Event( EV_Item_Pickup );
	e->AddEntity( other );
	ProcessEvent( e );
}

void Item::SetOwner( Sentient* ent )
{
	assert( ent );
	if( !ent )
	{
		// return to avoid any buggy behaviour
		return;
	}

	owner = ent;
	setRespawn( false );

	edict->s.renderfx &= ~RF_GLOW;
	setSolidType( SOLID_NOT );
	hideModel();
	CancelEventsOfType( EV_Item_DropToFloor );
	CancelEventsOfType( EV_Remove );
//	ItemPickup( ent );
}

Item* Item::ItemPickup( Entity* other )
{
	Sentient* sent;
	Item* item;
	str realname;

	if( !Pickupable( other ) )
	{
		return NULL;
	}

	sent = ( Sentient* )other;

	item = sent->giveItem( getClassname(), Amount(), icon_index );

	if( !item )
		return NULL;

	realname = GetRandomAlias( "snd_pickup" );
	if( realname.length() > 1 )
		sent->sound( realname, 1, CHAN_ITEM, ATTN_NORM );

	if( !Removable() )
	{
		// leave the item for others to pickup
		return item;
	}

	CancelEventsOfType( EV_Item_DropToFloor );
	CancelEventsOfType( EV_Item_Respawn );
	CancelEventsOfType( EV_FadeOut );

	setSolidType( SOLID_NOT );
	hideModel();


	if( Respawnable() )
	{
		PostEvent( EV_Item_Respawn, RespawnTime() );
	}
	else
	{
		PostEvent( EV_Remove, 0.1 );
	}

	if( DM_FLAG( DF_INSTANT_ITEMS ) )
	{
		Event* ev;

		ev = new Event( EV_InventoryItem_Use );
		ev->AddEntity( other );

		item->ProcessEvent( ev );
	}

	return item;
}

void Item::Respawn( Event* ev )
{
	showModel();

	// allow it to be touched again
	setSolidType( SOLID_TRIGGER );

	// play respawn sound
	if( playrespawn )
	{
		RandomGlobalSound( "snd_itemspawn" );
	}

	setOrigin( origin );
};

void Item::setRespawn( qboolean flag )
{
	respawnable = flag;
}

qboolean Item::Respawnable( void )
{
	return respawnable;
}

void Item::setRespawnTime( float time )
{
	respawntime = time;
}

float Item::RespawnTime( void )
{
	return respawntime;
}

int Item::GetIconIndex( void )
{
	return icon_index;
}

int Item::GetItemIndex( void )
{
	return item_index;
}

int Item::Amount( void )
{
	return amount;
}

int Item::MaxAmount( void )
{
	return maximum_amount;
}

qboolean Item::Pickupable( Entity* other )
{
	if( !other->isSubclassOf( Sentient ) )
	{
		return false;
	}
	else
	{
		Sentient* sent;
		Item* item;

		sent = ( Sentient* )other;
		item = sent->FindItem( getClassname() );

		if( item && ( item->Amount() >= item->MaxAmount() ) )
		{
			return false;
		}

		// Mutants can't pick up anything but health
		if( other->flags & ( FL_MUTANT | FL_SP_MUTANT ) && !( this->isSubclassOf( Health ) ) )
		{
			return false;
		}

		// If deathmatch and already in a powerup, don't pickup anymore when DF_INSTANT_ITEMS is on
		if( DM_FLAG( DF_INSTANT_ITEMS ) &&
				this->isSubclassOf( InventoryItem ) &&
				sent->PowerupActive()
		  )
		{
			return false;
		}
	}
	return true;
}

void Item::Pickup( Event* ev )
{
	ItemPickup( ev->GetEntity( 1 ) );
}

void Item::setIcon( const char* i )
{
	icon_name = i;
	icon_index = gi.imageindex( i );
}

void Item::setName( const char* i )
{
	item_name = i;
	item_index = gi.itemindex( i );
}

int Item::Icon( void )
{
	if( icon_name.length() )
		return icon_index;
	else
		return -1;
}

void Item::Set( int startamount )
{
	if( !amount_override )
	{
		amount = startamount;
		if( amount >= MaxAmount() )
			SetMax( amount );
	}
}

void Item::SetMax( int maxamount )
{
	maximum_amount = maxamount;
}

void Item::SetAmount( Event* ev )
{
	Set( ev->GetInteger( 1 ) );
}

void Item::SetMaxAmount( Event* ev )
{
	SetMax( ev->GetInteger( 1 ) );
}

void Item::SetIconName( Event* ev )
{
	setIcon( ev->GetString( 1 ) );
}

void Item::SetItemName( Event* ev )
{
	setName( ev->GetString( 1 ) );
}

void Item::Add( int num )
{
	amount += num;
	if( amount >= MaxAmount() )
		amount = MaxAmount();
}

//###
void Item::DoubleMaxAdd( int num )
{
	amount += num;
	if( amount >= MaxAmount() * 2 )
		amount = MaxAmount() * 2;
}
//##

void Item::Remove( int num )
{
	amount -= num;
	if( amount < 0 )
		amount = 0;
}


qboolean Item::Use( int num )
{
	if( num > amount )
	{
		return false;
	}

	amount -= num;
	return true;
}

qboolean Item::Removable( void )
{
	return true;
}

void Item::RespawnSound( Event* ev )
{
	playrespawn = true;
}

void Item::DialogNeeded( Event* ev )
{
	//
	// if this item is needed for a trigger, play this dialog
	//
	dialog_needed = ev->GetString( 1 );
}

str Item::GetDialogNeeded( void )
{
	return dialog_needed;
}
