void Start()
 {
     k = 0;
     currentWaveTanksNumber = 5;
     spawnPoint = GameObject.Find("SpawnPoint").GetComponent<Transform>();
     gameModeScript = GameObject.Find("ManagerScripts").GetComponent<GameMode>();
 }

	void Start () {
		if (gameModeIndexSet) {
			gameMode = (GameMode)gameModeIndex;
		}
		if (gameMode == GameMode.Regular) {
			GetComponent<Clock>().StartClock();
		}

		Board.SetPositionFromFen (Definitions.gameStartFen,true);

		ZobristKey.Init ();
		Evaluation.Init ();
		if (regenerateOpeningBook) {
			OpeningBookGenerator.GenerateBook ();
		}
		if (useOpeningBook) {
			OpeningBookReader.Init ();
		}

		playerManager = GetComponent<MoveManager> ();

		playerManager.CreatePlayers ();

		Board.SetPositionFromFen (Definitions.gameStartFen,true);

	}

        public void Initialize()
        {
            inGame = new InGame();
            inGame.Initialize();

            gameMode = GameMode.InGameState;
        }

        public void Start(GameMode gameMode)
        {
            int playercount = GtaPlayer.All.Count;
            bool success = true;

            GtaPlayer player = GtaPlayer.Create(499);

            if (GtaPlayer.All.Count - 1 != playercount)
            {
                Console.WriteLine("DisposureTest: Adding didn't add player to pool.");
                success = false;
            }
            player.Dispose();

            if (GtaPlayer.All.Count != playercount)
            {
                Console.WriteLine("DisposureTest: Disposing didn't remove player from pool.");
                success = false;
            }
            try
            {
                player.SetChatBubble("Test!", Color.Yellow, 100, 10);

                Console.WriteLine("DisposureTest: Passed SetChatBubble.");
                success = false;
            }
            catch (ObjectDisposedException)
            {
                Console.WriteLine("DisposureTest: Exception thrown.");
            }

            Console.WriteLine("DisposureTest successful: {0}", success);
        }

        public void Start(GameMode gameMode)
        {
            Native.RegisterExtension(new TestExtension());

            Console.WriteLine("Call OnTest183()");
            new NativeFunction("CallLocalFunction", typeof (string), typeof (string)).Invoke("OnTest183", "");
        }

    void EndTurn()
    {
        var intGameMode = (int) GameMode;
        intGameMode++;

        GameMode = (GameMode) (intGameMode % Enum.GetNames(typeof (GameMode)).Length);
    }

 /// <summary>
 /// Initializes a new instance of the <see cref="ServerResult" /> class.
 /// </summary>
 /// <param name="level">The level this server is running.</param>
 /// <param name="gameMode">The game mode this server is running.</param>
 /// <param name="gamePreset">The game preset this server is running.</param>
 /// <param name="url">The URL to the server on BattleLog.</param>
 public ServerResult(GameLevel level, GameMode gameMode, GamePreset gamePreset, string url)
 {
     Level = level;
     GameMode = gameMode;
     GamePreset = gamePreset;
     Url = url;
 }

 public PlayerItem(Guid uuid, string name, GameMode mode, int ping)
 {
     this.UUID = uuid;
     this.Name = name;
     this.Gamemode = mode;
     this.Ping = ping;
 }

        /**
         * Constructor
         */
        public Arena(Game g, GameMode mode)
            : base(g)
        {
            this.mode = mode;
            Init();
            bounds = new Rectangle(0, 0, (int)Constants.GAME_WORLD_WIDTH, (int)Constants.GAME_WORLD_HEIGHT);
            this.scale = (float)Constants.GAME_WORLD_WIDTH / (float)background.index.Width;
            player1.LoadContent();
            background = game.getSprite("clouds");
            maxLeft = game.maxLeft;
            maxRight = game.maxRight;
            maxTop = game.maxTop;
            maxButtom = game.maxButtom;
            gui = new GUI(g);
            buttons = new Button[g.blockCounter-9];
            int bCounter = 0;

            foreach (String i in g.blockList)
            {
                Button b ;
                if(bCounter%3==0)
                    b = new Button(g, new Vector2(10, (5 + 50 * bCounter)/3), bCounter, i);
                else if(bCounter%3==1)
                    b = new Button(g, new Vector2(50, (5 + 50 * (bCounter-1))/3), bCounter, i);
                else
                    b = new Button(g, new Vector2(90, (5 + 50 * (bCounter - 2)) / 3), bCounter, i);
                //gamaddEntity(b);
                buttons[bCounter] = b;
                bCounter++;
            }
            deathBall = game.getSprite("deathBall");
        }

    public static void ResetLevel()
    {
        mode = GameMode.Pause;
        previousGameMode = GameMode.Chase;

        gameModeTimer = 0.0f;
    }

    public void Apply(GameModeManagerDef _def)
    {
        if (_def.mode != null)
        {
            if ( ! _def.mode.overrideMode)
            {
                if (mode != null || m_ModeToSet != null)
                {
                    Debug.Log("Mode is already exist. ");
                }
            }

            m_ModeToSet = _def.mode;

            CancelInvoke("SetupProc");

            if (setupDelay <= 0f)
            {
                Debug.LogWarning("Setup mode without delay. Sure?");
                SetupProc();
            }
            else
            {
                Invoke("SetupProc", setupDelay);
            }
        }
    }

 public ScoreDTO(int player_id, int score, Difficulty difficulty, GameMode game_mode)
 {
     this.player_id = player_id;
     this.score = score;
     this.difficulty = difficulty;
     this.game_mode = game_mode;
 }

    public static void UploadScoreToServer(string name, UInt32 score, GameMode gameMode, string levelName)
    {
        if (name.Length != 3) return;
        try
        {
            ScoreGameType gameType = gameTypeLookup[gameMode];
            ScoreLevel level = levelLookup[levelName];
            
            byte[] buffer = new byte[9];

            new ASCIIEncoding().GetBytes(name).CopyTo(buffer, 0);

            // Convert score to bytes
            buffer[3] = (byte)((score & 0xFF000000) >> 24);
            buffer[4] = (byte)((score & 0x00FF0000) >> 16);
            buffer[5] = (byte)((score & 0x0000FF00) >>  8);
            buffer[6] = (byte)((score & 0x000000FF) >>  0);

            buffer[7] = (byte)gameType;
            buffer[8] = (byte)level;

            Coroutiner.StartCoroutine(SendData(GetEncryptedBytes(buffer)));
        }
        catch (Exception) { Debug.Log("Error uploading score to server"); }
    }

 private void CheckForGameStart()
 {
     if(m_gameMode == GameMode.ReadyUp && m_playerReady[0] && m_playerReady[1])
     {
         m_gameMode = GameMode.Play;
     }
 }

 public void changeModeToGameover()
 {
     gmode = GameMode.GAMEOVER;
     gameoverText.gameObject.active = true;
     touchtostartText.gameObject.active = true;
     ShipInstance.gameObject.active = false;
 }

        public void Launch(string segueId, GameMode mode, GameDifficulty difficulty, Filter filter)
        {
            SegueId = segueId;
              SelectedMode = mode;
              SelectedDifficulty = difficulty;
              SelectedFilter = filter;

              if (SelectedFilter == null)
              {
            SelectedFilter = new Filter("0", "Siphon filter", "defaultIcon");
              }

              UIViewController.InvokeInBackground(() => {
            int gamesCount = SelectedFilter.Load();

            mController.BeginInvokeOnMainThread(() => {
              if (gamesCount < 30)
              {
            Dialogs.ShowDebugFilterTooRestrictive();
              }
              else
              {
            mController.PerformSegue(SegueId, mController);
              }
            });
              });
        }

        public void AddCommandBindings(GameMode mode)
        {
            // add common bindings
            m_mainWindow.CommandBindings.AddRange(new CommandBinding[] {
                new CommandBinding(ClientCommands.AutoAdvanceTurnCommand, AutoAdvanceTurnHandler),
                new CommandBinding(ClientCommands.OpenConsoleCommand, OpenConsoleHandler),
                new CommandBinding(ClientCommands.OpenFocusDebugCommand, OpenFocusDebugHandler),
            });

            // add mode specific bindings
            switch (mode)
            {
                case GameMode.Fortress:
                    foreach (var kvp in ClientTools.ToolDatas)
                    {
                        var toolMode = kvp.Value.Mode;
                        m_mainWindow.CommandBindings.Add(new CommandBinding(kvp.Value.Command,
                            (s, e) => m_mainWindow.ClientTools.ToolMode = toolMode));
                    }
                    break;

                case GameMode.Adventure:
                    m_mainWindow.CommandBindings.AddRange(new CommandBinding[] {
                        new CommandBinding(ClientCommands.DropItemCommand, DropItemHandler),
                        new CommandBinding(ClientCommands.GetItemCommand, GetItemHandler),
                        new CommandBinding(ClientCommands.RemoveItemCommand, RemoveItemHandler),
                        new CommandBinding(ClientCommands.WearItemCommand, WearItemHandler),
                        new CommandBinding(ClientCommands.InventoryCommand, InventoryHandler),
                    });
                    break;
            }
        }

        public Submarine(GameMode gameMode)
            : base()
        {
            speed = (float)(GameConstants.EnemySpeed * 1.5);
            damage = GameConstants.TerminatorShootingDamage;
            timeBetweenFire = 2.0f;
            isBigBoss = true;
            random = new Random();
            health = 6000;
            //health = 1;

            //if (PlayGameScene.currentLevel > 10)
            //    perceptionRadius = GameConstants.BossPerceptionRadius * (HydroBot.gamePlusLevel + 1);
            //else
            perceptionRadius = GameConstants.BossPerceptionRadius;
            basicExperienceReward = 2000;

            if (PoseidonGame.gamePlus)
            {
                speed *= (1.0f + (float)HydroBot.gamePlusLevel / 4);
                damage *= (HydroBot.gamePlusLevel + 1);
                timeBetweenFire /= (1 + HydroBot.gamePlusLevel * 0.25f);
                health += (HydroBot.gamePlusLevel * 3000);
                basicExperienceReward *= (HydroBot.gamePlusLevel + 1);
                timeBetweenPowerUse /= (1 + (float)HydroBot.gamePlusLevel * 0.25f);
            }
            maxHealth = health;
            //basicExperienceReward = 1;
            this.gameMode = gameMode;
        }

    void OnLevelWasLoaded(int levelIndex)
    {
        //reset the game mode reference from the new gamemode object
        if (aGameMode == null || gameModeObject == null)
        {
            //look for game mode object in scene
            if (gameModeObject == null)
                gameModeObject = GameObject.Find("GameMode");

            //if there's no game mode object, make a default one
            if (gameModeObject == null)
            {
                gameModeObject = new GameObject("GameMode");
                aGameMode = gameModeObject.AddComponent<GameMode>();
            }

            //if game mode object exists, get its game mode component or make one
            else
            {
                aGameMode = gameModeObject.GetComponent<GameMode>();
                if (aGameMode == null)
                    aGameMode = gameModeObject.AddComponent<GameMode>();
            }
        }
    }

 public static GameMode GetProperty(string property, GameMode defaultValue)
 {
     try
     {
         string gm = ReadString(property);
         switch (gm.ToLower())
         {
             case "1":
             case "creative":
                 return GameMode.Creative;
             case "0":
             case "survival":
                 return GameMode.Survival;
             case "2":
             case "adventure":
                 return GameMode.Adventure;
             case "3":
             case "spectator":
                 return GameMode.Spectator;
             default:
                 return defaultValue;
         }
     }
     catch
     {
         return defaultValue;
     }
 }