New admin commands

using System;
using System.IO;
using System.Collections.Generic;
using System.Text;
using UnityEngine;
using System.Reflection;
using System.Timers;
using Ini;
using CommandHandler;

namespace Admin_Commands
{

    public class AdminCommands : MonoBehaviour
    {
        #region TOP: global variables are initialised here

        int updater3 = 0;
        public string lastUsedCommand = "none";

        public Timer itemsTimer;
        public Timer announceTimer;

        public int announceIndex = 0;
        public int itemsResetIntervalInSeconds = 2700;
        public int announceIntervalInSeconds = 600;
        public String[] AnnounceMessages;

        public List<String> WhitelistedSteamIDs = new List<string>();
        public bool usingWhitelist = false;

        public bool usingGUI = true;
        public bool usePlayerHomes = false;

        public String bigAssStringWithBannedPlayerNamesAndSteamIDs = "";   //empty until player issues /unban command

        Dictionary<String, Vector3> playerHomes =  new Dictionary<String, Vector3>();
        BetterNetworkUser userToBeBanned;

        #endregion

        public void Start()
        {
            ReadConfigs();  //Read all the announcements, whitelist, player homes, ...

            CommandList.add(new Command(Online,"online"));
            CommandList.add(new Command(Time, "time"));
            CommandList.add(new Command(SetHome, "sethome"));
            CommandList.add(new Command(Home, "home"));
            CommandList.add(new Command(6, Announce, "repeat", "announce", "ann"));
            CommandList.add(new Command(Ban, "ban"));
            CommandList.add(new Command(ReasonForBan, "reason", "r"));
            CommandList.add(new Command(ResetItems, "resetitems"));
            CommandList.add(new Command(RepairVehicles, "repairvehicles"));
            CommandList.add(new Command(RefuelVehicles, "refuelvehicles"));
            CommandList.add(new Command(SirensOn, "sirens"));
            CommandList.add(new Command(SirensOff, "sirensoff"));
            CommandList.add(new Command(ResetZombies, "resetzombies"));
            CommandList.add(new Command(Killzombies, "killzombies"));
            CommandList.add(new Command(ReloadBans, "reloadbans"));
            CommandList.add(new Command(SetItemsDelay, "setitemsdelay"));
            CommandList.add(new Command(SetAnnounceDelay, "setannouncedelay"));
            CommandList.add(new Command(EnableWhitelist, "enablewhitelist"));
            CommandList.add(new Command(DisableWhitelist, "disablewhitelist"));
            CommandList.add(new Command(Whitelist, "whitelist"));   //used for both /whitelist add & /whitelist remove
            CommandList.add(new Command(UnBan, "unban"));
            CommandList.add(new Command(TeleportToPlayer, "tp"));
            CommandList.add(new Command(TeleportToMe, "tptome"));
            CommandList.add(new Command(TeleportToCoords, "tpto"));
            CommandList.add(new Command(TeleportAll, "tpall"));
            CommandList.add(new Command(Kill, "kill"));
            CommandList.add(new Command(Heal, "heal"));
            CommandList.add(new Command(Promote, "promote"));
            CommandList.add(new Command(ShowAdminCommands, "commands"));
            CommandList.add(new Command(TeleportCar, "car"));
            CommandList.add(new Command(SpawnItem, "i"));
            CommandList.add(new Command(SpawnKit, "kit"));

        }



        //Methods for each command :)

        private void Online(CommandArgs args)
        {
            Reference.Tell(args.sender.player, "There are " + UserList.NetworkUsers.Count + " players online.");
        }

        private void Time(CommandArgs args)
        {
            NetworkChat.sendAlert("Time: " + Sun.getTime());
        }

        private void SetHome(CommandArgs args)
        {
            if (usePlayerHomes)
            {
                Vector3 location = NetworkUserList.getModelFromPlayer(args.sender.player).transform.position;
                setHome(args.sender.steamid, location);
                Reference.Tell(args.sender.player, "Home set.");
            }
        }

        private void Home(CommandArgs args)
        {
            if (usePlayerHomes)
            {
                home(args.sender);
                Reference.Tell(args.sender.player, "Teleported home. Don't move for 5 seconds if you don't wanna get kicked");
            }
        }

        private void Announce(CommandArgs args)
        {
            //Make all the parameters into 1 big string
            string concat = args.ParametersAsString;
            NetworkChat.sendAlert(concat);
        }

