//-----------------------------------------------------------------------------
//
//  $Logfile:: /EF2/Code/DLLs/game/dispenser.cpp                             $
// $Revision:: 20                                                             $
//   $Author:: Singlis                                                        $
//     $Date:: 9/26/03 2:36p                                                  $
//
// Copyright (C) 2002 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.
//
// DESCRIPTION:
// This is all the dispensing type objects in the world.  They basically work
// by the player using them.  As the player uses them they give the player
// something (health/ammo/etc.).
//

#include "_pch_cpp.h"
#include "dispenser.hpp"
#include "sentient.h"
#include "player.h"

Event EV_Dispenser_SetMaxAmount
(
	"dispenser_maxamount",
	EV_DEFAULT,
	"f",
	"maxAmount",
	"Sets the total amount that this dispenser can give out."
);
Event EV_Dispenser_SetDispenseRate
(
	"dispenser_rate",
	EV_DEFAULT,
	"f",
	"dispenseRate",
	"Sets the dispense rate (how many units per second to give out)."
);
Event EV_Dispenser_SetRegenRate
(
	"dispenser_regenrate",
	EV_DEFAULT,
	"f",
	"regenRate",
	"Sets the regen rate (how many units per second to regen)."
);
Event EV_Dispenser_SetType
(
	"dispenser_type",
	EV_DEFAULT,
	"s",
	"type",
	"Sets the type of thing to give out.\n"
	"Only health and ammo are valid currently."
);
Event EV_Dispenser_SetSubtype
(
	"dispenser_subtype",
	EV_DEFAULT,
	"s",
	"subtype",
	"Sets the subtype of thing to give out.\n"
	"There is no subtype for health, the subtype for ammo is the ammo type."
);
Event EV_Dispenser_SetOpenDistance
(
	"dispenser_openDistance",
	EV_DEFAULT,
	"f",
	"openDistance",
	"Sets the distance from the player that the dispenser will open/close\n"
);
Event EV_Dispenser_SetInstant
(
	"dispenser_instant",
	EV_DEFAULT,
	NULL,
	NULL,
	"Makes the dispenser give out its stuff instantly\n"
);
Event EV_Dispenser_AnimDone
(
	"dispenser_animdone",
	EV_CODEONLY,
	NULL,
	NULL,
	"Called when the dispenser's animation is done"
);
Event EV_Dispenser_SetSoundName
(
	"dispenser_soundName",
	EV_DEFAULT,
	"s",
	"soundName",
	"Makes the dispenser use the specified looping sound when its being used\n"
);

//------------------------- CLASS ------------------------------
//
// Name:		Dispenser
// Base Class:	Entity
//
// Description:	This is an entity that dispenses stuff (health, ammo, etc) 
//              to anything that uses it
//
// Method of Use:	Just like any entity.
//
//--------------------------------------------------------------

CLASS_DECLARATION( Entity, Dispenser, NULL )
{
	{ &EV_Dispenser_SetMaxAmount,		&Dispenser::setMaxAmount },
	{ &EV_Dispenser_SetDispenseRate,	&Dispenser::setDispenseRate },
	{ &EV_Dispenser_SetRegenRate,		&Dispenser::setRegenRate },
	{ &EV_Dispenser_SetType,			&Dispenser::setType },
	{ &EV_Dispenser_SetSubtype,			&Dispenser::setSubtype },
	{ &EV_Dispenser_SetOpenDistance,	&Dispenser::setOpenDistance },
	{ &EV_Dispenser_SetInstant,			&Dispenser::setInstant },
	{ &EV_Dispenser_AnimDone,			&Dispenser::animDone },
	{ &EV_Dispenser_SetSoundName,		&Dispenser::setSoundName },
	{ &EV_Use,							&Dispenser::useEvent },

	{ NULL, NULL }
};

//----------------------------------------------------------------
// Name:			Dispenser
// Class:			Dispenser
//
// Description:		constructor
//
// Parameters:		None
//
// Returns:			None
//----------------------------------------------------------------

