Esempio n. 1
0
    public void Feed(Vector2Int EatPosition, SnakeBody.FoodType TypeEaten)
    {
        if (TypeEaten == SnakeBody.FoodType.Food)
        {
            GameController.AddWobbleForce(HeadPosition, 0.3f, true);
            if (GameController.Food.Contains(EatPosition))
            {
                GameController.Food.Remove(EatPosition);
            }
            if (IsPlayer || GameController.AIMODE)
            {
                GameController.GrowArena();
                GameController.AddScore();
            }
            GameAssets.Sound.Food.Play();
            Length++;
            GameController.PlaceRandomFood();
        }

        if (TypeEaten == SnakeBody.FoodType.Egg)
        {
            GameController.AddWobbleForce(HeadPosition, 0.05f, true);
            GameController.Eggs.TryGetValue(EatPosition, out FoodTier);
            if (FoodTier == 0)
            {
                Debug.LogError("Snake has eaten invalid egg position: " + EatPosition);
            }
            else
            {
                GameController.Eggs.Remove(EatPosition);
            }
        }

        Engorged  = true;
        Digestion = TypeEaten;
    }
Esempio n. 2
0
    public void FixedUpdateSnake()
    {
        if (Dead || Forging)
        {
            return;
        }

        // AFFECTED PLAYER SPEED
        SpeedMultiplier = 1;
        if (Dying)
        {
            SpeedMultiplier = 5;
        }
        else if (IsPlayer)
        {
            MoveDir MovementFacing = GetMovementFacing();
            if (Facing == MovementFacing)
            {
                BoostTime += Time.fixedUnscaledDeltaTime;
                if (BoostTime >= BOOST_TIME_FLOOR)
                {
                    SpeedMultiplier = 3f;
                }
            }
            else
            {
                BoostTime = 0f;
                if (Facing == GameController.OppositeDirection(MovementFacing))
                {
                    SpeedMultiplier = 0.5f;
                }
            }
        }

        MoveFraction += MoveSpeed * SpeedMultiplier;

        if (MoveFraction > 0.5f && !PathChecked)
        {
            // RUN PATHFINDING FOR AI SNAKES
            if (!IsPlayer || GameController.AIMODE)
            {
                DetermineFacing();
            }

            PathChecked = true;
        }


        if (MoveFraction >= 2)
        {
            Debug.LogWarning("A snake MoveFraction is over 2. This will lead to pathfinding errors. Player: " + IsPlayer);
        }

        while (MoveFraction > 1)
        {
            PathChecked   = false;
            MoveFraction -= 1f;


            if (Dying)
            {
                GameController.AddExplosionToGrid(Bodies.Last.Value.Position);
                RemoveTail();

                if (Bodies.First == null)
                {
                    Dead = true;
                }

                return;
            }

            Vector2Int NewHeadPosition = HeadPosition;
            switch (Facing)
            {
            case MoveDir.Up:
                NewHeadPosition.y++;
                break;

            case MoveDir.Right:
                NewHeadPosition.x++;
                break;

            case MoveDir.Left:
                NewHeadPosition.x--;
                break;

            case MoveDir.Down:
                NewHeadPosition.y--;
                break;

            default:
                break;
            }

            // DETERMINE IF THE SNAKE MUST DIE
            bool DeathCondition = false;
            if (NewHeadPosition.y < GameController.TileIndexMin ||
                NewHeadPosition.x < GameController.TileIndexMin ||
                NewHeadPosition.y > GameController.TileIndexMax ||
                NewHeadPosition.x > GameController.TileIndexMax)
            {
                if (DisplayDeathMessagesFlag)
                {
                    Debug.Log("Snake Death: Left valid tile area.");
                }
                DeathCondition = true;
            }
            if (GameController.CollisionMap[NewHeadPosition.y, NewHeadPosition.x])
            {
                if (IsPlayer)
                {
                    if (!GameController.Food.Contains(NewHeadPosition) && !GameController.Eggs.ContainsKey(NewHeadPosition))
                    {
                        if (DisplayDeathMessagesFlag)
                        {
                            Debug.Log("Snake Death: Player hit block with no food or eggs: " + NewHeadPosition);
                        }
                        DeathCondition = true;
                    }
                }
                else
                {
                    if (!GameController.Food.Contains(NewHeadPosition))
                    {
                        if (!GameController.Eggs.ContainsKey(NewHeadPosition))
                        {
                            if (DisplayDeathMessagesFlag)
                            {
                                Debug.Log("Snake Death: AI hit spot with no food or eggs present: " + NewHeadPosition);
                            }
                            DeathCondition = true;
                        }
                        else
                        {
                            if (GameController.Eggs.TryGetValue(NewHeadPosition, out int EggTier))
                            {
                                if (EggTier >= Tier)
                                {
                                    if (DisplayDeathMessagesFlag)
                                    {
                                        Debug.Log("Snake Death: AI hit an egg of tier equal or higher. Position: " + NewHeadPosition + ", Snake Tier: " + Tier + ", Egg Tier: " + EggTier);
                                    }
                                    DeathCondition = true;
                                }
                            }
                            else
                            {
                                Debug.LogError("Game Tried to access a key that wasn't there.");
                            }
                        }
                    }
                }
            }
            if (DeathCondition)
            {
                StartDying();
                GameController.AddExplosionToGrid(NewHeadPosition);
                return;
            }

            GameController.CollisionMap[HeadPosition.y, HeadPosition.x]       = false;
            GameController.CollisionMap[NewHeadPosition.y, NewHeadPosition.x] = true;
            AddTail(HeadPosition, Facing);
            HeadPosition = NewHeadPosition;

            if (Engorged && Bodies.First != null)
            {
                Bodies.First.Value.Engorged  = true;
                Bodies.First.Value.Digestion = Digestion;
                Bodies.First.Value.FoodTier  = FoodTier;
                Engorged  = false;
                Digestion = SnakeBody.FoodType.None;
            }

            if (GameController.Food.Contains(NewHeadPosition))
            {
                Feed(NewHeadPosition, SnakeBody.FoodType.Food);
            }
            else if (GameController.Eggs.ContainsKey(NewHeadPosition))
            {
                Feed(NewHeadPosition, SnakeBody.FoodType.Egg);
            }

            while (Bodies.Count > Length)
            {
                RemoveTail();
            }
        }
    }