class MutSchlonzUT extends Mutator
    config(SchlonzUT);

// blarg
var() config bool SchlonzRedeemerEnable;
var() config bool SchlonzEnforcerEnable;
var() config bool SchlonzBioRifleEnable;
var() config bool SchlonzShockRifleEnable;
var() config bool SchlonzPlasmaRifleEnable;
var() config bool SchlonzMinigunEnable;
var() config bool SchlonzFlakCannonEnable;
var() config bool SchlonzRocketLauncherEnable;
var() config bool SchlonzSniperRifleEnable;
var() config bool NoSuperWeaponsEnable;
var() config bool SchlonzStatsEnable;
var() config string SchlonzStatsServer;
var() config int StatsIP;
var() config int StatsPort;
var() config bool SchlonzCampEnable;
var() config int CampTime;
var() config int CampRadius;
var() config float CampMaxBotSize;
var() config float CampMaxPlayerSize;

var bool bInitialized;
var bool CampEnable;

struct PInfo
{
	var int		PlayerID;
	var vector	PlayerLoc;
};

var array<PInfo> OldPlayer;
var array<PInfo> CurrentPlayer;
var float CurrentCampTime;


event PreBeginPLay()
{
	local SchlonzGameRules sgr;

	//log( "################# MutSchlonzUT PreBeginPLay #############" );
	if( Level != None )
	{
		//log( "----- have Level" );
		if( Level.Game != None )
		{
			sgr = Spawn( class'SchlonzUT.SchlonzGameRules' );
			if( sgr != None && Level.NetMode == NM_DedicatedServer )
			{
				if( SchlonzStatsEnable )
				{
					if( sgr.Init( StatsIP, StatsPort ) )
					{
						sgr.NextGameRules = Level.Game.GameRulesModifiers;
						Level.Game.GameRulesModifiers = sgr;
						log( "----- installed SchlonzGameRules" );
						sgr.LogStartGame();
					}
				}
			}
		}
	}
	//log( "***************** MutSchlonzUT PreBeginPLay *************" );

	// start camping
	CampEnable = False;
    CurrentCampTime = 0.0;
	if( Level != None )
	{
		if( Level.NetMode == NM_DedicatedServer && SchlonzCampEnable )
		{
			CampEnable = True;
			// Enable('Tick');
		}
	}

}

function PostBeginPlay()
{
	Level.KarmaGravScale = 0.0;
	Level.Game.PlayerControllerClassName = "SchlonzUT.SchlonzControllerPlayer";
	class'xPawn'.Default.ControllerClass = class'SchlonzUT.SchlonzControllerBot';
}

function ModifyPlayer(Pawn Other)
{
	if( Other.PlayerReplicationInfo.PlayerName == "Huarglio" ||
		Other.PlayerReplicationInfo.PlayerName == "Schlonz" ||
		Other.PlayerReplicationInfo.PlayerName == "Killertux" )
	{
		
		Other.GroundSpeed = 600;		// default is 440
		Other.MaxFallSpeed = 5100;		// default is 1220
		Other.HealthMax=200;			// default is 100
		Other.JumpZ=660;				// default is 440
	}
	if( Other.PlayerReplicationInfo.bBot )
	{
//		if( SchlonzXPawnBot( Other ) != None )
//			SchlonzXPawnBot( Other ).SetPawnBotSize( -0.4 );

		xPawn(Other).RagDeathUpKick = 99;
	    xPawn(Other).RagdollLifeSpan = 150;
	}

	Super.ModifyPlayer(Other);
}

function Initialize()
{
	bInitialized = true;

	if (SchlonzEnforcerEnable)
	{
		DefaultWeaponName = "SchlonzUT.SchlonzAssaultRifle";
		DefaultWeapon = class'SchlonzUT.SchlonzAssaultRifle';
	}
}

function string GetInventoryClassOverride(string InventoryClassName)
{
	// here, in mutator subclass, change InventoryClassName if desired.  For example:
	if ( InventoryClassName == "XWeapons.TransLauncher")
			InventoryClassName = "SchlonzUT.SchlonzTransLauncher";

	if ( InventoryClassName == "XWeapons.ShieldGun")
			InventoryClassName = "SchlonzUT.SchlonzShieldGun";


	if ( NextMutator != None )
		return NextMutator.GetInventoryClassOverride(InventoryClassName);
	return InventoryClassName;
}