Dispenser::Dispenser()
{
	animate = new Animate( this );

	setMoveType( MOVETYPE_NONE );
	setSolidType( SOLID_BBOX );
	setContents( CONTENTS_BODY );

	_maxAmount = 0;
	_amount    = 0;

	_dispenseRate = 0;
	_regenRate    = 0;

	_dispenseType = DISPENSE_TYPE_NONE;

	_lastTimeUsed = 0;

	edict->s.eType = ET_MODELANIM;

	_openDistance = 200.0f;

	if ( !LoadingSavegame )
	{
		Event *event = new Event( EV_Anim );
		event->AddString( "closed_idle" );
		PostEvent( event, 0.0f );
	}

	_state = DISPENSER_STATE_CLOSED;

	_instant = false;

	_entityDispensingTo = NULL;

	turnThinkOn();

	_playingSound = false;
	_lastSoundTime = 0.0f;
}

//----------------------------------------------------------------
// Name:			Think
// Class:			Dispenser
//
// Description:		Does everything the dispenser needs to do for this frame
//
// Parameters:		None
//
// Returns:			None
//----------------------------------------------------------------

void Dispenser::Think( void )
{
	bool playerNearby;
	Player *player;
	Vector dir;
	float distance;

	if ( _playingSound && level.time > _lastSoundTime + 0.25f )
	{
		StopLoopSound();
		_playingSound = false;
	}

	if ( _entityDispensingTo )
	{
		bool dispensedStuff;

		dispensedStuff = dispenseStuff( _entityDispensingTo );

		if ( dispensedStuff )
			return;
		else
		{
			_entityDispensingTo = NULL;
		}
	}

	// Regenerate if we are suppose to 

	if ( _regenRate > 0.0f )
	{
		_amount += _regenRate * level.frametime;

		if ( _amount > _maxAmount )
		{
			_amount = _maxAmount;
		}

		setDispenserAlpha();
	}

	// Do necessary animation stuff

	playerNearby = false;

	if ( _state != DISPENSER_STATE_EMPTY )
	{
		// Get the player

		player = (Player *)g_entities[ 0 ].entity;

		// See if the player is nearby

		if ( player )
		{
			dir = player->origin - origin;
			distance = dir.length();

			if ( distance < _openDistance )
			{
				playerNearby = true;
			}
		}
	}

	if ( _state == DISPENSER_STATE_CLOSED )
	{
		if ( playerNearby )
		{
			animate->RandomAnimate( "opening", EV_Dispenser_AnimDone );
			_state = DISPENSER_STATE_OPENING;
		}
	}
	else if ( _state == DISPENSER_STATE_OPEN )
	{
		if ( !playerNearby )
		{
			animate->RandomAnimate( "closing", EV_Dispenser_AnimDone );
			_state = DISPENSER_STATE_CLOSING;
		}
	}
}

//----------------------------------------------------------------
// Name:			useEvent
// Class:			Dispenser
//
// Description:		This is what is called when the dispenser is used by something.
//					This function dispenses whatever it needs to here.
//
// Parameters:		Event *ev		- event (contains using entity)
//
// Returns:			None
//----------------------------------------------------------------

void Dispenser::useEvent( Event *ev )
{
	Sentient *sent;
	Entity *ent;


	// Make sure we should bother trying to give something out

	if ( _amount <= 0 )
		return;

	if ( _lastTimeUsed == level.time )
		return;

	//if ( _state != DISPENSER_STATE_OPEN )
	//	return;

	// Get the entity that is using us

	ent = ev->GetEntity( 1 );

	if ( !ent->isSubclassOf( Sentient ) )
		return;

	sent = (Sentient *)ent;

	if ( _instant )
	{
		_entityDispensingTo = sent;
	}
	else
	{
		dispenseStuff( sent );
	}

	_lastTimeUsed = level.time;
}

