U2.NIU2

//=============================================================================
// NIU2.uc
// Created By: Mike Fox
// Created On: 2/5/00
// $Author: Sbrown $
// $Date: 8/15/02 21:24 $
// $Revision: 5 $
//=============================================================================

class NIU2 extends U2Mutator config(NIU2);

/*=============================================================================
Unreal II "No Item" Mutator -- plagerized from NIUT.

=== Overview ===

Removes all weapon pickups from the game and controls the weapons that players
have, including the default weapon. 

Everyone plays with the same weapon(s) at all times.

Specified weapons can be cycled or given all at once to players.

When cycling weeapons, the current weapon changes every 
MinTimeBetweenWeaponSwitches..MaxTimeBetweenWeaponSwitches (exact time
determined randomly -- to force a specific delay, make these equal).
  
Weapons can be selected randomly/sequentially (bRandomWeapons=true/false).

Non-weapon pickups in the level are generally either removed, replaced with
health or replaced with ammo for the current weapon if weapons are being
cycled but it is possible to force specific pickups to remain in the game.

If weapons are selected randomly can force all weapons to be used at least
once before restarting the selection process (bUseAllWeapons=true).
 
Plays a warning sound just before weapon is changed (WarningSoundStr).

Server automatically increments health of all players by HealthIncrementRate
units per second.

When not cycling weapons, server automatically increments ammo for all
weapons at a "reasonable" rate.
 
//!!mdf-tbd: separate mutator(s):
//Option to randomly give everyone jump boots, invisibility, power amplifier.
 
Can specify max ammo that any weapon can carry.

MaxHealth option for auto-incremented health (5000 with Redeemer is fun).

StartHealth option to control health that pawns start with.

Can specify how much ammo should be given per second (ammo is still 
incremented on each TimeBetweenAmmoIncrements).

InitialAmmoXXX settings to specify how much ammo weapons should have
when given to players (bots). Setting this to 0 means that the weapon will
have no ammo (and won't be available until ammo is found/given to the player).

Actually give more ammo to a weapon that it normally allows (e.g. can start out 
with redeemers with 99 warheads) and this becomes the new maximum for the weapon.
  
If bCycleWeapons is false players get all weapons specified in NIU2.ini and
ammo auto-increments -- pickups are health vials.

If TimeBetweenAmmoIncrements is > 0.0, ammo auto-increments by 1 unit every N
seconds where N is determined by settings in NIU2.ini. Pickups are health 
vials.

=== Details ===

Current weapon is chosen from a configurable list of weapons and should support 
any Weapon-derived classes, including non-U2 weapons.

NIU2 generally removes all pickups in the level and replaces these with health
pickups or ammo for the current weapon if weapons are being cycled (tbd: this 
is only really done to give the bots "something to go after when roaming -- 
!!mdf-tbd: change bot code to pick reasonable destinations when there is no 
inventory). 

Each time a Pawn (player / bot) joins the game or respawns, all weapons in the 
Pawn's inventory at that point are removed. This is also done when cycling
weapons and when the current weapon changes.

The KeptClassStrings list can be used to force specific pickups or weapons to 
remain in the game (e.g. PowerSuits, Weapon-derived accessories like translocators
and grappling hooks etc.).

To have some weapons used more frequently that others, just put them
in WeaponInfo more than once.

CheckReplacement also only strips out known weapons (unless bForceWeaponSpawn
is set internally).

Logging in PreBeginPlay (number of weapons) and log info if no weapons found.

Logging each time the weapon is changed, including the number of (real) players 
in the game.
  
Default to just 1 weapon in slot 0 of the WeaponInfo -- rocket launcher
so that you don't have to override a pile of unused slots if you have < N 
weapons.

Default time between weapon switches is 5 secs. Might help to avoid server
crashes which can occur when many objects created and destroyed before a level
ends (old UT bug, not sure if this is still an issue with UW).

NOTE: if 2 or more weapons use the same ammo, only one set of initial/max/rate 
values will be used for the ammo. Ideally, weapons should always use their own 
unique ammo type (e.g. just subclass the type you want to use).

===============================================================================
tbd:

Check zone before healing (shouldn't heal if drowning, in lava etc.).

Not sure starthealth and maxhealth being used correctly.

Add a timer to the HUD to show next weapon switch (when applicable)?

Eliminate TimeBetweenAmmoIncrements as a config var? Users shouldn't ever need
to worry about this (oops -- what if they want cycle weapons with increment
ammo -- change to a bool?)

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

const MaxWeaponClasses	= 64;
const MaxKeptClasses	= 32;

//-----------------------------------------------------------------------------

// used in .ini (can contain gaps and/or disabled weapons)
struct WeaponInfoRawT
{
	var() config string		WeaponClassString;	// weapon class string
	var() config int		InitialAmmo;		// initial ammo for weapon
	var() config int		MaxAmmo;			// max ammo for weapon
	var() config float		AmmoPerSecond;		// rate at which ammo added
	var() config bool		bEnabled;			// whether weapon is enabled
};

// used internally (packed with enabled weapons only)
struct WeaponInfoT
{
	var   class<Weapon>		WeaponClass;		// weapon class
	var   int				InitialAmmo;		// initial ammo for weapon
	var   int				MaxAmmo;			// max ammo for weapon
	var   float				AmmoPerSecond;		// rate at which ammo added
	var   float				AmmoCount;			// used internally to track ammo to add
	var   bool				bUsed;				// weapon was used (used with bUseAllWeapons when picking weapon randomly)
};

//-----------------------------------------------------------------------------
// configurable properties

var() config bool bRandomWeapons;							// (true): true ==> weapons selected randomly, false ==> weapons cycled sequentially
var() config bool bUseAllWeapons;							// (true): true ==> if bWeaponsRandom is true, all weapons used once per cycle
var() config bool bCycleWeapons;							// (true): false ==> players get all weapons in weapons list with auto-incrementing ammo

var() config WeaponInfoRawT WeaponInfo[ MaxWeaponClasses ];	// list of weapons to use with ammo info
var() config string KeptClassStrings[ MaxKeptClasses ];		// list of classes to leave alone

var() config float  TimeBetweenWeaponSwitchesMin;			// (45): min secs between weapon switches
var() config float  TimeBetweenWeaponSwitchesMax;			// (45): max secs between weapon switches
var() config float  TimeBetweenAmmoIncrements;				// (0.0): >0.0 ==> auto-increment ammo at this rate
var() config string WarningSoundStr;						// (U2CTF.CTFTaken): sound to use for "about to switch" warning
var() config int    WarningSoundRepeats;					// (3): # times to repeat WarningSound
var() config string HealthIncrementSoundStr;				// (None): sound to play when incrementing player's health
var() config int    HealthIncrementAmount;					// (0): rate at which health of players is incremented
var() config int    StartHealth;								// (100): health that pawns start out with
var() config int    MaxHealth;								// (100): max that health can be auto-incremented to
var() config float  TimeBetweenHealthIncrements;				// (5): secs between health updates if HealthIncrementRate >= 1

var() string DefaultPickupString;							// default replacement for pickups when not keeping ammo

//-----------------------------------------------------------------------------
// internal properties

var int NumWeapons;											// number of active weapons in internal list
var WeaponInfoT FilteredWeaponInfo[ MaxWeaponClasses ];		// filtered list of weapon classes to use and ammo info
var class<Weapon> CurrentWeaponClass;						// current weapon class
var int CurrentWeaponIndex;									// index into FilteredWeaponInfo for current weapon
var int NumUsedWeapons;										// number of weapons used so far (used with bUseAllWeapons)
var int NumWarnings;										// did "about to switch" warning
var float NextChooseWeaponTime;								// when to switch again
var float ChooseWeaponWarningTime;    						// secs before weapon switch to warn clients
var float NextIncrementHealthTime;    						// when to do another pass through player health values
var float NextAmmoIncrementTime;							// when to increment ammo
var int NumKeptClasses;										// number of classes in KeptClassStrings list
var class<Actor> KeptClasses[ MaxKeptClasses ];				// list of classes to keep

var Sound WarningSound;										// loaded warning sound
var Sound HealthIncrementSound;								// loaded health increment sound
															
// utility variables										
var bool bDidTick;											// set after first tick occurs
var bool bForceWeaponSpawn;									// set to force CheckReplacement to return true for weapons

var string DefaultWeaponString;								// fallback weapon in case of problems
var class<Pickup> DefaultPickupClass;						// default replacement for pickups when not keeping ammo

const LOTSATIME = 99999.0;

//-----------------------------------------------------------------------------

function bool AddWeaponClass( string WeaponClassString, int Index )
{
	local class<Weapon> WeaponClass;
	local bool bResult;

	bResult = false;
	WeaponClass = class<Weapon>(DynamicLoadObject( WeaponClassString, class'Class' ));
	if( WeaponClass != None )
	{
		FilteredWeaponInfo[ Index ].WeaponClass = WeaponClass;
		bResult = true;
	}

	return bResult;
}

//-----------------------------------------------------------------------------

function AssignSounds()
{
	if( WarningSoundStr != "" )
	{
		WarningSound = Sound( DynamicLoadObject( WarningSoundStr, class'Sound' ));

		if( WarningSound == None )
			warn( "(NIU2): couldn't assign warning sound" );
	}

	if( HealthIncrementSoundStr != "" )
	{
		HealthIncrementSound = Sound( DynamicLoadObject( HealthIncrementSoundStr, class'Sound' ));

		if( HealthIncrementSound == None )
			warn( "(NIU2): couldn't assign health increment sound" );
	}
}

//-----------------------------------------------------------------------------
// Prepare list of weapon classes to use, initialize stuff. The first tick that
// this mutator receives will select the first weapon to use and give it to
// all players.

event PreBeginPlay()
{
	local int ii;
	local class<Actor> ActorClass;

	Super.PreBeginPlay();

	log( "Server is running NIU2." );

	// determine how many valid weapons we have
	NumWeapons=0;

	// weapons to use are specified through .ini
	for( ii=0; ii<MaxWeaponClasses; ii++ )
	{
		if( WeaponInfo[ii].WeaponClassString != "" && WeaponInfo[ii].bEnabled )
		{
			if( AddWeaponClass( WeaponInfo[ii].WeaponClassString, NumWeapons ) )
			{
				FilteredWeaponInfo[ NumWeapons ].InitialAmmo	= WeaponInfo[ii].InitialAmmo;
				FilteredWeaponInfo[ NumWeapons ].MaxAmmo		= WeaponInfo[ii].MaxAmmo;
				FilteredWeaponInfo[ NumWeapons ].AmmoPerSecond	= WeaponInfo[ii].AmmoPerSecond;
				FilteredWeaponInfo[ NumWeapons ].AmmoCount		= 0.0;
				NumWeapons++;
			}
			else
				warn( "WeaponInfo["$ii$"] is invalid: " $ WeaponInfo[ii].WeaponClassString );
		}
	}

	DefaultWeapon = None;
	DefaultWeaponName = "";

	log( "NIU2: " $ NumWeapons $ " weapons" );
	if( NumWeapons == 0 )
	{
		log( "WARNING: No weapons specified -- defaulting to " $ DefaultWeaponString );
		if( AddWeaponClass( DefaultWeaponString, 0 ) )
		{
			FilteredWeaponInfo[ 0 ].InitialAmmo		= 50;
			FilteredWeaponInfo[ 0 ].MaxAmmo			= 50;
			FilteredWeaponInfo[ 0 ].AmmoPerSecond	= 0.2;
			FilteredWeaponInfo[ 0 ].AmmoCount		= 0.0;
			NumWeapons = 1;
		}
		else
			warn( "DefaultWeaponString is invalid: " $ DefaultWeaponString );
	}
	else
	{
		for( ii=0; ii<NumWeapons; ii++ )
		{
			log( ii $ " : " $ FilteredWeaponInfo[ii].WeaponClass );
		}
	}

	DefaultPickupClass = class<Pickup>(DynamicLoadObject( DefaultPickupString, class'Class' ));
	if( DefaultPickupClass == None )
		warn( "DefaultPickupString is invalid: " $ DefaultPickupString );
	
	if( !bCycleWeapons )
	{
		// weapons never switch
		WarningSoundRepeats = 0;
		
		// ammo will be auto-incremented (pickups are health vials)
		if( TimeBetweenAmmoIncrements == 0.0 )
		{
			TimeBetweenAmmoIncrements = 1.0;
		}

		// call this here since ChooseWeapon will never be called		
		TransformPickups();
	}

	NextChooseWeaponTime = 0.0;
	NextIncrementHealthTime = 0.0;
	NumWarnings = WarningSoundRepeats;
	
	ChooseWeaponWarningTime = 0.0;
	if( WarningSound != None )
	{
		ChooseWeaponWarningTime = GetSoundDuration( WarningSound );
	}
		
	CurrentWeaponIndex = -1;
	ResetUsedWeapons();

	if( MaxHealth <= 0)
	{
		MaxHealth = class'Pawn'.default.Health;
	}

	if( StartHealth <= 0)
	{
		StartHealth = class'Pawn'.default.Health;
	}

	// set up list of classes to keep (optimization -- incur overhead once up-front)
	NumKeptClasses = 0;
	for( ii=0; ii<MaxKeptClasses; ii++ )
	{
		if( KeptClassStrings[ii] != "" )
		{
			ActorClass = class<Actor>(DynamicLoadObject( KeptClassStrings[ii], class'Class' ));

			if( ActorClass != None )
			{
				KeptClasses[ NumKeptClasses ] = ActorClass;
				NumKeptClasses++;
			}
			else
			{
				warn( "KeptClassStrings["$ii$"] is invalid: " $ KeptClassStrings[ii] );
			}
		}
	}

	AssignSounds();
}

//-----------------------------------------------------------------------------

function WeaponTimeDemoLog()
{
	local Controller C;

	for( C=Level.ControllerList; C!=None; C=C.NextController )
	{
		if( PlayerController(C)!=None && PlayerController(C).Player!=None && PlayerController(C).Player.Console!=None )
		{
			C.ConsoleCommand( "TimeDemo 0" );
			Log( CurrentWeaponClass.Name );
			C.ConsoleCommand( "TimeDemo 1" );
			break;
		}
	}
}

//-----------------------------------------------------------------------------
// Perform weapon switching etc. when the time is right.

// !!mdf-tbd: use timers instead?

event Tick( float DeltaTime )
{
	local Controller C;
	local Inventory Inv;
	
	Super.Tick( DeltaTime );

	// setup
	if( !bDidTick )
	{
		if( TimeBetweenAmmoIncrements > 0.0 )
		{
			NextAmmoIncrementTime = Level.TimeSeconds + TimeBetweenAmmoIncrements;
		}
		
		bDidTick = true;
	}
	else
	{
		// weapon switch warning
		if( (NumWarnings < WarningSoundRepeats) && (Level.TimeSeconds >= (NextChooseWeaponTime - (WarningSoundRepeats-NumWarnings)*ChooseWeaponWarningTime )) )
		{
			// warn that we are about to switch the weapon
			if( WarningSound != None )
			{
				for( C=Level.ControllerList; C!=None; C=C.NextController )
				{
					if( PlayerController(C)!=None )
					{
						PlayerController(C).PlaySound( WarningSound,, 8 );
					}
				}
			}
			
			NumWarnings++;
		}
	}
	
	// weapon switch	
	if( bCycleWeapons && Level.TimeSeconds >= NextChooseWeaponTime )
	{
		// time to change everybody's weapon
		
		ChooseWeapon();
		for( C=Level.ControllerList; C!=None; C=C.NextController )
			SetInventory( C.Pawn );
		
		WeaponTimeDemoLog();

		NumWarnings = 0;
		NextChooseWeaponTime = Level.TimeSeconds + RandRange(TimeBetweenWeaponSwitchesMin, TimeBetweenWeaponSwitchesMax);
	}
	
	// increment health
	if( (HealthIncrementAmount >= 1) && (Level.TimeSeconds >= NextIncrementHealthTime) )
	{
		for( C=Level.ControllerList; C!=None; C=C.NextController )
		{
			if( C.Pawn != None && C.Pawn.Health > 0 && C.Pawn.Health < MaxHealth )
			{
				C.Pawn.Health += Min( HealthIncrementAmount, MaxHealth - C.Pawn.Health );
				
				// play sound only if we won't spam the weapons switch warning (not playing if NumWarnings is 0
				if( HealthIncrementSound != None && (NumWarnings == 0) && (PlayerController(C) != None) )
				{
					C.PlaySound( HealthIncrementSound );
				}
			}
		}
		NextIncrementHealthTime = Level.TimeSeconds + TimeBetweenHealthIncrements;
	}
	
	// ammo
	if( (TimeBetweenAmmoIncrements > 0.0) && (Level.TimeSeconds >= NextAmmoIncrementTime) )
	{
		IncrementAllInventoryAmmo();
				
		NextAmmoIncrementTime = Level.TimeSeconds + TimeBetweenAmmoIncrements;
	}
}
	
//-----------------------------------------------------------------------------
// Clear used weapon list used to make sure all weapons are used at least once
// when bUseAllWeapons is set.

function ResetUsedWeapons()
{
	local int ii;
	
	for( ii=0; ii<NumWeapons; ii++ )
	{
		FilteredWeaponInfo[ ii ].bUsed = false;
	}
	
	NumUsedWeapons = 0;
}

//-----------------------------------------------------------------------------

function bool ShouldKeep( Actor Other )
{
	local int ii;
	local bool bRetVal;

	bRetVal = false;
	if( Pickup(Other) != None || Weapon(Other) != None )
	{
		// only keep pickups and weapons which are in the KeptClasses list
		for( ii=0; ii<NumKeptClasses; ii++ )
		{
			if( ClassIsChildOf( KeptClasses[ ii ], Other.Class ) )
			{
				bRetVal = true;
				break;
			}
		}
	}
	else if( Inventory(Other) == None )
	{
		// keep everything else except inventory
		bRetVal = true;
	}

	//DM( "ShouldKeep " $ Other $ ": " $ bRetVal );
	return bRetVal;
}

//-----------------------------------------------------------------------------

function TransformPickups()
{
	local Pickup Pickup;

	foreach AllActors( class'Pickup', Pickup )
	{
		if( Pickup.Owner == None )
		{
			if( !ShouldKeep( Pickup ) )
			{
				if( TimeBetweenAmmoIncrements > 0.0 )
				{
					//DM( "TimeBetweenAmmoIncrements > 0.0 -- replacing " $ Pickup $ " with " $ DefaultPickupClass );
					// replace pickups with health -- weapon ammo will be incremented
					if( ReplaceWithClass( Pickup, DefaultPickupClass ) )
						Pickup.Destroy();
				}
				else if( CurrentWeaponClass.default.AmmoName.default.PickupClass == None )
				{
					//DM( "Weapon ammo not set -- replacing " $ Pickup $ " with " $ DefaultPickupClass );
					// !!mdf-tbd: replace pickups with health -- keeps bot destination code happy
					if( ReplaceWithClass( Pickup, DefaultPickupClass ) )
						Pickup.Destroy();
				}
				else if( Pickup.Class != CurrentWeaponClass.default.AmmoName.default.PickupClass )
				{
					//DM( "replacing with current weapon ammo -- replacing " $ Pickup $ " with " $ CurrentWeaponClass.default.AmmoName.default.PickupClass );
					if( ReplaceWithClass( Pickup, CurrentWeaponClass.default.AmmoName.default.PickupClass ) )
						Pickup.Destroy();
				}
			}
		}
	}
}
	
//-----------------------------------------------------------------------------
// Select the next weapon to use and replace all pickup items in the level with
// ammo for this weapon, or health vials if the weapon doesn't require ammo.

function ChooseWeapon()
{
	local Inventory Inv;

//DM( "ChooseWeapon" );

	if( NumWeapons >= 1)
	{
		if( NumUsedWeapons == NumWeapons )
		{
			ResetUsedWeapons();
		}
	
		if( bRandomWeapons )
		{
			CurrentWeaponIndex = Rand( NumWeapons );
			
			if( bUseAllWeapons )
			{
				while( FilteredWeaponInfo[CurrentWeaponIndex].bUsed )
				{
					CurrentWeaponIndex++;
					if( CurrentWeaponIndex >= NumWeapons )
						CurrentWeaponIndex=0;
				}
			}
			
			NumUsedWeapons++;
			FilteredWeaponInfo[CurrentWeaponIndex].bUsed = true;
		}
		else
		{
			// use weapons sequentially (always starts with weapon #0)
			CurrentWeaponIndex++;
			if( CurrentWeaponIndex >= NumWeapons )
				CurrentWeaponIndex=0;
		}
					
		CurrentWeaponClass = FilteredWeaponInfo[ CurrentWeaponIndex ].WeaponClass;
		if( CurrentWeaponClass == None )
			warn( "CurrentDefaultWeapon is None!" );
	}
	else
	{
		warn( "ExtraWeaponsClassStrings contain no valid weapon(s)!" );
	}

	DM( "NIU2: " $ Level.TimeSeconds $ " (" $ Level.Game.NumPlayers $ ") -- selected: " $ CurrentWeaponClass );
	
	TransformPickups();

	NextChooseWeaponTime = Level.TimeSeconds + RandRange( TimeBetweenWeaponSwitchesMin, TimeBetweenWeaponSwitchesMax );
}

//-----------------------------------------------------------------------------
// Give W Amount units of ammo, increasing ammo's MaxAmmo if necessary and make
// sure the weapon doesn't end up with *more* than Amount units of ammo. NOTE:
// Amount can be greater than Max (weapons can start out with more than the max
// ammo if set up that way in the .ini) so MaxAmmo can temporarily exceed Max
// when giving initial Amount below.

function SetWeaponAmmo( Weapon W, Pawn Other, int Amount, int Max )
{
//DM( "SetWeaponAmmo:" );

	if( W.AmmoName != None )
	{
		W.AmmoType = Ammunition(Other.FindInventoryType( W.AmmoName ));
		if( W.AmmoType != None )
		{
			if( W.AmmoType.MaxAmmo < Amount )
				W.AmmoType.MaxAmmo = Amount;
			W.AmmoType.AddAmmo( Amount );
		}
		else
		{
			W.AmmoType = Spawn( W.AmmoName );	// Create ammo type required		
			W.AmmoType.GiveTo( Other );			// and add to player's inventory

			if( W.AmmoType.MaxAmmo < Amount )
				W.AmmoType.MaxAmmo = Amount;
			W.AmmoType.AmmoAmount = Amount; 
		}

		// .ini can decide to override normal MaxAmmo
		if( Max > 0 )
			W.AmmoType.MaxAmmo = Max;

		// make sure weapon doesn't have *more* than the specified amount.
		if( W.AmmoType.AmmoAmount > Amount )
			W.AmmoType.AmmoAmount = Amount;

		// make sure amount in chamber is <= total amount
		if( U2Ammo(W.AmmoType) != None )
			U2Ammo(W.AmmoType).ClipRoundsRemaining = Min( U2Ammo(W.AmmoType).ClipRoundsRemaining, W.AmmoType.AmmoAmount );
	}
}	

//-----------------------------------------------------------------------------

function GiveWeaponTo( Pawn P, Class<Weapon> WeaponClass )
{
	local Weapon NewWeapon;
	local int ii, FoundIndex;

	bForceWeaponSpawn = true;

	NewWeapon = Spawn( WeaponClass ); // NOTE: WeaponClass may be replaced...
	if( NewWeapon != None )
	{
		NewWeapon.GiveTo( P );

		FoundIndex = -1;
		if( bCycleWeapons )
		{
			// !!mdf-tbr: only Weapon should be that for current weapon (not true on startup?)
			//DM( "GiveWeaponTo -- WeaponClass: " $ WeaponClass $ " NewWeapon: " $ NewWeapon );
			//DM( " CurrentWeaponIndex: " $ CurrentWeaponIndex $ " CurrentClass: " $ FilteredWeaponInfo[ CurrentWeaponIndex ].WeaponClass );
			assert( FilteredWeaponInfo[ CurrentWeaponIndex ].WeaponClass == WeaponClass );
			FoundIndex = CurrentWeaponIndex;
		}
		else
		{
			for( ii=0; ii<NumWeapons; ii++ )
			{
				if( FilteredWeaponInfo[ ii ].WeaponClass == WeaponClass )
				{
					FoundIndex = ii;
					break;
				}
			}
		}
		if( FoundIndex != -1 )
		{
	 		SetWeaponAmmo( NewWeapon, P, FilteredWeaponInfo[ FoundIndex ].InitialAmmo, FilteredWeaponInfo[ FoundIndex ].MaxAmmo) ;
		}
		else
		{
			// !!mdf-tbr: specified weapon should always be found
			assert( false );
		}

		NewWeapon.BringUp();
		NewWeapon.bCanThrow = false; // don't allow the weapon to be thrown out
	}
	
	bForceWeaponSpawn = false;
}

//-----------------------------------------------------------------------------
// Set the given Pawn's weapon to the current one. Get rid of all inventory
// before doing this.

function SetInventory( Pawn P )
{
	local Inventory Inv;
	local int WeaponIndex;

//DM( Self$".SetInventory( "$P$" ) ***** "$ CurrentWeaponClass );
	if( P != None )
	{	
		// zap any current inventory and weapons before we give the NIU2 weapon(s) below
		for( Inv=P.Inventory; Inv!=None; Inv=Inv.Inventory ) 
		{
			if( !ShouldKeep( Inv ) )
			{
				//DM( "SetInventory Filtering Item: " $ Inv );
				P.DeleteInventory( Inv );
				Inv.Destroy();
			}
		}
	
		if( !bCycleWeapons )		
		{
			for( WeaponIndex=0; WeaponIndex<NumWeapons; WeaponIndex++ )
				GiveWeaponTo( P, FilteredWeaponInfo[ WeaponIndex ].WeaponClass );
		}
		else if( CurrentWeaponClass != None )
		{
			GiveWeaponTo( P, CurrentWeaponClass );
		}
	}
}

//-----------------------------------------------------------------------------

function AddAmmo( Ammunition AInv, int Amount )
{
//DM( "  AddAmmo: " $ AInv $ " " $ Amount );
	AInv.AmmoAmount += Amount;
	if( AInv.AmmoAmount > AInv.MaxAmmo )
		AInv.AmmoAmount = AInv.MaxAmmo;
}

//-----------------------------------------------------------------------------

function IncrementAllInventoryAmmo()
{
	local Inventory Inv;
	local Controller C;
	local int ii, FoundIndex;
	local bool bCheckInventory;
				
//DMT( "IncrementAllInventoryAmmo:" );

	// increment counters
	bCheckInventory = false; // track whether any counters reach an integer amount (otherwise avoid expensive inventory walk)
	if( bCycleWeapons )
	{
		FilteredWeaponInfo[ CurrentWeaponIndex ].AmmoCount += FilteredWeaponInfo[ CurrentWeaponIndex ].AmmoPerSecond*TimeBetweenAmmoIncrements;
		if( int(FilteredWeaponInfo[ CurrentWeaponIndex ].AmmoCount) >= 1 )
			bCheckInventory = true;
		//DM( " FilteredWeaponInfo[ CurrentWeaponIndex ].AmmoCount: " $ FilteredWeaponInfo[ CurrentWeaponIndex ].AmmoCount );
	}
	else
	{
		for( ii=0; ii<NumWeapons; ii++ )
		{
			FilteredWeaponInfo[ ii ].AmmoCount += FilteredWeaponInfo[ ii ].AmmoPerSecond*TimeBetweenAmmoIncrements;
			if( int(FilteredWeaponInfo[ ii ].AmmoCount) >= 1 )
				bCheckInventory = true;
		}
	}

	if( bCheckInventory )
	{	
		// increment ammo amount in all matching inventory
		for( C=Level.ControllerList; C!=None; C=C.NextController )
		{
			if( C.Pawn != None )
			{
				for( Inv=C.Pawn.Inventory; Inv!=None; Inv=Inv.Inventory ) 
				{
					if( Ammunition(Inv) != None )
					{
						// find weapon in list which uses this ammo
						FoundIndex = -1;
						if( bCycleWeapons )
						{
							// !!mdf-tbr: only Ammunition should be that for current weapon?
							//DM( " CurrentWeaponIndex: " $ CurrentWeaponIndex );
							//DM( " FilteredWeaponInfo[ CurrentWeaponIndex ]: " $ FilteredWeaponInfo[ CurrentWeaponIndex ].WeaponClass );
							//DM( " FilteredWeaponInfo[ CurrentWeaponIndex ].WeaponClass.default.AmmoName: " $ FilteredWeaponInfo[ CurrentWeaponIndex ].WeaponClass.default.AmmoName );
							//DM( " Inv.Class: " $ Inv.Class );
							assert( FilteredWeaponInfo[ CurrentWeaponIndex ].WeaponClass.default.AmmoName == Inv.Class );
							FoundIndex = CurrentWeaponIndex;
						}
						else
						{
							for( ii=0; ii<NumWeapons; ii++ )
							{
								if( FilteredWeaponInfo[ ii ].WeaponClass.default.AmmoName == Inv.Class )
								{
									FoundIndex = ii;
									break;
								}
							}
						}
						if( FoundIndex != -1 )
						{
							// !!mdf-tbr: should always find Ammunition?
							if( int(FilteredWeaponInfo[ FoundIndex ].AmmoCount) >= 1 )
								AddAmmo( Ammunition(Inv), int(FilteredWeaponInfo[ FoundIndex ].AmmoCount) );
						}
						else
							assert( false);
					}
				}
			}
		}
	}

	// re-baseline counters (only keep non-integer remainder, if any)
	if( bCycleWeapons )
	{
		if( FilteredWeaponInfo[ CurrentWeaponIndex ].AmmoCount >= 1.0 )
			FilteredWeaponInfo[ CurrentWeaponIndex ].AmmoCount -= int(FilteredWeaponInfo[ CurrentWeaponIndex ].AmmoCount);
	}
	else
	{
		for( ii=0; ii<NumWeapons; ii++ )
		{
			if( FilteredWeaponInfo[ ii ].AmmoCount >= 1.0 )
				FilteredWeaponInfo[ ii ].AmmoCount -= int(FilteredWeaponInfo[ ii ].AmmoCount);
		}
	}
}

//-----------------------------------------------------------------------------
// Make sure everyone is using the correct weapon, ammo no matter when they
// join the game or respawn.

function ModifyPlayer( Pawn Other )
{
//DMN( "ModifyPlayer( "$ Other $ " )" );
	if ( NextMutator != None )
	{
		NextMutator.ModifyPlayer(Other);
	}
	
	SetInventory( Other );

	if( StartHealth != 0 )
	{
		Other.Health = StartHealth;
	}
}

//-----------------------------------------------------------------------------
// Return true for any Actor which is in the KeptClasses list.

function bool AlwaysKeep( Actor Other )
{
	local bool bRetVal;

//DM( "AlwaysKeep" );
	
	bRetVal = false;
	if( ShouldKeep( Other ) )
	{
		bRetVal = true;
	}
	if( NextMutator != None )
	{
		bRetVal = NextMutator.AlwaysKeep(Other);
	}

	return bRetVal;
}			

//-----------------------------------------------------------------------------

function bool CheckReplacement( Actor Other, out byte bSuperRelevant )
{
	local bool bRetVal;

	//DM( "CheckReplacement begin : " $ Other );

	bRetVal = true;

	if( bForceWeaponSpawn )
	{
		//DM( "Setting bSuperRelevant" );
		bSuperRelevant = 1;
	}
	else if( Weapon(Other) != None && !ShouldKeep( Weapon(Other) ) )
	{
		// Filter weapons by replacing them with the current weapon (if set) or by
		// removing them since some games (e.g. Last Man Standing) try to give 
		// players weapons sometime after players join the game.
		if( CurrentWeaponIndex != -1 && FilteredWeaponInfo[ CurrentWeaponIndex ].WeaponClass != None )
			ReplaceWithClass( Other, FilteredWeaponInfo[ CurrentWeaponIndex ].WeaponClass );

		bRetVal = false;
	}

	//DM( "CheckReplacement returning " $ bRetVal $ " for " $ Other );

	return bRetVal;
}

//-----------------------------------------------------------------------------
// No weapon by default -- this mutator hands out all weapons.

function class<Weapon> MyDefaultWeapon()
{
	return None;
}

//-----------------------------------------------------------------------------

defaultproperties
{
	bUseAllWeapons=true
	bCycleWeapons=true
	WeaponInfo(0)=(WeaponClassString="U2Weapons.weaponInvAssaultRifle",InitialAmmo=50,MaxAmmo=100,AmmoPerSecond=1.000000)
	WeaponInfo(1)=(WeaponClassString="U2Weapons.weaponInvEnergyRifle",InitialAmmo=50,MaxAmmo=200,AmmoPerSecond=1.000000)
	WeaponInfo(2)=(WeaponClassString="U2Weapons.weaponInvFlameThrower",InitialAmmo=50,MaxAmmo=200,AmmoPerSecond=1.000000,bEnabled=true)
	WeaponInfo(3)=(WeaponClassString="U2Weapons.weaponInvGrenadeLauncher",InitialAmmo=10,MaxAmmo=50,AmmoPerSecond=0.200000,bEnabled=true)
	WeaponInfo(4)=(WeaponClassString="U2Weapons.weaponInvLaserRifle",InitialAmmo=10,MaxAmmo=100,AmmoPerSecond=0.200000,bEnabled=true)
	WeaponInfo(5)=(WeaponClassString="U2Weapons.weaponInvLeechGun",InitialAmmo=25,MaxAmmo=100,AmmoPerSecond=0.500000)
	WeaponInfo(6)=(WeaponClassString="U2Weapons.weaponInvPistol",InitialAmmo=25,MaxAmmo=50,AmmoPerSecond=0.500000,bEnabled=true)
	WeaponInfo(7)=(WeaponClassString="U2Weapons.weaponInvRocketLauncher",InitialAmmo=10,MaxAmmo=50,AmmoPerSecond=0.200000,bEnabled=true)
	WeaponInfo(8)=(WeaponClassString="U2Weapons.weaponInvShotgun",InitialAmmo=25,MaxAmmo=50,AmmoPerSecond=0.200000)
	WeaponInfo(9)=(WeaponClassString="U2Weapons.weaponInvSingularityCannon",InitialAmmo=10,MaxAmmo=50,AmmoPerSecond=0.200000)
	WeaponInfo(10)=(WeaponClassString="U2Weapons.weaponInvSniperRifle",InitialAmmo=20,MaxAmmo=50,AmmoPerSecond=0.200000,bEnabled=true)
	WeaponInfo(11)=(WeaponClassString="U2Weapons.weaponInvTakkra",InitialAmmo=5,MaxAmmo=5,AmmoPerSecond=0.200000)
	KeptClassStrings(0)="U2.PowerSuit"
	KeptClassStrings(1)="U2.PowerSuitPickup"
	KeptClassStrings(2)="U2.HumanEnergyPickup"
	TimeBetweenWeaponSwitchesMin=30.000000
	TimeBetweenWeaponSwitchesMax=30.000000
	TimeBetweenAmmoIncrements=1.000000
	WarningSoundStr="U2CTF.CTFTaken"
	WarningSoundRepeats=3
	StartHealth=100
	MaxHealth=100
	TimeBetweenHealthIncrements=5.000000
	DefaultPickupString="U2.HumanHealthPickup"
	DefaultWeaponString="U2Weapons.WeaponInvRocketLauncher"
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}