        private void Ban(CommandArgs args)
        {
            String playerNameToBeBanned = args.ParametersAsString;
            String tempBanName;

            if (playerNameToBeBanned.Length < 2)
            {
                userToBeBanned = UserList.users[Convert.ToInt32(playerNameToBeBanned)];
                tempBanName = userToBeBanned.name;
                Reference.Tell(args.sender.player, "Reason for banning " + tempBanName + " ?  /reason <reason> to ban");
            }
            else
            {
                userToBeBanned = UserList.getUserFromName(playerNameToBeBanned);
                tempBanName = userToBeBanned.name;
                Reference.Tell(args.sender.player, "Reason for banning " + tempBanName + " ?  /reason <reason> to ban");
            }
        }

        private void ReasonForBan(CommandArgs args)
        {
            String reason = args.ParametersAsString;
            if (args.Parameters.Count > 0)
                Ban(userToBeBanned, reason);
        }


        private void ResetItems(CommandArgs args)
        {
            SpawnItems.reset();
            NetworkChat.sendAlert(args.sender.name + " has respawned all items");
        }

        private void RepairVehicles(CommandArgs args)
        {
            Vehicle[] vehicles = UnityEngine.Object.FindObjectsOfType(typeof(Vehicle)) as Vehicle[];
            foreach (Vehicle vehicle in vehicles)
            {
                vehicle.networkView.RPC("tellExploded", RPCMode.All, new object[] { false });
                vehicle.networkView.RPC("tellWrecked", RPCMode.All, new object[] { false });
                vehicle.heal(1000);
            }
            NetworkChat.sendAlert(args.sender.name + " has repaired " + vehicles.Length + " vehicles");
        }

        private void RefuelVehicles(CommandArgs args)
        {
            Vehicle[] vehicles = UnityEngine.Object.FindObjectsOfType(typeof(Vehicle)) as Vehicle[];
            foreach (Vehicle vehicle in vehicles)
            {
                vehicle.fill(1000);
            }
            NetworkChat.sendAlert(args.sender.name + " has refueled " + vehicles.Length + " vehicles");
        }

        private void SirensOn(CommandArgs args)
        {
            Vehicle[] vehicles = UnityEngine.Object.FindObjectsOfType(typeof(Vehicle)) as Vehicle[];
            foreach (Vehicle vehicle in vehicles)
            {
                vehicle.networkView.RPC("tellSirens", RPCMode.All, new object[] { true });
            }
        }

        private void SirensOff(CommandArgs args)
        {
            Vehicle[] vehicles = UnityEngine.Object.FindObjectsOfType(typeof(Vehicle)) as Vehicle[];
            foreach (Vehicle vehicle in vehicles)
            {
                vehicle.networkView.RPC("tellSirens", RPCMode.All, new object[] { false });
            }
        }

        private void ResetZombies(CommandArgs args)
        {
            SpawnAnimals.reset();
            NetworkChat.sendAlert(args.sender.name + " has respawned all zombies");
        }

        private void Killzombies(CommandArgs args)
        {
            Zombie[] Zombies = UnityEngine.Object.FindObjectsOfType(typeof(Zombie)) as Zombie[];
            foreach (Zombie Zombie in Zombies)
            {
                Zombie.damage(500);
            }
            NetworkChat.sendAlert(args.sender.name + " has killed " + Zombies.Length + " zombies");
        }


        private void ReloadBans(CommandArgs args)
        {
            NetworkBans.load();
        }

        private void SetItemsDelay(CommandArgs args)
        {
            String seconds = args.Parameters[0];
            setItemResetIntervalInSeconds(Convert.ToInt32(seconds));
        }

        private void SetAnnounceDelay(CommandArgs args)
        {
            String seconds = args.Parameters[0];
            setAnnounceIntervalInSeconds(Convert.ToInt32(seconds));
        }

        private void EnableWhitelist(CommandArgs args)
        {
            usingWhitelist = true;
            NetworkChat.sendAlert("Whitelist enabled.");
        }

        private void DisableWhitelist(CommandArgs args)
        {
            usingWhitelist = false;
            NetworkChat.sendAlert("Whitelist disabled.");
        }