bool Dispenser::dispenseStuff( Sentient *sent )
{
	DispenseType currentDispenseType = DISPENSE_TYPE_HEALTH;
	float maxAmountToGive;
	float amountToGive;
	float entityMaxAmount = 0.0f;
	float entityCurrentAmount = 0.0f;

	if ( !_playingSound )
	{
		LoopSound( _useSoundName );
		_playingSound = true;
	}

	_lastSoundTime = level.time;

	// Get the max amount/current amount of this type of thing for this entity

	if ( _dispenseType == DISPENSE_TYPE_HEALTH )
	{
		entityMaxAmount     = sent->getMaxHealth();
		entityCurrentAmount = sent->getHealth();

		currentDispenseType = DISPENSE_TYPE_HEALTH;

		if ( entityCurrentAmount == entityMaxAmount )
		{
			entityMaxAmount     = 100.0f;
			entityCurrentAmount = sent->GetArmorValue();

			currentDispenseType = DISPENSE_TYPE_ARMOR;
		}
	}
	else if ( _dispenseType == DISPENSE_TYPE_AMMO )
	{
		entityMaxAmount     = sent->MaxAmmoCount( _dispenseSubtype );
		entityCurrentAmount = sent->AmmoCount( _dispenseSubtype );

		currentDispenseType = DISPENSE_TYPE_AMMO;
	}

	// Calculate the amount to give

	maxAmountToGive = _dispenseRate * level.frametime;

	if ( _dispenseType == DISPENSE_TYPE_AMMO )
	{
		amountToGive = maxAmountToGive;
	}
	else
	{
		if ( maxAmountToGive > entityMaxAmount - entityCurrentAmount )
			amountToGive = entityMaxAmount - entityCurrentAmount;
		else
			amountToGive = maxAmountToGive;
	}

	if ( amountToGive > _amount )
		amountToGive = _amount;

	if ( amountToGive < 0.0f )
		amountToGive = 0.0f;

	// Give the calculated amount to the entity

	if ( amountToGive )
	{
		if ( currentDispenseType == DISPENSE_TYPE_HEALTH )
		{
			sent->setHealth( entityCurrentAmount + amountToGive );
		}
		else if ( currentDispenseType == DISPENSE_TYPE_ARMOR )
		{
			Event *armorEvent = new Event( EV_Sentient_GiveArmor );
			armorEvent->AddString( "BasicArmor" );
			armorEvent->AddFloat( amountToGive );
			sent->ProcessEvent( armorEvent );
		}
		else if ( currentDispenseType == DISPENSE_TYPE_AMMO )
		{
			int ammoGiven;
			ammoGiven = (int) sent->GiveAmmo( _dispenseSubtype, (int)amountToGive, false );
			amountToGive = ammoGiven;
		}
	}

	// Use up our amount

	_amount -= amountToGive;

	setDispenserAlpha();

	// See if we are empty now

	if ( ( _amount <= 0.0f ) && ( _regenRate == 0.0f ) )
	{
		animate->RandomAnimate( "emptying", EV_Dispenser_AnimDone );
		_state = DISPENSER_STATE_EMPTYING;
	}

	if ( amountToGive > 0 )
		return true;
	else
		return false;
}

//----------------------------------------------------------------
// Name:			setMaxAmount
// Class:			Dispenser
//
// Description:		Sets the maximum amount that we can dispense. It
//					also sets the current amount to the maximum amount.
//
// Parameters:		Event *ev		- event (contains max amount)
//
// Returns:			None
//----------------------------------------------------------------

void Dispenser::setMaxAmount( Event *ev )
{
	_maxAmount = ev->GetFloat( 1 );

	_amount = _maxAmount;
}

//----------------------------------------------------------------
// Name:			setDispenseRate
// Class:			Dispenser
//
// Description:		Sets the rate that we will dispense stuff in units per second.
//
// Parameters:		Event *ev		- event (contains dispense rate)
//
// Returns:			None
//----------------------------------------------------------------

void Dispenser::setDispenseRate( Event *ev )
{
	_dispenseRate = ev->GetFloat( 1 );
}