function bool CheckReplacement( Actor Other, out byte bSuperRelevant )
{
	if ( !bInitialized )
		Initialize();

	bSuperRelevant = 0;

/*
	if( (ShieldGun(Other) != None) && (xWeaponBase(Other).WeaponType == class'XWeapons.ShieldGun' ) )
	{
		xWeaponBase(Other).WeaponType = class'SchlonzUT.SchlonzShieldGun';
		return false;
	}
*/

	if( SchlonzRedeemerEnable )
	{
		if( (xWeaponBase(Other) != None) && (xWeaponBase(Other).WeaponType == class'XWeapons.Redeemer' ) )
		{
			xWeaponBase(Other).WeaponType = class'SchlonzUT.SchlonzRedeemer';
			return false;
		}
		else if( (WeaponPickup(Other) != None) && (string(Other.Class) == "XWeapons.RedeemerPickup") )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzRedeemerPickup");
			return false;
		}
		else if( (Weapon(Other) != None) && (Other.Class == class'XWeapons.Redeemer' ) )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzRedeemer" );
			return false;
		}
		//else if ( (LinkAmmoPickup(Other) != None) && (Other.Class == class'XWeapons.RedeemerAmmoPickup' ) )
		//{
		//	ReplaceWith( Other, "SchlonzUT.SchlonzRedeemerAmmoPickup");
		//	return false;
		//}
		else if ( (LinkAmmo(Other) != None) && (Other.Class == class'XWeapons.RedeemerAmmo' ) )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzRedeemerAmmo");
			return false;
		}
	}

	if (SchlonzRocketLauncherEnable)
	{
		if ( (xWeaponBase(Other) != None) && (xWeaponBase(Other).WeaponType == class'XWeapons.RocketLauncher' ) )
		{
			xWeaponBase(Other).WeaponType = class'SchlonzUT.SchlonzRocketLauncher';
			return false;
		}
		else if ( (WeaponPickup(Other) != None) && (string(Other.Class) == "XWeapons.RocketLauncherPickup") )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzRocketLauncherPickup");
			return false;
		}
		else if ( (Weapon(Other) != None) && (Other.Class == class'XWeapons.RocketLauncher' ) )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzRocketLauncher");
			return false;
		}
	}

	if (SchlonzShockRifleEnable)
	{
		if ( (xWeaponBase(Other) != None) && (xWeaponBase(Other).WeaponType == class'XWeapons.ShockRifle' ) )
		{
			xWeaponBase(Other).WeaponType = class'SchlonzUT.SchlonzShockRifle';
			return false;
		}
		else if ( (WeaponPickup(Other) != None) && (string(Other.Class) == "XWeapons.ShockRiflePickup") )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzShockRiflePickup");
			return false;
		}
		else if ( (Weapon(Other) != None) && (Other.Class == class'XWeapons.ShockRifle' ) )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzShockRifle");
			return false;
		}
	}

	if (SchlonzFlakCannonEnable)
	{
		if ( (xWeaponBase(Other) != None) && (xWeaponBase(Other).WeaponType == class'XWeapons.FlakCannon' ) )
		{
			xWeaponBase(Other).WeaponType = class'SchlonzUT.SchlonzFlakCannon';
			return false;
		}
		else if ( (WeaponPickup(Other) != None) && (string(Other.Class) == "XWeapons.FlakCannonPickup") )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzFlakCannonPickup");
			return false;
		}
		else if ( (Weapon(Other) != None) && (Other.Class == class'XWeapons.FlakCannon' ) )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzFlakCannon");
			return false;
		}
	}

	if (SchlonzMinigunEnable)
	{
		if ( (xWeaponBase(Other) != None) && (xWeaponBase(Other).WeaponType == class'XWeapons.Minigun' ) )
		{
			xWeaponBase(Other).WeaponType = class'SchlonzUT.SchlonzMinigun';
			return false;
		}
		else if ( (WeaponPickup(Other) != None) && (string(Other.Class) == "XWeapons.MinigunPickup") )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzMinigunPickup");
			return false;
		}
		else if ( (Weapon(Other) != None) && (Other.Class == class'XWeapons.Minigun' ) )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzMinigun");
			return false;
		}
	}

	if (SchlonzSniperRifleEnable)
	{
		if ( (xWeaponBase(Other) != None) && (xWeaponBase(Other).WeaponType == class'XWeapons.SniperRifle' ) )
		{
			xWeaponBase(Other).WeaponType = class'SchlonzUT.SchlonzSniperRifle';
			return false;
		}
		else if ( (WeaponPickup(Other) != None) && (string(Other.Class) == "XWeapons.SniperRiflePickup") )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzSniperRiflePickup");
			return false;
		}
		else if ( (Weapon(Other) != None) && (Other.Class == class'XWeapons.SniperRifle' ) )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzSniperRifle");
			return false;
		}
		else if ( (SniperAmmoPickup(Other) != None) && (Other.Class == class'XWeapons.SniperAmmoPickup' ) )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzSniperAmmoPickup");
			return false;
		}
		else if ( (SniperAmmo(Other) != None) && (Other.Class == class'XWeapons.SniperAmmo' ) )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzSniperAmmo");
			return false;
		}
	}

	if (SchlonzPlasmaRifleEnable)
	{
		if ( (xWeaponBase(Other) != None) && (xWeaponBase(Other).WeaponType == class'XWeapons.LinkGun' ) )
		{
			xWeaponBase(Other).WeaponType = class'SchlonzUT.SchlonzLinkGun';
			return false;
		}
		else if ( (WeaponPickup(Other) != None) && (string(Other.Class) == "XWeapons.LinkGunPickup") )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzLinkGunPickup");
			return false;
		}
		else if ( (Weapon(Other) != None) && (Other.Class == class'XWeapons.LinkGun' ) )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzLinkGun");
			return false;
		}
		else if ( (LinkAmmoPickup(Other) != None) && (Other.Class == class'XWeapons.LinkAmmoPickup' ) )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzLinkAmmoPickup");
			return false;
		}
		else if ( (LinkAmmo(Other) != None) && (Other.Class == class'XWeapons.LinkAmmo' ) )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzLinkAmmo");
			return false;
		}
	}

	if (SchlonzBioRifleEnable)
	{
		if ( (xWeaponBase(Other) != None) && (xWeaponBase(Other).WeaponType == class'XWeapons.BioRifle' ) )
		{
			xWeaponBase(Other).WeaponType = class'SchlonzUT.SchlonzBioRifle';
			return false;
		}
		else if ( (WeaponPickup(Other) != None) && (string(Other.Class) == "XWeapons.BioRiflePickup") )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzBioRiflePickup");
			return false;
		}
		else if ( (Weapon(Other) != None) && (Other.Class == class'XWeapons.BioRifle' ) )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzBioRifle");
			return false;
		}
	}

	if (SchlonzEnforcerEnable)
	{
		if ( (xWeaponBase(Other) != None) && (xWeaponBase(Other).WeaponType == class'XWeapons.AssaultRifle' ) )
		{
			xWeaponBase(Other).WeaponType = class'SchlonzUT.SchlonzAssaultRifle';
			return false;
		}
		else if ( (WeaponPickup(Other) != None) && (string(Other.Class) == "XWeapons.AssaultRiflePickup") )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzAssaultRiflePickup");
			return false;
		}
		else if ( (Weapon(Other) != None) && (Other.Class == class'XWeapons.AssaultRifle' ) )
		{
			ReplaceWith( Other, "SchlonzUT.SchlonzAssaultRifle");
			return false;
		}
		else if ( (Ammo(Other) != None) && (string(Other.Class) == "XWeapons.AssaultAmmoPickup") )
		{
			ReplaceWith( Other, "XWeapons.RocketAmmoPickup");
			return false;
		}
	}


	if (NoSuperWeaponsEnable)
	{
		if ( xWeaponBase(Other) != None )
		{
			if ( xWeaponBase(Other).WeaponType == class'Painter' )
			{
				if (SchlonzSniperRifleEnable)
					xWeaponBase(Other).WeaponType = class'SchlonzUT.SchlonzSniperRifle';
				else
					xWeaponBase(Other).WeaponType = class'SniperRifle';
			}
			else if ( xWeaponBase(Other).WeaponType == class'Redeemer' )
			{
				if (SchlonzRocketLauncherEnable)
					xWeaponBase(Other).WeaponType = class'SchlonzUT.SchlonzRocketLauncher';
				else
					xWeaponBase(Other).WeaponType = class'RocketLauncher';
			}
			else
				return true;
		}
		else if ( WeaponPickup(Other) != None )
		{
			if ( string(Other.Class) == "xWeapons.PainterPickup" )
			{
				if (SchlonzSniperRifleEnable)
					ReplaceWith( Other, "SchlonzUT.SchlonzSniperRiflePickup");
				else
					ReplaceWith( Other, "xWeapons.SniperRiflePickup");
			}
			else if ( string(Other.Class) == "xWeapons.RedeemerPickup" )
			{
				if (SchlonzRocketLauncherEnable)
					ReplaceWith( Other, "SchlonzUT.SchlonzRocketLauncherPickup");
				else
					ReplaceWith( Other, "xWeapons.RocketLauncherPickup");
			}
			else
				return true;
		}
		else
			return true;

		return false;
	}

	return true;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////