        private void Whitelist(CommandArgs args)
        {
            if (args.Parameters[0].Equals("add"))
            {
                args.Parameters.RemoveAt(0);

                String name = args.ParametersAsString;
                String steamid = UserList.getUserFromName(name).steamid;

                System.IO.StreamWriter file = new StreamWriter("Unturned_Data/Managed/mods/AdminCommands/UnturnedWhitelist.txt", true);
                file.WriteLine("");
                file.WriteLine(steamid);
                file.Close();
                WhitelistedSteamIDs.Add(steamid);
            }
            else if (args.Parameters[0].Equals("remove") || args.Parameters[0].Equals("del") || args.Parameters[0].Equals("rem"))
            {
                args.Parameters.RemoveAt(0);

                String name = args.ParametersAsString;
                String steamid = UserList.getUserFromName(name).steamid;

                WhitelistedSteamIDs.Remove(steamid);

                File.Delete("Unturned_Data/Managed/mods/AdminCommands/UnturnedWhitelist.txt");
                System.IO.StreamWriter file = new StreamWriter("Unturned_Data/Managed/mods/AdminCommands/UnturnedWhitelist.txt", true);
                for (int i = 0; i < WhitelistedSteamIDs.Count; i++)
                {
                    file.WriteLine(WhitelistedSteamIDs[i]);
                }
                file.Close();
            }
        }

        private void UnBan(CommandArgs args)
        {
            String name = args.ParametersAsString;
            unban(name);
        }


        private void TeleportToPlayer(CommandArgs args)
        {
            String name = args.ParametersAsString;
            BetterNetworkUser UserToTeleportTo;

            if (name.Length < 2)
            {
                UserToTeleportTo = UserList.users[Convert.ToInt32(name)];
            }
            else
            {
                UserToTeleportTo = UserList.getUserFromName(name);
            }
            args.sender.model.transform.position = UserToTeleportTo.model.transform.position;
            args.sender.model.GetComponent<Life>().networkView.RPC("tellStatePosition", RPCMode.All, new object[] { UserToTeleportTo.model.transform.position, UserToTeleportTo.model.transform.rotation });
        }

        private void TeleportToMe(CommandArgs args)
        {
            String name = args.ParametersAsString;
            BetterNetworkUser UserToTeleportToMe;

            if (name.Length < 2)
            {
                UserToTeleportToMe = UserList.users[Convert.ToInt32(name)];
            }
            else
            {
                UserToTeleportToMe = UserList.getUserFromName(name);
            }
            UserToTeleportToMe.model.transform.position = args.sender.model.transform.position;
            UserToTeleportToMe.model.GetComponent<Life>().networkView.RPC("tellStatePosition", RPCMode.All, new object[] { args.sender.model.transform.position, args.sender.model.transform.rotation });
        }

        private void TeleportToCoords(CommandArgs args)
        {
            Quaternion rotation = args.sender.model.transform.rotation;
            float x = float.Parse(args.Parameters[0]);
            float y = float.Parse(args.Parameters[1]);
            float z = float.Parse(args.Parameters[2]);
            args.sender.model.GetComponent<Life>().networkView.RPC("tellStatePosition", RPCMode.All, new object[] { new Vector3(x, y, z), rotation });
        }

        private void TeleportAll(CommandArgs args)
        {
            Vector3 location = args.sender.model.transform.position;
            Quaternion rotation = args.sender.model.transform.rotation;

            foreach (BetterNetworkUser user in UserList.users)
            {
                user.model.transform.position = location;
                user.model.GetComponent<Life>().networkView.RPC("tellStatePosition", RPCMode.All, new object[] { location, rotation });
            }
        }

        private void Kill(CommandArgs args)
        {
            String naam = args.ParametersAsString;
            UserList.getUserFromName(naam).model.GetComponent<Life>().damage(500, "You died of retardedness");
        }

        private void Heal(CommandArgs args)
        {
            if (args.Parameters.Count == 0)
                args.sender.model.GetComponent<Life>().heal(100, true, true);
            else
            {
                String naam = args.ParametersAsString;
                UserList.getUserFromName(naam).model.GetComponent<Life>().heal(100, true, true);
            }
        }

        private void Promote(CommandArgs args)
        {
            String naam = args.ParametersAsString;
            BetterNetworkUser user = UserList.getUserFromName(naam);

            UserList.promote(user.steamid);

            Reference.Tell(args.sender.player, naam + " has been promoted to level " + UserList.getPermission(user.steamid));
            Reference.Tell(user.player, "You have been promoted to level " + UserList.getPermission(user.steamid));
        }

