using SFDGameScriptInterface;using System;using System.Collections.Generic;public class Cod {
    //-----------------------------------

    /*=======================================
    =            Elevator Script            =
    =======================================*/

    private ElevatorHandlerHelper m_elevatorA = null;

    public void ElevatorButtonPress(TriggerArgs args)
    {
        // find out which button
        if ((args.Caller != null) && (args.Caller is IObject))
        {
            IObject btnPressed = (IObject)args.Caller;
            m_elevatorA.ButtonPressed(btnPressed.CustomId);
        }
    }

    public void ElevatorArrived(TriggerArgs args)
    {
        // args.Caller is the elevatorAttachmentJoint, args.Sender is the elevatorPathJoint arrived at in this case
        if ((args.Sender != null) && (args.Sender is IObject))
        {
            IObject pathJoint = (IObject)args.Sender;
            m_elevatorA.ElevatorArrived(pathJoint.CustomId);
        }
    }


    /*=====  End of Elevator Script  ======*/

    /*========================================
    =            Script Variables            =
    ========================================*/

    // The global instance of the queueUsers
    static DynamicUserQueue CodUsers = DynamicUserQueue.Instace;

    // The users playing the game
    static List<DynamicUser> users = new List<DynamicUser>();

    // Script name
    const string scriptName = "COD";

    // The spawn area list, used to add players
    static IObject[] spawns;

    // Random generator object
    static Random rand = new Random();

    // Mid Tick
    static IObjectTimerTrigger midTick;

    // Respawn delay
    static float respawnDelay = 5000;

    // Game time
    static TimeSpan globalTime = new TimeSpan(0, 0, 2, 30, 0);

    // Blacklist objects that must be deleted
    string[] junkObjects = {
    "Giblet00",
    "Giblet01",
    "Giblet02",
    "Giblet03",
    "Giblet04",
    "ShellSmall",
    "ShellShotgun",
    "ShellGLauncher",
    "ShellBig",
    "MagSmall",
    "MagAssaultRifle",
    "MagDrum",
    "MagSMG",
    "WpnPistol",
    "WpnSilencedPistol",
    "WpnMagnum",
    "WpnRevolver",
    "WpnPumpShotgun",
    "WpnTommygun",
    "WpnSMG",
    "WpnM60",
    "WpnPipeWrench",
    "PipeDebris1",
    "WpnChain",
    "WpnHammer",
    "HammerDebris1",
    "WpnKatana",
    "SwordDebris1",
    "WpnMachete",
    "MacheteDebris1",
    "WpnKnife",
    "KnifeDebris1",
    "WpnSawedOff",
    "WpnBat",
    "WpnBaton",
    "BatonDebris1",
    "BatonDebris2",
    "WpnUzi",
    "WpnSilencedUzi",
    "WpnBazooka",
    "WpnAxe",
    "AxeDebris1",
    "WpnAssaultRifle",
    "WpnSniperRifle",
    "WpnCarbine",
    "WpnFlamethrower",
    "ItemPills",
    "ItemMedkit",
    "ItemSlomo5",
    "ItemSlomo10",
    "ItemLaserSight",
    "WpnGrenades",
    "WpnGrenadesThrown",
    "WpnGrenadePin",
    "WpnMolotovs",
    "WpnMolotovsThrown",
    "WpnC4",
    "WpnC4Thrown",
    "WpnC4Detonator",
    "WpnMines",
    "WpnMineThrown",
    "WpnFlareGun",
    "WpnGrenadeLauncher"
    };

    // Teleport stamina consumption
    static float teleport_energy_comsume = 35f;

    /*=====  End of Script Variables  ======*/

    /*========================================
    =            Script Functions            =
    ========================================*/

    /**
     * OnStartup listener
     */
    public void OnStartup(TriggerArgs args)
    {
        // Setup the elevator
        m_elevatorA = new ElevatorHandlerHelper(GameScriptInterface.Game, "EleA", new string[] { "A", "B", "C" }, "A");

        // Setup the ticks
        Utils.SetTimer("PeriodicalTick", "PeriodicalTick", -1, 20000);
        Utils.SetTimer("SecTick", "SecTick", -1, 1000);
        Utils.SetTimer("SlowTick", "SlowTick", -1, 500);
        Utils.SetTimer("MidTick", "MidTick", -1, 250);
        Utils.SetTimer("FastTick", "FastTick", -1, 75);

        CodUsers.DisplayPlayerPoints();

        // Setup the players
        //PlayersLife(new TriggerArgs(null, null, false));

        // Gets all the spawn areas
        spawns = GameScriptInterface.Game.GetObjectsByCustomId("SpawnArea");
    }

    /**
     * 20000 ms tick
     */
    public void PeriodicalTick(TriggerArgs args)
    {
        DeleteTrash();
    }

    /**
     * 1000 ms tick
     */
    public void SecTick(TriggerArgs args)
    {
        // Ticks the time
        if (!GameScriptInterface.Game.IsGameOver)
        {
            GameTime(args);
            CodUsers.DisplayPlayerPoints();
        }
    }

    /**
     * 500 ms tick
     */
    public void SlowTick(TriggerArgs args)
    {
        // Update the players
        CodUsers.UpdateUsers(args);
    }

    /**
     * 250 ms tick
     */
    public void MidTick(TriggerArgs args)
    {

    }

    /**
     * 75 ms tick
     */
    public void FastTick(TriggerArgs args)
    {

    }

    /**
     *  Deletes trash objects
     *  from the map
     */
    public void DeleteTrash()
    {
        foreach (IObject obj in GameScriptInterface.Game.GetObjectsByName(junkObjects))
        {
            obj.Remove();
        }
    }

    /**
     * Used to move a player to the game with a kit
     */
    public void KitButton(TriggerArgs args)
    {
        try
        {
            // Gets the caller and the trigger
            IObjectTrigger caller = args.Caller as IObjectTrigger;
            IPlayer sender = args.Sender as IPlayer;

            DynamicUser dynUser = CodUsers.DynamicUserFromIPlayer(sender);

            dynUser.GiveKit(caller.CustomId);
            dynUser.SendPlayerToBattleArea();
        }
        catch (System.Exception e)
        {
            Utils.SendExceptionMessage(e, "KitButton");
        }
    }

    /**
     * Death listener
     */
    public void Death(TriggerArgs args)
    {
        try
        {
            IPlayer sender = args.Sender as IPlayer;

            DynamicUser deadDynUsr = new DynamicUser(sender.GetUser());

            CodUsers.UserDied(deadDynUsr);
        }
        catch (System.Exception e)
        {
            Utils.SendExceptionMessage(e, "Death");
        }
    }

    /**
     * Canned ammo, used in the vending machines
     */
    public void CannedLife(TriggerArgs args)
    {
        try
        {
            IObjectTrigger caller = args.Caller as IObjectTrigger;
            IPlayer sender = args.Sender as IPlayer;
            DynamicUser tempUsr = CodUsers.DynamicUserFromIPlayer(sender);

            if (tempUsr.CanUseTheLifeMachine())
            {
                Utils.CreateClickableObject("CrabCan00", tempUsr.Ply.GetWorldPosition() + new Vector2(11f * tempUsr.Ply.FacingDirection, 0), "LifeCan", true);
                tempUsr.LifeMachineTime = GameScriptInterface.Game.TotalElapsedGameTime;
            }
            else
            {
                Utils.SendMessageFromTriggerArgs(args, "Wait...");
            }
        }
        catch (System.Exception e)
        {
            Utils.SendExceptionMessage(e, "CannedLife");
        }
    }

    /**
     *
     * Gives life to the player who gets
     * the life can.
     *
     */
    public void LifeCan(TriggerArgs args)
    {
        IPlayer sender = args.Sender as IPlayer;
        IObjectActivateTrigger caller = args.Caller as IObjectActivateTrigger;
        IObject obj = caller.GetHighlightObject();

        sender.GiveWeaponItem(WeaponItem.PILLS);
        obj.Destroy();

        Utils.SendMessageFromTriggerArgs(args, "Chomp!");
    }

    /**
     * Closet ammo, spawns a desired
     * kit in a box when trigered
     */
    public void ClosetAmmo(TriggerArgs args)
    {
        try
        {
            IObjectTrigger caller = args.Caller as IObjectTrigger;
            IPlayer sender = args.Sender as IPlayer;
            DynamicUser tempUsr = CodUsers.DynamicUserFromIPlayer(sender);

            if (tempUsr.CanUseTheClosetAmmo())
            {
                Utils.CreateClickableObject("CardboardBox00", tempUsr.Ply.GetWorldPosition(), "ClosetGift", true);
                tempUsr.ClosetAmmoTime = GameScriptInterface.Game.TotalElapsedGameTime;
            }
            else
            {
                Utils.SendMessageFromTriggerArgs(args, "Wait...");
            }
        }
        catch (System.Exception e)
        {
            Utils.SendExceptionMessage(e, "ClosetAmmo");
        }
    }

    public void ClosetGift(TriggerArgs args)
    {
        try
        {
            IPlayer sender = args.Sender as IPlayer;
            IObjectActivateTrigger caller = args.Caller as IObjectActivateTrigger;
            IObject obj = caller.GetHighlightObject();
            DynamicUser tempUsr = CodUsers.DynamicUserFromIPlayer(sender);

            tempUsr.GiveKit(tempUsr.PlyClass);
            obj.Destroy();
        }
        catch (System.Exception e)
        {
            Utils.SendExceptionMessage(e, "ClosetGift");
        }
    }

    /**
     * GameTime, used to gameover the game
     */
    public void GameTime(TriggerArgs args)
    {
        IObjectText timeRemaining = (IObjectText)GameScriptInterface.Game.GetSingleObjectByCustomId("TimeRemaining");
        IObjectText timeRemainingShadow = (IObjectText)GameScriptInterface.Game.GetSingleObjectByCustomId("TimeRemainingShadow");

        timeRemaining.SetText(globalTime.ToString(@"m\:ss"));
        timeRemainingShadow.SetText(globalTime.ToString(@"m\:ss"));

        if (globalTime <= TimeSpan.Zero)
        {
            timeRemaining.SetText("Game Over");
            timeRemainingShadow.SetText("Game Over");

            CodUsers.GameOver();
        }
        else if (CodUsers.IsAnyPlayerInArena())
        {
            globalTime = globalTime.Subtract(new TimeSpan(0, 0, 0, 1, 0));
        }
    }

    /**
     * Teleport join, used to
     * teleport players through doors
     */
    public void TeleportJoint(TriggerArgs args)
    {
        IPlayer sender = (IPlayer)args.Sender;
        DynamicUser dUser = CodUsers.DynamicUserFromIPlayer(sender);

        if (dUser.CanTeleport() && sender.GetModifiers().CurrentEnergy > teleport_energy_comsume)
        {
            // Update the teleport time
            dUser.TeleportTime = GameScriptInterface.Game.TotalElapsedGameTime;

            // Consume some energy
            PlayerModifiers modifiers = sender.GetModifiers();
            modifiers.CurrentEnergy = modifiers.CurrentEnergy - teleport_energy_comsume;
            sender.SetModifiers(modifiers);

            // Teleport from A1 to A2
            IObjectActivateTrigger caller = (IObjectActivateTrigger)args.Caller;
            IObject otherSide = GameScriptInterface.Game.GetSingleObjectByCustomId((caller.GetHighlightObject() as IObject).CustomId.Substring(0, 2));
            sender.SetWorldPosition(otherSide.GetWorldPosition());
        }
    }

    /*=====  End of Script Functions  ======*/

    /*=========================================
    =            Class Definitions            =
    =========================================*/

    /**
     * DynamicUserQueue class
     * A class to respawn the
     * DynamicUser and make
     * deletion/creation control
     */
    public class DynamicUserQueue
    {
        // --- Singleton
        private static DynamicUserQueue instance;

        private DynamicUserQueue() { }

        public static DynamicUserQueue Instace
        {
            get
            {
                if (instance == null)
                {
                    instance = new DynamicUserQueue();
                    instance.dynUsers = new List<DynamicUser>();
                }
                return instance;
            }
        }
        // --- End of Singleton

        // The dynamic users hashset
        private List<DynamicUser> dynUsers;

        /**
         * Adds a user to the users list
         */
        private void AddUser(IUser user)
        {
            DynamicUser din = new DynamicUser(user);
            dynUsers.Add(din);
            //Utils.SendMessage("There are " + dynUsers.Count.ToString() + " players...");
        }

        /**
         * Adds and removes users based in:
         * Should a new user be added?
         * Is the user dead?
         * Should the user be respawned?
         * Is the game over?
         * Is the user in the room yet?
         */
        public void UpdateUsers(TriggerArgs args)
        {
            if (!GameScriptInterface.Game.IsGameOver)
            {
                // Add new users and remove old ones
                this.SearchForNewUsers();
                this.CleanUsers();

                // Try to respawn the users
                this.RespawnUsers();
            }


        }

        /**
         * Detects new users and adds them
         */
        private void SearchForNewUsers()
        {
            // Try to add new users
            foreach (IUser usr in GameScriptInterface.Game.GetActiveUsers())
            {
                // Try to add it to the hashSet
                if (!Utils.IsUserServerUser(usr))
                {
                    if (CodUsers.DynamicUserFromIUser(usr) == null)
                    {
                        AddUser(usr);
                    }
                }
            }
        }

        /**
         * Detects users that aren't not added anymore
         */
        private void CleanUsers()
        {
            foreach (DynamicUser dynUsr in dynUsers.ToArray())
            {
                // Checks if the user is not in the game, if so remove it
                if (dynUsr.User.IsRemoved)
                {
                    dynUsr.RemovePlayer(false, true);
                    dynUsers.Remove(dynUsr);
                }

            }
        }

        /**
         * Detects if a user must respawn and respawns it
         */
        private void RespawnUsers()
        {
            foreach (DynamicUser dynUsr in dynUsers.ToArray())
            {
                if (dynUsr.MustRespawn())
                {
                    dynUsr.Respawn();
                }
            }
        }

        /**
         * Recieves a dead user
         */
        public void UserDied(DynamicUser deadDynUser)
        {
            foreach (DynamicUser dynUsr in dynUsers.ToArray())
            {
                if (dynUsr.Equals(deadDynUser))
                {
                    dynUsr.Death(GameScriptInterface.Game.TotalElapsedGameTime);
                }
            }
            this.GameScore();
        }

        public void GameScore()
        {
            foreach (DynamicUser dynUsr in dynUsers.ToArray())
            {
                try
                {
                    if (!dynUsr.isDead() && dynUsr.IsInArena)
                    {
                        dynUsr.Score++;
                    }
                }
                catch (Exception e)
                {
                    Utils.SendExceptionMessage(e, "GameScore");
                }
            }
        }

        /**
         * Retrieves a dynamic user by an IUser
         */
        public DynamicUser DynamicUserFromIUser(IUser usr)
        {
            foreach (DynamicUser dynUsr in dynUsers.ToArray())
            {
                if (dynUsr.User == usr)
                {
                    return dynUsr;
                }
            }
            return null;
        }

        /**
         * Retrieves a dynamic user by an IPlayer
         */
        public DynamicUser DynamicUserFromIPlayer(IPlayer ply)
        {
            foreach (DynamicUser dynUsr in dynUsers.ToArray())
            {
                if (dynUsr.Ply == ply)
                {
                    return dynUsr;
                }
            }
            return null;
        }

        public void DisplayPlayerPoints()
        {
            IObjectText tempTxt = null;
            string tempStr;
            string tempName;
            string plyClass;
            int i = 0;
            foreach (DynamicUser dynUser in dynUsers.ToArray())
            {
                tempTxt = (IObjectText)GameScriptInterface.Game.GetSingleObjectByCustomId("PlayerPoints" + i);
                tempName = dynUser.User.Name;
                plyClass = dynUser.PlyClass;
                tempStr = tempName + ": " + dynUser.Score.ToString() + " ~ " + (plyClass == "" ? "NaN" : plyClass) + ".";

                if (tempName == "MtMercer")
                {
                    tempTxt.SetTextColor(new Color((byte)rand.Next(100, 200), (byte)rand.Next(100, 200), (byte)rand.Next(100, 255)));
                }
                else
                {
                    tempTxt.SetTextColor(Color.Yellow);
                }

                if (tempStr.Length < 40)
                {
                    tempTxt.SetText(tempStr);
                }
                else
                {
                    tempTxt.SetText(tempStr.Substring(0, 40) + ".");
                }
                i += 1;
            }
            for (int j = 7; j > dynUsers.Count - 1; j--)
            {
                tempTxt = (IObjectText)GameScriptInterface.Game.GetSingleObjectByCustomId("PlayerPoints" + j);
                tempTxt.SetText("");
            }
        }

        public bool IsAnyPlayerInArena()
        {
            foreach (DynamicUser dynUser in dynUsers.ToArray())
            {
                if (dynUser.IsInArena)
                {
                    return true;
                }
            }
            return false;
        }

        public void GameOver()
        {
            DynamicUser winner = null;
            foreach (DynamicUser dynUser in dynUsers.ToArray())
            {
                if (winner == null || dynUser.Score > winner.Score)
                {
                    winner = dynUser;
                }
            }

            bool draw = false;
            // Search for draws
            foreach (DynamicUser dynUser in dynUsers.ToArray())
            {
                if (!dynUser.Equals(winner) && dynUser.Score == winner.Score)
                {
                    draw = true;
                    break;
                }
            }


            GameScriptInterface.Game.SetGameOver(draw ? "DRAW" : winner.User.Name + " WINS");
        }
    }

    /**
     * DynamicUser class
     * A class to control
     * the player actions
     * during the game
     */
    public class DynamicUser
    {
        // The player from object
        private IPlayer ply;
        public IPlayer Ply
        {
            get
            {
                return ply;
            }
        }
        // The user of the object
        private IUser user;
        public IUser User
        {
            get
            {
                return user;
            }
        }
        // If the player is in arena
        private bool isInArena;
        public bool IsInArena
        {
            get
            {
                return isInArena;
            }
        }
        // The time that the player died
        private float deathTime;
        public float DeathTime
        {
            get
            {
                return deathTime;
            }
            set
            {
                deathTime = value;
            }
        }
        // The player score
        private int score;
        public int Score
        {
            get
            {
                return score;
            }
            set
            {
                score = value;
            }
        }
        // The player kit class
        private string plyClass;
        public string PlyClass
        {
            get
            {
                return plyClass;
            }
            set
            {
                plyClass = value;
            }
        }
        // If the player can use the Life Machines
        private float lifeMachineTime;
        public float LifeMachineTime
        {
            get
            {
                return lifeMachineTime;
            }
            set
            {
                lifeMachineTime = value;
            }
        }
        // If the player can use the teleport
        private float teleportTime;
        public float TeleportTime
        {
            get
            {
                return teleportTime;
            }
            set
            {
                teleportTime = value;
            }
        }
        // If the player can use the closet
        private float closetAmmoTime;
        public float ClosetAmmoTime
        {
            get
            {
                return closetAmmoTime;
            }
            set
            {
                closetAmmoTime = value;
            }
        }
        // Used to persist the game team settings
        private PlayerTeam persistentTeam;

        // The constructor
        // User required
        public DynamicUser(IUser user)
        {
            // Assigns the user
            this.user = user;

            // Setup the player
            this.ply = user.GetPlayer();
            if (this.ply != null)
            {
                this.persistentTeam = ply.GetTeam();
                this.ply.SetTeam(PlayerTeam.Team3);
            }

            this.deathTime = GameScriptInterface.Game.TotalElapsedGameTime;
            this.lifeMachineTime = GameScriptInterface.Game.TotalElapsedGameTime;
            this.teleportTime = GameScriptInterface.Game.TotalElapsedGameTime;
            this.plyClass = "";
        }


        // Died event
        public void Death(float time)
        {
            try
            {
                this.deathTime = time;
                //this.ply = null;
            }
            catch (Exception e)
            {
                Utils.SendExceptionMessage(e, "SetDeathTime");
            }
        }

        // Removes the player from the user object
        // killing or gibing it
        public void RemovePlayer(bool kill, bool gib)
        {
            try
            {
                if (kill)
                {
                    this.ply.Kill();
                }
                else if (gib)
                {
                    this.ply.Gib();
                }
            }
            catch (System.Exception e)
            {
                Utils.SendExceptionMessage(e, "DynamicPlayer.RemovePlayer");
            }
            finally
            {
                this.ply = null;
            }
        }

        //Sends the user to the battle area
        public void SendPlayerToBattleArea()
        {
            try
            {
                // Gets the area
                Area area = spawns[rand.Next(0, spawns.Length)].GetAABB();

                // Teleports the player to a random place in the arena
                ply.SetWorldPosition(new Vector2(rand.Next((int)area.Left, (int)area.Right), (int)area.Top));

                // Independent team
                ply.SetTeam(this.persistentTeam);

                this.isInArena = true;
            }
            catch (System.Exception e)
            {
                Utils.SendExceptionMessage(e, "DynamicPlayer.SendPlayerToBattleArea");
            }
        }

        // Checks if the user must respawn
        public bool MustRespawn()
        {
            //GameScriptInterface.Game.WriteToConsole(this.deathTime.ToString());
            if (GameScriptInterface.Game.TotalElapsedGameTime - this.deathTime > respawnDelay && !Utils.IsPlayerInTheGame(this.ply))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        // Respawn the user
        public void Respawn()
        {
            try
            {
                // Gets the area
                Area area = GameScriptInterface.Game.GetSingleObjectByCustomId("KitsSpawn").GetAABB();
                IPlayer otherPly = GameScriptInterface.Game.CreatePlayer(new Vector2(rand.Next((int)area.Left, (int)area.Right), (int)area.Top));
                otherPly.SetUser(this.user);
                otherPly.SetProfile(this.user.GetProfile());
                if (this.ply != null)
                {
                    this.ply.Gib();
                }
                this.ply = otherPly;
                this.ply.SetTeam(PlayerTeam.Team3);

                this.isInArena = false;
                this.plyClass = "";
            }
            catch (Exception e)
            {
                Utils.SendExceptionMessage(e, "Respawn");
            }
        }

        // Checks if the user can use the life machines
        public bool CanUseTheLifeMachine()
        {
            if (GameScriptInterface.Game.TotalElapsedGameTime - this.lifeMachineTime > 10000)
            {
                return true;
            }
            return false;
        }

        // Checks if the user can use the closet ammos
        public bool CanUseTheClosetAmmo()
        {
            if (GameScriptInterface.Game.TotalElapsedGameTime - this.closetAmmoTime > 20000)
            {
                return true;
            }
            return false;
        }

        // Checks if the player can teleport
        public bool CanTeleport()
        {
            if (GameScriptInterface.Game.TotalElapsedGameTime - this.teleportTime > 1000)
            {
                return true;
            }
            return false;
        }

        public override int GetHashCode()
        {
            return user.GetHashCode();
        }

        public override bool Equals(object obj)
        {
            if (obj != null && obj.GetType() == this.GetType())
            {
                DynamicUser otherUsr = obj as DynamicUser;
                return Object.ReferenceEquals(this.user, otherUsr.User);
            }
            return false;
        }

        public void GiveKit(string kit)
        {
            switch (kit)
            {
                case "Bomber":
                    ply.GiveWeaponItem(WeaponItem.MINES);
                    ply.GiveWeaponItem(WeaponItem.SILENCEDUZI);
                    ply.GiveWeaponItem(WeaponItem.HAMMER);
                    ply.GiveWeaponItem(WeaponItem.SLOWMO_10);
                    break;
                case "Assaulter":
                    ply.GiveWeaponItem(WeaponItem.ASSAULT);
                    ply.GiveWeaponItem(WeaponItem.SILENCEDUZI);
                    ply.GiveWeaponItem(WeaponItem.C4);
                    ply.GiveWeaponItem(WeaponItem.SLOWMO_5);
                    break;
                case "Mexican":
                    ply.GiveWeaponItem(WeaponItem.MACHETE);
                    ply.GiveWeaponItem(WeaponItem.MAGNUM);
                    ply.GiveWeaponItem(WeaponItem.SLOWMO_5);
                    break;
                case "Runner":
                    ply.GiveWeaponItem(WeaponItem.KATANA);
                    ply.GiveWeaponItem(WeaponItem.SAWED_OFF);
                    ply.GiveWeaponItem(WeaponItem.REVOLVER);
                    ply.GiveWeaponItem(WeaponItem.SLOWMO_5);
                    break;
                case "Marksman":
                    ply.GiveWeaponItem(WeaponItem.KNIFE);
                    ply.GiveWeaponItem(WeaponItem.SNIPER);
                    ply.GiveWeaponItem(WeaponItem.PISTOL);
                    ply.GiveWeaponItem(WeaponItem.SLOWMO_10);
                    break;
                case "Technician":
                    ply.GiveWeaponItem(WeaponItem.PIPE);
                    ply.GiveWeaponItem(WeaponItem.SILENCEDPISTOL);
                    ply.GiveWeaponItem(WeaponItem.SHOTGUN);
                    ply.GiveWeaponItem(WeaponItem.GRENADES);
                    ply.GiveWeaponItem(WeaponItem.SLOWMO_10);
                    break;
                case "Revolutionist":
                    ply.GiveWeaponItem(WeaponItem.AXE);
                    ply.GiveWeaponItem(WeaponItem.SUB_MACHINEGUN);
                    ply.GiveWeaponItem(WeaponItem.PISTOL);
                    ply.GiveWeaponItem(WeaponItem.SLOWMO_5);
                    break;
                case "The Last War":
                    ply.GiveWeaponItem(WeaponItem.BAT);
                    ply.GiveWeaponItem(WeaponItem.REVOLVER);
                    ply.GiveWeaponItem(WeaponItem.CARBINE);
                    ply.GiveWeaponItem(WeaponItem.GRENADES);
                    ply.GiveWeaponItem(WeaponItem.SLOWMO_5);
                    break;
                case "Guetto":
                    ply.GiveWeaponItem(WeaponItem.CHAIN);
                    ply.GiveWeaponItem(WeaponItem.UZI);
                    ply.GiveWeaponItem(WeaponItem.SHOTGUN);
                    ply.GiveWeaponItem(WeaponItem.SLOWMO_5);
                    break;
            }
            this.PlyClass = kit;
        }

        public bool isDead()
        {
            return this.ply == null || this.ply.IsDead;
        }
    }

    /**
     * Utils class
     * The functions are used
     * to automate some
     * actions in the script.
     */
    public static class Utils
    {
        /**
         * Used to set a timer trigger
         */
        public static IObjectTimerTrigger SetTimer(string method, string customId, int repeatCount, int interval)
        {
            IObjectTimerTrigger trigger = (IObjectTimerTrigger)GameScriptInterface.Game.CreateObject("TimerTrigger");
            trigger.CustomId = customId;
            trigger.SetScriptMethod(method);
            trigger.SetIntervalTime(interval);
            trigger.SetRepeatCount(repeatCount);
            trigger.SetWorldPosition(new Vector2(0, -100));
            trigger.Trigger();
            return trigger;
        }

        /**
         * Sends a custom message to the chat
         */
        public static void SendMessage(string msg)
        {
            GameScriptInterface.Game.RunCommand("/MSG " + msg);
        }

        /**
         * Sends a exception message to the console
         */
        public static void SendExceptionMessage(System.Exception e, string at)
        {
            //GameScriptInterface.Game.WriteToConsole(scriptName + " EXCEPTION: " + e + " AT: " + at);
            GameScriptInterface.Game.WriteToConsole(scriptName + " EXCEPTION: " + "" + " AT: " + at);
        }

        /**
         * Gets a DynamicUser object with an IPlayer object
         */
        public static DynamicUser GetUserByIPlayer(IPlayer ply)
        {
            foreach (DynamicUser usr in users.ToArray())
            {
                if (ply.Equals(usr.User.GetPlayer()))
                {
                    return usr;
                }
            }
            return null;
        }

        /**
        * Gets a DynamicUser object with an IUser object
        */
        public static DynamicUser GetUserByIUser(IUser ply)
        {
            foreach (DynamicUser usr in users.ToArray())
            {
                if (ply.Equals(usr.User))
                {
                    return usr;
                }
            }
            return null;
        }

        /**
         * Removes a user to user list
         * If it isn't in the map
         * Can be forced
         */
        public static void RemoveUser(IPlayer ply, bool force)
        {
            if (ply.GetUser().IsRemoved || force)
            {
                users.Remove(Utils.GetUserByIPlayer(ply));
            }
        }

        /**
         * Checks if a player is in the game (the tile)
         */
        public static bool IsPlayerInTheGame(IPlayer ply)
        {
            if (ply == null)
            {
                return false;
            }
            foreach (IPlayer other in GameScriptInterface.Game.GetPlayers())
            {
                if (ply == other && !other.IsDead)
                {
                    return true;
                }
            }
            return false;
        }

        /**
         * Sends a work in progress
         * message for something that isn't
         * ready in the map
         */
        public static void SendWorkInProgressMessage(Vector2 whereToSend)
        {
            GameScriptInterface.Game.PlayEffect("CFTXT", whereToSend, "Beta version!\nMtMercer is working...");
        }

        /**
         * Generates a clicable object
         * runs the specific method when triggered
         */

        public static IObject CreateClickableObject(string objName, Vector2 location, string method, bool destroyTriggers)
        {
            // Creates the object
            IObject obj = (IObject)GameScriptInterface.Game.CreateObject(objName, location);

            // Creates a weldjoint
            IObjectWeldJoint welder = (IObjectWeldJoint)GameScriptInterface.Game.CreateObject("WeldJoint", location);
            welder.SetBodyType(BodyType.Dynamic);

            // The button that triggers the method
            IObjectActivateTrigger invButton = (IObjectActivateTrigger)GameScriptInterface.Game.CreateObject("ActivateTrigger", location);
            invButton.SetBodyType(BodyType.Dynamic);
            // What method will it run when trigered?
            invButton.SetScriptMethod(method);

            // Joins everyone
            welder.AddTargetObject(obj);
            welder.AddTargetObject(invButton);

            // Used to higlight the obj
            invButton.SetHighlightObject(obj);

            // Used to destroy the "clickable family"
            if (destroyTriggers)
            {
                // Destroy the other objects, like the trigger
                IObjectDestroyTargets destroyer = (IObjectDestroyTargets)GameScriptInterface.Game.CreateObject("DestroyTargets", location);
                destroyer.SetBodyType(BodyType.Dynamic);
                welder.AddTargetObject(destroyer);
                destroyer.AddTriggerDestroyObject(obj);
                destroyer.AddObjectToDestroy(welder);
                destroyer.AddObjectToDestroy(invButton);
                destroyer.AddObjectToDestroy(destroyer);
            }

            return obj;
        }

        /**
        * Sends a message based in
        * a triggers args
        */
        public static void SendMessageFromTriggerArgs(TriggerArgs args, string message)
        {
            IObject caller = args.Caller as IObject;
            GameScriptInterface.Game.PlayEffect("CFTXT", caller.GetWorldPosition(), message);
        }

        /**
         * Checks if a user is a server user
         */
        public static bool IsUserServerUser(IUser usr)
        {
            return "SERVER".Equals(usr.Name) && usr.IsHost && usr.IsSpectator;
        }
    }

    /*=====  End of Class Definitions  ======*/

    //ply.GiveWeaponItem(WeaponItem.ASSAULT);
    //ply.GiveWeaponItem(WeaponItem.UZI);
    //ply.GiveWeaponItem(WeaponItem.SLOWMO_5);
    //
    //ply.GiveWeaponItem(WeaponItem.MACHETE);
    //ply.GiveWeaponItem(WeaponItem.MAGNUM);
    //ply.GiveWeaponItem(WeaponItem.SLOWMO_5);
    //
    //ply.GiveWeaponItem(WeaponItem.KATANA);
    //ply.GiveWeaponItem(WeaponItem.SAWED_OFF);
    //ply.GiveWeaponItem(WeaponItem.REVOLVER);
    //ply.GiveWeaponItem(WeaponItem.SLOWMO_5);
    //
    //ply.GiveWeaponItem(WeaponItem.SNIPER);
    //ply.GiveWeaponItem(WeaponItem.PISTOL);
    //ply.GiveWeaponItem(WeaponItem.SLOWMO_10);
    //
    //ply.GiveWeaponItem(WeaponItem.PIPE);
    //ply.GiveWeaponItem(WeaponItem.REVOLVER);
    //ply.GiveWeaponItem(WeaponItem.SHOTGUN);
    //ply.GiveWeaponItem(WeaponItem.GRENADES);
    //ply.GiveWeaponItem(WeaponItem.SLOWMO_10);
    //
    //ply.GiveWeaponItem(WeaponItem.AXE);
    //ply.GiveWeaponItem(WeaponItem.SUB_MACHINEGUN);
    //ply.GiveWeaponItem(WeaponItem.PISTOL);
    //ply.GiveWeaponItem(WeaponItem.SLOWMO_5);
    //
    //ply.GiveWeaponItem(WeaponItem.BAT);
    //ply.GiveWeaponItem(WeaponItem.CARBINE);
    //ply.GiveWeaponItem(WeaponItem.GRENADES);
    //ply.GiveWeaponItem(WeaponItem.SLOWMO_5);

    //-----------------------------------
}