//----------------------------------------------------------------
// Name:			setRegenRate
// Class:			Dispenser
//
// Description:		Sets the regen rate that we will regenerate our 
//					amount we can give out.  Only does this is below its maximum
//					amount.  This is also in units per second.
//
// Parameters:		Event *ev		- event (contains regen rate)
//
// Returns:			None
//----------------------------------------------------------------

void Dispenser::setRegenRate( Event *ev )
{
	_regenRate = ev->GetFloat( 1 );
}

//----------------------------------------------------------------
// Name:			setType
// Class:			Dispenser
//
// Description:		Sets the type of stuff we are giving out (health, ammo, etc.)
//
// Parameters:		Event *ev		- event (contains type)
//
// Returns:			None
//----------------------------------------------------------------

void Dispenser::setType( Event *ev )
{
	str typeName;

	typeName = ev->GetString( 1 );

	if ( typeName == "health" )
	{
		_dispenseType = DISPENSE_TYPE_HEALTH;
	}
	else if ( typeName == "ammo" )
	{
		_dispenseType = DISPENSE_TYPE_AMMO;
	}
	else
	{
		gi.WDPrintf( "Unknown dispense type %s\n", typeName.c_str() );
		_dispenseType = DISPENSE_TYPE_NONE;
	}
}

//----------------------------------------------------------------
// Name:			setSubtype
// Class:			Dispenser
//
// Description:		Sets the subtype of the thing we are giving out.
//					For ammo - this is the ammo type
//
// Parameters:		Event *ev		- event (contains subtype)
//
// Returns:			None
//----------------------------------------------------------------

void Dispenser::setSubtype( Event *ev )
{
	_dispenseSubtype = ev->GetString( 1 );
}

//----------------------------------------------------------------
// Name:			setOpenDistance
// Class:			Dispenser
//
// Description:		Sets the distance from the player that the dispenser will open/close
//
// Parameters:		Event *ev		- event (contains open distance)
//
// Returns:			None
//----------------------------------------------------------------

void Dispenser::setOpenDistance( Event *ev )
{
	_openDistance = ev->GetFloat( 1 );
}

//----------------------------------------------------------------
// Name:			animDone
// Class:			Dispenser
//
// Description:		Called when on of the dispenser's animation is done playing
//
// Parameters:		Event *						- not used
//
// Returns:			None
//----------------------------------------------------------------

void Dispenser::animDone( Event * )
{
	// The animation is done playing so, move the dispenser to the correct state and play the appropriate animation

	if ( _state == DISPENSER_STATE_CLOSING )
	{
		animate->RandomAnimate( "closed_idle" );
		_state = DISPENSER_STATE_CLOSED;
	}
	else if ( _state == DISPENSER_STATE_OPENING )
	{
		animate->RandomAnimate( "open_idle" );
		_state = DISPENSER_STATE_OPEN;
	}
	else if ( _state == DISPENSER_STATE_EMPTYING )
	{
		animate->RandomAnimate( "empty_idle" );
		_state = DISPENSER_STATE_EMPTY;
	}
}

//----------------------------------------------------------------
// Name:			setDispenserAlpha
// Class:			Dispenser
//
// Description:		Sets the alpha of the dispenser based on how much amount is left
//
// Parameters:		None
//
// Returns:			None
//----------------------------------------------------------------

void Dispenser::setDispenserAlpha( void )
{
	float percentLeft;

	if ( _maxAmount )
	{
		percentLeft = _amount / _maxAmount;

		setAlpha( percentLeft );
		G_SetConstantLight( &edict->s.constantLight, &percentLeft, &percentLeft, &percentLeft, 0 );
	}
}

//----------------------------------------------------------------
// Name:			setInstant
// Class:			Dispenser
//
// Description:		Sets this dispenser to give out stuff instant (only have to hit use once)
//
// Parameters:		None
//
// Returns:			None
//----------------------------------------------------------------

void Dispenser::setInstant( Event * )
{
	_instant = qtrue;
}

void Dispenser::setSoundName( Event *ev )
{
	_useSoundName = ev->GetString( 1 );
}