        private void ShowAdminCommands(CommandArgs args)
        {
            String string1 = " /ban, /kick, /repeat, /reason, /resetitems, /repairvehicles, /refuelvehicles";
            String string2 = " /resetzombies, /killzombies, /kill, /setitemsdelay, /enablewhitelist";
            String string3 = " /disablewhitelist, /whitelist add & remove, /unban, /reloadCommands, ";
            String string4 = " /tptome <playername>, /promote, /online, /heal, /tp, /tpto <x> <y> <z>";
            String string5 = " /i <itemid> <amount>, /car, /kit /sethome, /home  (if enabled)";

            Reference.Tell(args.sender.player, string1);
            Reference.Tell(args.sender.player, string2);
            Reference.Tell(args.sender.player, string3);
            Reference.Tell(args.sender.player, string4);
            Reference.Tell(args.sender.player, string5);
        }

        private void TeleportCar(CommandArgs args)
        {
            Vector3 location = args.sender.model.transform.position;
            Quaternion rotation = args.sender.model.transform.rotation;

            Vehicle[] mapVehicles = UnityEngine.Object.FindObjectsOfType(typeof(Vehicle)) as Vehicle[];

            int random = UnityEngine.Random.Range(0, mapVehicles.Length);
            Vehicle randomVehicle = mapVehicles[random];

            Vector3 newPos = new Vector3(location[0] + 5, location[1] + 50, location[2]);

            randomVehicle.updatePosition(newPos, rotation);
            randomVehicle.transform.position = newPos;
        }

        private void SpawnItem(CommandArgs args)
        {
            int itemid = Convert.ToInt32(args.Parameters[0]);
            int amount = 1;
            if (args.Parameters.Count == 2)
            {
                amount = Convert.ToInt32(args.Parameters[1]);
            }

            Vector3 location = args.sender.model.transform.position;

            for (int i = 0; i < amount; i++)
                SpawnItems.spawnItem(itemid, 1, location);

        }

        private void SpawnKit(CommandArgs args)
        {
            int[] itemids = new int[] { 0x7d4, 0x1b60, 0x2ee0, 0x232c, 0x2711, 0x2afb, 0x465e, 0x465e, 0x465e, 0x465e, 0x465e, 0x465e, 0x465e, 0xfb1, 0x1399, 11, 0x32c8, 0x32c8, 0x36c6, 0x36c6, 0x1f4f, 0x1f4d, 0xbba };
            Vector3 location = args.sender.model.transform.position;

            foreach (int itemid in itemids)
                SpawnItems.spawnItem(itemid, 1, location);

        }



        // HELPER METHODS :D

        #region Helper Methods:  Used by the main command methods to handle some stuff...

        private void Ban(BetterNetworkUser userToBeBanned, string reason)
        {
            NetworkTools.ban(userToBeBanned.player, userToBeBanned.name, userToBeBanned.steamid, reason);
        }

        public void announcesTimeElapsed(object sender, ElapsedEventArgs e)
        {
            announceNext();
        }


        private void announceNext()
        {
            for (int i = announceIndex; i < AnnounceMessages.Length; i++)
            {
                string message = AnnounceMessages[i];
                if (message.Equals(":"))
                {
                    announceIndex = i + 1;
                    return;
                }
                else
                {
                    NetworkChat.sendAlert(message);
                }
            }
            announceIndex = 0;
        }

        public void setAnnounceIntervalInSeconds(int seconds)
        {
            announceIntervalInSeconds = seconds;
            announceTimer.Stop();
            announceTimer.Interval = seconds * 1000;
            announceTimer.Start();
        }

        private void itemsTimeElapsed(object sender, ElapsedEventArgs e)
        {
            resetItems();
        }

        public void setItemResetIntervalInSeconds(int seconds)
        {
            itemsResetIntervalInSeconds = seconds;
            itemsTimer.Stop();
            itemsTimer.Interval = seconds * 1000;
            itemsTimer.Start();
        }

        public void resetItems()
        {
            SpawnItems.reset();
        }