function Tick( float DeltaTime )
{
	local Pawn					pawn;
	local float					VDistance;
	local Vector				DVector;
	local SchlonzXPawnPlayer	SchlonzPawnPlayer;
	local SchlonzXPawnBot		SchlonzPawnBot;

	if( ! CampEnable )
		return;

	CurrentCampTime += DeltaTime;

	if( CurrentCampTime < CampTime )
		return;

	CurrentCampTime = 0.0;

	foreach DynamicActors( class'Pawn', pawn )
	{
		SchlonzPawnBot = SchlonzXPawnBot( pawn );
		SchlonzPawnPlayer = SchlonzXPawnPlayer( pawn );

		if( SchlonzPawnBot != None )
		{
			// its a bot 

			DVector = SchlonzPawnBot.OldPlayerLoc - pawn.Location;
			VDistance = VSize( DVector );

			if( VDistance < CampRadius )
			{
				if( SchlonzPawnBot.PlayerSize < CampMaxBotSize )
				{
					SchlonzPawnBot.SetPawnBotSize( 0.3 );
				}
			}
			SchlonzPawnBot.OldPlayerLoc = pawn.Location;
		}
		else if( SchlonzPawnPlayer != None )
		{
			// its a player

			if( SchlonzPawnPlayer.PlayerReplicationInfo.PlayerName == "Huarglio" ||
				SchlonzPawnPlayer.PlayerReplicationInfo.PlayerName == "Killertux" )
			{
				return;
			}

			DVector = SchlonzPawnPlayer.OldPlayerLoc - pawn.Location;
			VDistance = VSize( DVector );

			if( VDistance < CampRadius )
			{
				if( SchlonzPawnPlayer.PlayerSize < CampMaxPlayerSize )
				{
					SchlonzPawnPlayer.SetPawnPlayerSize( 1 );
				}
			}
			SchlonzPawnPlayer.OldPlayerLoc = pawn.Location;
		}
	}
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////


defaultproperties
{
	 SchlonzRedeemerEnable=True
     SchlonzEnforcerEnable=True
     SchlonzBioRifleEnable=True
     SchlonzShockRifleEnable=True
     SchlonzPlasmaRifleEnable=True
     SchlonzMinigunEnable=True
     SchlonzFlakCannonEnable=True
     SchlonzRocketLauncherEnable=True
     SchlonzSniperRifleEnable=True
	 SchlonzStatsEnable=True
	 SchlonzStatsServer="127.0.0.1:21844"
	 StatsIP=0
	 StatsPort=0
	 SchlonzCampEnable=True
     CampTime=5
     CampRadius=100
	 CampMaxBotSize = 2.5;
	 CampMaxPlayerSize = 5;
     ConfigMenuClassName="SchlonzUT.SchlonzUTConfig"
     GroupName="SchlonzUT"
     FriendlyName="SchlonzUT"
     Description="Schlonz UT weapons."
}