// Use this for initialization
	void Start() {    
		//Set high to be out of pickable range
		location = 0;
		//
		minZombies = 4;
		maxZombies = 5;
		zombieSpeed = 3;
		zombieSpawn = 5;
		timeToSpawn = 5;
		
		// Init Lists //
		zombies = new List<GameObject>();
		currentZombies = new List<GameObject>();
		zombieWave = new List<int>();

		//Add Zombies to List//
		zombies.Add(zombie1);
		zombies.Add(zombie2);
		zombies.Add(zombie3);
		zombies.Add(zombie4);
		//
		spawnLocations = new List<Vector3>();
		//Store locations in list
		for (int x = -150; x < 180; x += 30) {
			spawnLocations.Add(new Vector3(x, 0, 1500));
		}
		//LINK Scripts//
		bc = gameObject.GetComponent<BuildingControl>();
		gs = GameObject.Find ("GameController").GetComponent<GameState>();

	}

        protected override void Draw(GameTime gameTime)
        {
            if(_state == GameState.Menu)
            {
                if (GamePad.GetState(PlayerIndex.One).Buttons.Start == ButtonState.Pressed)
                    _state = GameState.Menu;

                GraphicsDevice.Clear(Color.CornflowerBlue);
                spriteBatch.Begin();
                play.Draw(spriteBatch);
                options.Draw(spriteBatch);
                exit.Draw(spriteBatch);
                spriteBatch.Draw(Textures.Bullet, new Vector2(Mouse.GetState().X, Mouse.GetState().Y), Color.Gray);
                spriteBatch.End();
            }
            if (_state == GameState.Game)
            {
                GraphicsDevice.Clear(Color.WhiteSmoke);
                spriteBatch.Begin(SpriteSortMode.Texture, BlendState.AlphaBlend);
                handler.Draw(gameTime, spriteBatch);
                spriteBatch.End();
            }
            if (_state == GameState.Pause)
            {
                GraphicsDevice.Clear(Color.White);
                spriteBatch.Begin(SpriteSortMode.Deferred,BlendState.AlphaBlend);
                handler.Draw(gameTime, spriteBatch);
                spriteBatch.Draw(_pauseScreen, Vector2.Zero, Color.White);
                play.Draw(spriteBatch);
                exit.Draw(spriteBatch);
                spriteBatch.Draw(Textures.Bullet, new Vector2(Mouse.GetState().X, Mouse.GetState().Y), Color.Gray);
                spriteBatch.End();
            }
            base.Draw(gameTime);
        }

 public void PauseGame()
 {
     gameState = GameState.PAUSE;
     timer.StopTimer();
     fillterController.StopBlinking();
     fillterController.Change2Black();
 }

        /// <summary>
        /// This will be run on each turns. It must return a direction fot the bot to follow
        /// </summary>
        /// <param name="state">The game state</param>
        /// <returns></returns>
        public string Move(GameState state)
        {
            myFinder = new Pathfinder(state);

            string direction;

            switch (random.Next(0, 5)) {
                case 0:
                    direction = Direction.East;
                    break;

                case 1:
                    direction = Direction.West;
                    break;

                case 2:
                    direction = Direction.North;
                    break;

                case 3:
                    direction = Direction.South;
                    break;

                default:
                    direction = Direction.Stay;
                    break;
            }

            direction = myFinder.GetNextMoveToGetToDestination(2, 2);

            Console.WriteLine("Completed turn {0}, going {1}", state.currentTurn, direction);
            Console.WriteLine(DateTime.Now - delta);
            return direction;
        }

 public void Defeat()
 {
     defeatUI.SetActive(true);
     replayBtn.SetActive(true);
     catAnimator.runtimeAnimatorController = happyAnima;
     state = GameState.GAME_OVER;
 }

		public void Generate(PlayerInfo owner, GameState state, ActionCandidates candidates)
		{
			if (!owner.IsBallOwner || owner.CanBeTackled.Any()) { return; }

			foreach (var direction in WalkingDirections)
			{
				var target = owner.Position + direction;

				// Don't try to leave the field.
				if(Game.Field.IsOnField(target))
				{
					var dribble = PlayerPath.Create(owner, target, MaximumDribbleLength, Distance.Tackle);
					var catchUp = dribble.GetCatchUps(state.Current.OtherPlayers).FirstOrDefault();

					// don't start (too) short walks.
					if(catchUp == null || catchUp.Turn >= MinimumDribbleLength)
					{
						if (catchUp != null) { target = dribble[catchUp.Turn - 2]; }

						var action = Actions.Move(owner, target);
						var length = catchUp == null ? dribble.Count : catchUp.Turn - 1;
						candidates.Add(Evaluator.GetPositionImprovement(owner, target, length), action);
					}
				}
			}
		}

    // Use this for initialization
    void Start()
    {
        gameState = GameState.InGame;
        //SAFE CODE : Check si il existe un autre gamemanager si c'est le cas, je m'autodetruit
        if (gameController != null && gameController != this)
        {
            Destroy(this.gameObject);
            return;
        }

        // pour qu'on puisse y accéder dans les methodes statiques
        gameController = this;

        // L'objet n'est pas détruit quand on change de scène
        //DontDestroyOnLoad(this.gameObject);
        SettingTarget();
        BrowseLists();
        //chargement de menu
        //Application.LoadLevel("Menu");
        //Application.LoadLevel("arena");
        foreach (GameObject go in Killers)
        {
            LoadObjectives(go);
        }
    }

	// Use this for initialization
	void Start () {
		
		GameState freedom = new GameState(){RoomPrompt=StringsStore.Freedom_Prompt};
		GameState lock_1 = new GameState(){RoomPrompt=StringsStore.Lock_1_Prompt};
		GameState cell_mirror = new GameState(){RoomPrompt=StringsStore.Cell_Mirror_Prompt};
		GameState sheets_1 = new GameState(){RoomPrompt=StringsStore.Sheets_1_Prompt};
		GameState mirror_0 = new GameState(){RoomPrompt=StringsStore.Mirror_0_Prompt};
		GameState lock_0 = new GameState(){RoomPrompt=StringsStore.Lock_0_Prompt};
		GameState sheets_0 = new GameState(){RoomPrompt=StringsStore.Sheets_0_Prompt};
		GameState cell_0 = new GameState(){RoomPrompt=StringsStore.PrisonCell_0_Prompt};
		
		cell_0.UserChoices.Add(new UserChoice (KeyCode.S, StringsStore.GoToSheets, sheets_0));
		cell_0.UserChoices.Add(new UserChoice (KeyCode.M, StringsStore.GoToMirror, mirror_0));
		cell_0.UserChoices.Add(new UserChoice (KeyCode.D, StringsStore.GoToDoor, lock_0));
		
		sheets_0.UserChoices.Add(new UserChoice (KeyCode.R, StringsStore.ReturnToCenterCell, cell_0));
		lock_0.UserChoices.Add(new UserChoice(KeyCode.R, StringsStore.ReturnToCenterCell, cell_0));
		mirror_0.UserChoices.Add(new UserChoice (KeyCode.T, StringsStore.SmashMirror, cell_mirror));
		mirror_0.UserChoices.Add(new UserChoice(KeyCode.R, StringsStore.ReturnToCenterCell, cell_0));
		sheets_1.UserChoices.Add(new UserChoice (KeyCode.R, StringsStore.ReturnToBrokenMirror, cell_mirror));
		cell_mirror.UserChoices.Add(new UserChoice (KeyCode.S, StringsStore.GoToSheets, sheets_1));
		cell_mirror.UserChoices.Add(new UserChoice(KeyCode.D, StringsStore.GoToDoor, lock_1));
		lock_1.UserChoices.Add(new UserChoice (KeyCode.O, StringsStore.OpenDoorWithShard, freedom));
		lock_1.UserChoices.Add(new UserChoice(KeyCode.R, StringsStore.ReturnToBrokenMirror, cell_mirror));
		freedom.UserChoices.Add(new UserChoice(KeyCode.P, StringsStore.PlayAgain, cell_0));
		
		MoveToState(cell_0);
	}

        public Game()
        {
            this.sideOnePoints = PointState.Love;
            this.sideTwoPoints = PointState.Love;

            this.state = GameState.PriorToDeuce;
        }

 public bool CaptureAll(GameState state, Coords start, Coords end, Direction dir, out IEnumerable<Coords> capture)
 {
     if (pattern.Count() == 0)
     {
         capture = new List<Coords>();
         return true;
     }
     if (end != null && !OnSameLine(start, end))
     {
         capture = new List<Coords>();
         return false;
     }
     if (!pattern.ElementAt(0).IsTarget)
     {
         throw new NotImplementedException("Target other than the beginning is not supported yet.");
     }
     List<Coords> cAll = new List<Coords>();
     bool retVal = false;
     foreach (var incrementer in ToIncrementers(dir))
     {
         // Try every direction
         List<Coords> c = new List<Coords>();
         if (FindMatch(state, start, end, incrementer, pattern, out c))
         {
             cAll.AddRange(c);
             retVal = true;
         }
     }
     capture = cAll;
     return retVal;
 }

 public bool Match(GameState state, Coords start, Coords end, Direction dir)
 {
     if (pattern.Count() == 0)
     {
         return true;
     }
     if (end != null && !OnSameLine(start, end))
     {
         return false;
     }
     if (!pattern.ElementAt(0).IsTarget)
     {
         throw new NotImplementedException("Target other than the beginning is not supported yet.");
     }
     foreach (var incrementer in ToIncrementers(dir))
     {
         // Try every direction
         List<Coords> c;
         if (FindMatch(state, start, end, incrementer, pattern, out c))
         {
             return true;
         }
     }
     return false;
 }

        public override void Proceed(GameState caller)
        {
            //Clear the score stacks.
            Screen.Player.ScoreBar.ClearStacks();

            if (caller is AgroState)
            {
                //AgroState does all the logic work. No need to add much logic here.
                Spawner spawner = Spawner.GetInstance();

                if (spawner.FriendliesPerEnemies > 2)
                {
                    spawner.FriendliesPerEnemies -= 2;
                    spawner.MaximumAlive += 50;
                }
            }
            else if (caller is RegularState)
            {
                RegularState temp = (RegularState)caller;
                PushState(new AgroState(this, temp.AgroBorder));
            }

            //Call the base.
            base.Proceed(caller);
        }

    public void startGame(Game game)
    {
        Game.current = game;
        State = GameState.Building;

        camera.maxPosition = new Vector3 ((Game.current.Chunk)*34f, 25f, 0f);
        camera.calculateBounds();

        world.clearChunks();
        for (int i=0; i<Game.current.Chunk; i++) {
            GameObject ch = world.generateChunk (i);
            if (Game.current.Team == 1) {
                ch.GetComponent<MeshRenderer>().materials = WhiteMaterial;
            } else {
                ch.GetComponent<MeshRenderer>().materials = BlackMaterial;
            }
        }

        currentBeam = (GameObject) Instantiate(beam);

        GameObject c = (GameObject) Instantiate(character);
        c.transform.position = new Vector3 (1f, 20f, 0f);

        Grunt ai = c.GetComponent<Grunt>();
            ai.isHero = true;
            ai.team = Game.current.Team;
        EnemyController cont = c.GetComponent<EnemyController>();
            cont.maxSpeed = 2.5f;

        camera.target = c.transform;
    }

 public Button(Texture2D img, Rectangle rect, GameState click)
 {
     image = img;
     boundingRect = rect;
     clickFunction = click;
     roomIndex = -1;
 }

        public bool Parse(GameState game, GameState.Entity enchant)
        {
            this.card_id = enchant.CardId;
            this.creator_entity_id = enchant.GetTagOrDefault(GameTag.CREATOR, -1);

            return true;
        }

        private void AdvanceState(Side side)
        {
            if (StillPlaying())
            {
                if (HasEnteredDeuce())
                {
                    this.state = GameState.Deuce;

                    if (GetPointState(side) == PointState.Advantage)
                    {
                        this.state = DetermineWinner(side);
                        return;
                    }

                    if((sideOnePoints == PointState.Deuce && sideTwoPoints == PointState.Deuce)
                        || (sideOnePoints == PointState.Forty && sideTwoPoints == PointState.Forty))
                    {
                        SetPointState(side, PointState.Advantage);
                        return;
                    }

                    sideOnePoints = PointState.Deuce;
                    sideTwoPoints = PointState.Deuce;
                    return;
                }

                RollPoints(side);

                if (((int)GetPointState(side)) > 4)
                {
                    this.state = DetermineWinner(side);
                }
            }
        }

 /// <summary>
 /// Allows the game to perform any initialization it needs to before starting to run.
 /// This is where it can query for any required services and load any non-graphic
 /// related content.  Calling base.Initialize will enumerate through any components
 /// and initialize them as well.
 /// </summary>
 protected override void Initialize()
 {
     IsMouseVisible = true;
     gameState = GameState.TitleScreen;
     camera = new Camera(graphics.GraphicsDevice.Viewport);
     base.Initialize();
 }

        /// <summary>
        /// This will be run on each turns. It must return a direction fot the bot to follow
        /// </summary>
        /// <param name="state">The game state</param>
        /// <returns></returns>
        public string Move(GameState state)
        {
            string direction;
            new Disjkstra().pathTo(new Pos(5, 5), state.myHero.pos, state.board);


            switch (random.Next(0, 5)) {
                case 0:
                    direction = Direction.East;
                    break;

                case 1:
                    direction = Direction.West;
                    break;

                case 2:
                    direction = Direction.North;
                    break;

                case 3:
                    direction = Direction.South;
                    break;

                default:
                    direction = Direction.Stay;
                    break;
            }

            Console.WriteLine("Completed turn {0}, going {1}", state.currentTurn, direction);
            return direction;
        }

 public static void BossUpdate(ContentManager Content, GameTime gameTime, Boss bossDragon, List<EnemyAttack> bossFireBalls, GameState CurrentGameState, List<PlayerAttack> ninjaAttacks, Health healthRectangle)
 {
     healthRectangle.Widht = (int)bossDragon.Life;
     BossSummon(Content, gameTime, bossDragon, bossFireBall, bossFireBalls);
     BossAnimation(gameTime, bossDragon);
     BossCollision(bossDragon, CurrentGameState, ninjaAttacks);
 }

        public void SwitchState(GameState newGameState, string[] args)
        {
            switch (newGameState) {

                case GameState.Login_Menu:
                    loginMenu = new LoginMenu(this, netClient);
                    loginMenu.LoadContent(this.Content);
                    break;

                case GameState.Create_Menu:
                    createMenu = new CreateAccountMenu(this, netClient, args);
                    createMenu.LoadContent(this.Content);
                    break;

                case GameState.Select_Menu:
                    selectMenu = new CharacterSelectionMenu(this, netClient);
                    selectMenu.LoadContent(this.Content);
                    break;

                case GameState.CreateCharacter_Menu:
                    characterCreateMenu = new CharacterCreateMenu(this, netClient, args);
                    characterCreateMenu.LoadContent(this.Content);
                    break;

            }

            gameState = newGameState;
        }