        private static System.Random random = new System.Random((int)DateTime.Now.Ticks);//thanks to McAden
        private string RandomString(int size)
        {
            StringBuilder builder = new StringBuilder();
            char ch;
            for (int i = 0; i < size; i++)
            {
                ch = Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65)));
                builder.Append(ch);
            }

            return builder.ToString();
        }



        private void Log(string p)
        {
            System.IO.StreamWriter file = new StreamWriter("Unturned_Data/Managed/mods/AdminCommands_Log.txt", true);
            file.WriteLine(p);

            file.Close();
        }


        private void kickNonWhitelistedPlayers()
        {
            if (usingWhitelist && updater3 <= 1)
            {
                foreach (BetterNetworkUser user in UserList.users)
                {
                    if (!WhitelistedSteamIDs.Contains(user.steamid))
                    {
                        KICK(user.name, "You are not whitelisted on this server!");
                    }
                }
                this.updater3 = 100;
            }
        }

        public void loadBans()
        {
            bigAssStringWithBannedPlayerNamesAndSteamIDs = PlayerPrefs.GetString("bans");
        }


        public void saveBans()
        {
            PlayerPrefs.SetString("bans", bigAssStringWithBannedPlayerNamesAndSteamIDs);
        }

        public void unban(String name)
        {
            loadBans();
            string bannedppl = bigAssStringWithBannedPlayerNamesAndSteamIDs;

            if (bannedppl.Contains(name))
            {
                int startIndex = bannedppl.IndexOf(name);
                int length = name.Length + 1 + 17 + 2;

                String temp1 = bannedppl.Substring(0, startIndex);
                String temp2 = bannedppl.Substring(startIndex + length);
                bannedppl = temp1 + temp2;
            }

            bigAssStringWithBannedPlayerNamesAndSteamIDs = bannedppl;
            saveBans();
            NetworkBans.load();
        }



        void KICK(String name, String reason)
        {
            Player[] players = GameObject.FindObjectsOfType<Player>();
            foreach (Player p in players)
            {
                if (p.name.Equals(name))
                {
                    NetworkPlayer np = p.networkView.owner;
                    NetworkTools.kick(np, reason);
                    return;
                }
            }
        }



        private void setHome(string steamID, Vector3 location)
        {
            if (playerHomes.ContainsKey(steamID))
            {
                string[] lines = System.IO.File.ReadAllLines(@"Unturned_Data/Managed/mods/AdminCommands/PlayerHomes.txt");
                File.Delete("Unturned_Data/Managed/mods/AdminCommands/PlayerHomes.txt");

                System.IO.StreamWriter file = new StreamWriter("Unturned_Data/Managed/mods/AdminCommands/PlayerHomes.txt", true);


                for (int i = 0; i < lines.Length; i++)
                {
                    if (!lines[i].StartsWith(steamID))
                    {
                        file.WriteLine(lines[i]);
                    }

                }
                file.Close();
            }
            System.IO.StreamWriter file2 = new StreamWriter("Unturned_Data/Managed/mods/AdminCommands/PlayerHomes.txt", true);
            file2.WriteLine(steamID + ":" + location.x + "," + location.y + "," + location.z);
            file2.Close();
            playerHomes[steamID] = location;
        }

        private void home(BetterNetworkUser user)
        {
            user.model.GetComponent<Life>().networkView.RPC("tellStatePosition", RPCMode.All, new object[] { playerHomes[user.steamid], user.model.transform.rotation });
        }

        #endregion


        public void Update()
        {
            kickNonWhitelistedPlayers();
        }



        public void OnGUI()
        {
            if (usingGUI)
            {
                GUI.BeginGroup(new Rect(50, 100, 600, 70));
                GUI.Box(new Rect(0, 0, 530, 400), "Admin Commands v2 running! Last command used: " + lastUsedCommand);
                GUI.EndGroup();
            }

        }

        #region Readconfig: Reads in all the configs at the start

        private void ReadConfigs()
        {
            Directory.CreateDirectory("Unturned_Data/Managed/mods/AdminCommands");


            if (!File.Exists("Unturned_Data/Managed/mods/AdminCommands/config.ini"))  //create config file
            {
                IniFile tempIni = new IniFile("Unturned_Data/Managed/mods/AdminCommands/config.ini");

                tempIni.IniWriteValue("Config", "Using Whitelist", "false");
                tempIni.IniWriteValue("Config", "Using Player Homes", "false");
                tempIni.IniWriteValue("Config", "Show gui", "true");
                tempIni.IniWriteValue("Security", "Using_console", "true");
                tempIni.IniWriteValue("Security", "Console_password", RandomString(8));
                tempIni.IniWriteValue("Security", "Require_command_confirmation", "false");

                tempIni.IniWriteValue("Timers", "Time between item respawns in seconds", "2700");
                tempIni.IniWriteValue("Timers", "Time between announces in seconds", "600");
            }

            IniFile ini = new IniFile("Unturned_Data/Managed/mods/AdminCommands/config.ini");

            //things that need to be added to existing files
            if (ini.IniReadValue("Security", "Using_console").Equals(""))
            {
                ini.IniWriteValue("Security", "Using_console", "true");
            }
            if (ini.IniReadValue("Security", "Console_password").Equals(""))
            {
                ini.IniWriteValue("Security", "Console_password", RandomString(8));
            }
            if (ini.IniReadValue("Security", "Require_command_confirmation").Equals(""))
            {
                ini.IniWriteValue("Security", "Require_command_confirmation", "false");
            }


            usingWhitelist = Boolean.Parse(ini.IniReadValue("Config", "Using Whitelist"));
            usingGUI = Boolean.Parse(ini.IniReadValue("Config", "Show gui"));
            usePlayerHomes = Boolean.Parse(ini.IniReadValue("Config", "Using Player Homes"));


            itemsResetIntervalInSeconds = Int32.Parse(ini.IniReadValue("Timers", "Time between item respawns in seconds"));
            announceIntervalInSeconds = Int32.Parse(ini.IniReadValue("Timers", "Time between announces in seconds"));



            //WHITELIST
            if (!File.Exists("Unturned_Data/Managed/mods/AdminCommands/UnturnedWhitelist.txt"))  //create a template for whitelist
            {
                System.IO.StreamWriter file = new StreamWriter("Unturned_Data/Managed/mods/AdminCommands/UnturnedWhitelist.txt", true);
                file.WriteLine("Nessin");
                file.WriteLine("Some other player");
                file.Close();
            }

            string[] whitelistedLines = System.IO.File.ReadAllLines(@"Unturned_Data/Managed/mods/AdminCommands/UnturnedWhitelist.txt");

            for (int i = 0; i < whitelistedLines.Length; i++)
            {
                if (whitelistedLines[i].Length > 10)
                {
                    WhitelistedSteamIDs.Add(whitelistedLines[i]);
                }
            }

            //PLAYER HOMES
            if (!File.Exists("Unturned_Data/Managed/mods/AdminCommands/playerHomes.txt"))  //create a template for playerHomes
            {
                System.IO.StreamWriter file = new StreamWriter("Unturned_Data/Managed/mods/AdminCommands/playerHomes.txt", true);
                file.WriteLine("");
                file.Close();
            }


            string[] tempHomes = System.IO.File.ReadAllLines(@"Unturned_Data/Managed/mods/AdminCommands/playerHomes.txt");
            for (int i = 0; i < tempHomes.Length; i++)
            {
                if (tempHomes[i].Length > 5)
                {
                    String id = tempHomes[i].Split(':')[0];
                    String location = tempHomes[i].Split(':')[1];

                    String x = location.Split(',')[0];
                    String y = location.Split(',')[1];
                    String z = location.Split(',')[2];

                    Vector3 loc = new Vector3(Convert.ToSingle(x), Convert.ToSingle(y), Convert.ToSingle(z));

                    playerHomes[id] = loc;
                }

            }

            //ANNOUNCEMENTS
            if (!File.Exists("Unturned_Data/Managed/mods/AdminCommands/UnturnedAnnounces.txt"))  //create a template for announcements
            {
                System.IO.StreamWriter file = new StreamWriter("Unturned_Data/Managed/mods/AdminCommands/UnturnedAnnounces.txt", true);
                file.WriteLine("This line will be announced 10 minutes after injecting (or whatever you change the interval to)");
                file.WriteLine("This line will be announced at the same time");
                file.WriteLine(":");
                file.WriteLine("This line will be announced 20 minutes after injecting  (2x interval)");
                file.WriteLine(":");
                file.WriteLine(":");
                file.WriteLine("This line will be announced 40 minutes after injecting  (4x interval)");
                file.WriteLine("And so forth.. then it will go back to the 1st line      (4x interval)");
                file.Close();
            }
            string[] announces = System.IO.File.ReadAllLines(@"Unturned_Data/Managed/mods/AdminCommands/UnturnedAnnounces.txt");
            AnnounceMessages = new String[announces.Length];
            for (int i = 0; i < announces.Length; i++)
            {
                AnnounceMessages[i] = announces[i];
            }


            itemsTimer = new Timer(itemsResetIntervalInSeconds * 1000);
            itemsTimer.Elapsed += new ElapsedEventHandler(this.itemsTimeElapsed);
            itemsTimer.Enabled = true;

            announceTimer = new Timer(announceIntervalInSeconds * 1000);
            announceTimer.Elapsed += new ElapsedEventHandler(this.announcesTimeElapsed);
            announceTimer.Enabled = true;

        }

        #endregion

    }

}