Example #1
0
    // Update is called once per frame
    void Update()
    {
        if (GameManager.instance.CurrentPlayer.isAI)
        {
        }
        else
        {
            currentMouseDirection = UpdateMouseDirection();

            if (Input.GetKeyDown(KeyCode.RightArrow))
            {
                Move(Tile.Direction.East);
            }
            if (Input.GetKeyDown(KeyCode.LeftArrow))
            {
                Move(Tile.Direction.West);
            }
            if (Input.GetKeyDown(KeyCode.UpArrow))
            {
                Move(Tile.Direction.North);
            }
            if (Input.GetKeyDown(KeyCode.DownArrow))
            {
                Move(Tile.Direction.South);
            }
            if (Input.GetMouseButtonDown(0) && !EventSystem.current.IsPointerOverGameObject())
            {
                UseCurrentAbility();
            }

            currentAbility.VisualEffect();
        }
    }
Example #2
0
        public void Move(
            Tile.Direction direction,
            Player movingPlayer,
            Player destinationTilePlayer,
            MoveDetails moveDetails
            )
        {
            Tile currentTile = GetTile(movingPlayer);
            Wall wall        = currentTile.GetWall(direction);

            if (wall == null)
            {
                moveDetails.Status = MoveDetails.MoveStatus.ABORTED;
            }
            else
            {
                wall.GoThrough(
                    movingPlayer, destinationTilePlayer, moveDetails
                    );
                if (moveDetails.Status != MoveDetails.MoveStatus.FAILURE)
                {
                    movingPlayer.Pos.Move(direction);
                }
            }
        }
    public bool IsTileFree(Tile.Direction direction)
    {
        switch (direction)
        {
        case Tile.Direction.North:
            if (!playerController.IsTileOccupied(GameManager.instance.CurrentPlayer.mapPosition.x, GameManager.instance.CurrentPlayer.mapPosition.y + 1))
            {
                return(true);
            }
            break;

        case Tile.Direction.East:
            if (!GameManager.instance.map.tiles[GameManager.instance.CurrentPlayer.mapPosition.x, GameManager.instance.CurrentPlayer.mapPosition.y].east &&
                !playerController.IsTileOccupied(GameManager.instance.CurrentPlayer.mapPosition.x + 1, GameManager.instance.CurrentPlayer.mapPosition.y))
            {
                return(true);
            }
            break;

        case Tile.Direction.South:
            if (!playerController.IsTileOccupied(GameManager.instance.CurrentPlayer.mapPosition.x, GameManager.instance.CurrentPlayer.mapPosition.y - 1))
            {
                return(true);
            }
            break;

        case Tile.Direction.West:
            if (!playerController.IsTileOccupied(GameManager.instance.CurrentPlayer.mapPosition.x - 1, GameManager.instance.CurrentPlayer.mapPosition.y))
            {
                return(true);
            }
            break;
        }
        return(false);
    }
    public bool IsWalled(Tile.Direction direction)
    {
        switch (direction)
        {
        case Tile.Direction.North:
            if (!GameManager.instance.map.tiles[GameManager.instance.CurrentPlayer.mapPosition.x, GameManager.instance.CurrentPlayer.mapPosition.y].north)
            {
                return(true);
            }
            break;

        case Tile.Direction.East:
            if (!GameManager.instance.map.tiles[GameManager.instance.CurrentPlayer.mapPosition.x, GameManager.instance.CurrentPlayer.mapPosition.y].east)
            {
                return(true);
            }
            break;

        case Tile.Direction.South:
            if (!GameManager.instance.map.tiles[GameManager.instance.CurrentPlayer.mapPosition.x, GameManager.instance.CurrentPlayer.mapPosition.y].south)
            {
                return(true);
            }
            break;

        case Tile.Direction.West:
            if (!GameManager.instance.map.tiles[GameManager.instance.CurrentPlayer.mapPosition.x, GameManager.instance.CurrentPlayer.mapPosition.y].west)
            {
                return(true);
            }
            break;
        }
        return(false);
    }
Example #5
0
        public Position OffsetPosition(Tile.Direction direction)
        {
            Position position = new Position(x, y);

            position.Move(direction);
            return(position);
        }
        protected bool GetEventCollision()
        {
            int[] playerPos     = Global.action.tileMap.player.GetMapPos();
            bool  isPlayerThere = false;

            Tile.Direction dir = GetDir();
            IEvent         e   = null;

            if (dir == Tile.Direction.NORTH)
            {
                e             = Global.action.tileMap.GetEvent(mapX, mapY + 1, mapZ);
                isPlayerThere = (playerPos[BasicEvent.X] == mapX && playerPos[BasicEvent.Y] == mapY + 1 && playerPos[BasicEvent.Z] == mapZ);
            }
            if (dir == Tile.Direction.SOUTH)
            {
                e             = Global.action.tileMap.GetEvent(mapX, mapY - 1, mapZ);
                isPlayerThere = (playerPos[BasicEvent.X] == mapX && playerPos[BasicEvent.Y] == mapY - 1 && playerPos[BasicEvent.Z] == mapZ);
            }
            if (dir == Tile.Direction.EAST)
            {
                e             = Global.action.tileMap.GetEvent(mapX + 1, mapY, mapZ);
                isPlayerThere = (playerPos[BasicEvent.X] == mapX + 1 && playerPos[BasicEvent.Y] == mapY && playerPos[BasicEvent.Z] == mapZ);
            }
            if (dir == Tile.Direction.WEST)
            {
                e             = Global.action.tileMap.GetEvent(mapX - 1, mapY, mapZ);
                isPlayerThere = (playerPos[BasicEvent.X] == mapX - 1 && playerPos[BasicEvent.Y] == mapY && playerPos[BasicEvent.Z] == mapZ);
            }
            return(!isPlayerThere && (e == null || (e != null && e.GetPassage() && !e.IsForPlayerOnly())));
        }
Example #7
0
    public void Move(Tile.Direction direction)
    {
        switch (direction)
        {
        case Tile.Direction.North:
            if (!GameManager.instance.map.tiles[GameManager.instance.CurrentPlayer.mapPosition.x, GameManager.instance.CurrentPlayer.mapPosition.y].north &&
                !IsTileOccupied(GameManager.instance.CurrentPlayer.mapPosition.x, GameManager.instance.CurrentPlayer.mapPosition.y + 1))
            {
                GameManager.instance.CurrentPlayer.transform.Translate(new Vector3(0, 0, 1 + GameManager.instance.map.tilePadding));
                GameManager.instance.CurrentPlayer.mapPosition.y++;
            }
            else
            {
                return;
            }
            break;

        case Tile.Direction.East:
            if (!GameManager.instance.map.tiles[GameManager.instance.CurrentPlayer.mapPosition.x, GameManager.instance.CurrentPlayer.mapPosition.y].east &&
                !IsTileOccupied(GameManager.instance.CurrentPlayer.mapPosition.x + 1, GameManager.instance.CurrentPlayer.mapPosition.y))
            {
                GameManager.instance.CurrentPlayer.transform.Translate(new Vector3(1 + GameManager.instance.map.tilePadding, 0, 0));
                GameManager.instance.CurrentPlayer.mapPosition.x++;
            }
            else
            {
                return;
            }
            break;

        case Tile.Direction.South:
            if (!GameManager.instance.map.tiles[GameManager.instance.CurrentPlayer.mapPosition.x, GameManager.instance.CurrentPlayer.mapPosition.y].south &&
                !IsTileOccupied(GameManager.instance.CurrentPlayer.mapPosition.x, GameManager.instance.CurrentPlayer.mapPosition.y - 1))
            {
                GameManager.instance.CurrentPlayer.transform.Translate(new Vector3(0, 0, -1 - GameManager.instance.map.tilePadding));
                GameManager.instance.CurrentPlayer.mapPosition.y--;
            }
            else
            {
                return;
            }
            break;

        case Tile.Direction.West:
            if (!GameManager.instance.map.tiles[GameManager.instance.CurrentPlayer.mapPosition.x, GameManager.instance.CurrentPlayer.mapPosition.y].west &&
                !IsTileOccupied(GameManager.instance.CurrentPlayer.mapPosition.x - 1, GameManager.instance.CurrentPlayer.mapPosition.y))
            {
                GameManager.instance.CurrentPlayer.transform.Translate(new Vector3(-1 - GameManager.instance.map.tilePadding, 0, 0));
                GameManager.instance.CurrentPlayer.mapPosition.x--;
            }
            else
            {
                return;
            }
            break;
        }

        UseMoves(MoveCost);
    }
Example #8
0
 public void UseCurrentAbility(Tile.Direction direction)
 {
     if (currentAbility.cost > GameManager.instance.CurrentPlayer.Moves)
     {
         return;
     }
     currentAbility.Use(direction);
 }
Example #9
0
 public OWPlayer(string texturePath, int[] mapPos, Tile.Direction dir) : base(texturePath, mapPos, dir, "Player")
 {
     this.texturePath = texturePath;
     mapX             = mapPos[0];
     mapY             = mapPos[1];
     mapZ             = mapPos[2];
     SetDir(dir);
 }
Example #10
0
        void Update()
        {
            m_newInput = GetCurrentInput();

            if (m_waitForNoInput && m_newInput == Tile.Direction.NONE)
            {
                m_waitForNoInput = false;
            }
        }
Example #11
0
 public Character(string texturePath, int[] mapPos, Tile.Direction dir, string name)
 {
     this.texturePath = texturePath;
     mapX = mapPos[0];
     mapY = mapPos[1];
     mapZ = mapPos[2];
     this.dir = dir;
     this.name = name;
 }
 public override bool Use(Tile.Direction direction)
 {
     if (GameManager.instance.map.tiles[GameManager.instance.CurrentPlayer.mapPosition.x, GameManager.instance.CurrentPlayer.mapPosition.y].DestroyWall(direction))
     {
         GameManager.instance.playerController.UseMoves(cost);
         return(true);
     }
     return(false);
 }
Example #13
0
 public Character(string texturePath, int[] mapPos, Tile.Direction dir, string name)
 {
     this.texturePath = texturePath;
     mapX             = mapPos[0];
     mapY             = mapPos[1];
     mapZ             = mapPos[2];
     this.dir         = dir;
     this.name        = name;
 }
    public override void VisualEffect()
    {
        Player player = GameManager.instance.CurrentPlayer;

        Tile.Direction direction  = GameManager.instance.playerController.currentMouseDirection;
        Tile           playerTile = GameManager.instance.map.tiles[player.mapPosition.x, player.mapPosition.y];
        Wall           newVfxWall = null;

        switch (direction)
        {
        case Tile.Direction.North:
            if (playerTile.north)
            {
                newVfxWall = playerTile.north;
            }
            break;

        case Tile.Direction.East:
            if (playerTile.east)
            {
                newVfxWall = playerTile.east;
            }
            break;

        case Tile.Direction.South:
            if (playerTile.south)
            {
                newVfxWall = playerTile.south;
            }
            break;

        case Tile.Direction.West:
            if (playerTile.west)
            {
                newVfxWall = playerTile.west;
            }
            break;
        }

        if (lastVfxedWall != newVfxWall)
        {
            if (lastVfxedWall != null)
            {
                lastVfxedWall.GetComponent <MeshRenderer>().material = lastVfxedWallMaterial;
            }
            if (newVfxWall != null)
            {
                lastVfxedWallMaterial = newVfxWall.GetComponent <MeshRenderer>().material;
                if (newVfxWall.destructable)
                {
                    newVfxWall.GetComponent <MeshRenderer>().material = vfxMaterial;
                }
            }
            lastVfxedWall = newVfxWall;
        }
    }
Example #15
0
        public void SetTileMap(string mapName, int[] destPos, Tile.Direction dir)
        {
            TileMap nextMap = tileMaps[mapName];

            nextMap.player = tileMap.player;
            nextMap.player.SetMapPos(destPos);
            nextMap.Initialize();
            nextMap.player.SetDir(dir);
            tileMap = nextMap;
        }
Example #16
0
 public void SetDir(Tile.Direction dir)
 {
     this.dir = dir;
     if (animations != null)
     {
         animation = animations[dir.ToString()];
         animation.PauseSet(0);
     }
     travel = new Vector2(0f);
 }
 public SlidingDoor(string texturePath, int[] mapPos, int[] destPos, Tile.Direction dir, Tile.Direction playerDir, string mapDestKey)
 {
     this.texturePath = texturePath;
     mapX             = mapPos[0];
     mapY             = mapPos[1];
     mapZ             = mapPos[2];
     this.destPos     = destPos;
     this.dir         = dir;
     this.playerDir   = playerDir;
     this.mapDestKey  = mapDestKey;
     passage          = true;
 }
Example #18
0
    public IVela GetVela(Tile.Direction direction)
    {
        switch (direction)
        {
        case Tile.Direction.Up: return(colliderUp.Vela);

        case Tile.Direction.Right: return(colliderRight.Vela);

        case Tile.Direction.Down: return(colliderDown.Vela);

        case Tile.Direction.Left: return(colliderLeft.Vela);
        }
        return(null);
    }
Example #19
0
    public bool CanPushing(Tile.Direction direction)
    {
        switch (direction)
        {
        case Tile.Direction.Up: return(colliderUp.CanPushing);

        case Tile.Direction.Right: return(colliderRight.CanPushing);

        case Tile.Direction.Down: return(colliderDown.CanPushing);

        case Tile.Direction.Left: return(colliderLeft.CanPushing);
        }
        return(true);
    }
Example #20
0
 /// <summary>
 /// Called when a directional button is being held.
 /// </summary>
 /// <param name="dir">The direction requested for motion</param>
 public void Move(Tile.Direction dir)
 {
     //DIRECT CLONE IN OWPLAYER...
     if (travel.X == 0 && travel.Y == 0)
     {
         this.dir  = dir;
         animation = animations[dir.ToString()];
         if (GetTileCollision() && GetBuildingCollision() && GetEventCollision())
         {
             if (!animation.running)
             {
                 animation.Start();
             }
             else
             {
                 animation.running = true;
             }
             if (dir == Tile.Direction.NORTH)
             {
                 travel.Y = +0.01f;
                 Global.action.tileMap.UpdateEventGrid(this, GetMapPos(), new int[2] {
                     GetMapPos()[0], GetMapPos()[1] + 1
                 });
             }
             if (dir == Tile.Direction.SOUTH)
             {
                 travel.Y = -0.01f;
                 Global.action.tileMap.UpdateEventGrid(this, GetMapPos(), new int[2] {
                     GetMapPos()[0], GetMapPos()[1] - 1
                 });
             }
             if (dir == Tile.Direction.EAST)
             {
                 travel.X = +0.01f;
                 Global.action.tileMap.UpdateEventGrid(this, GetMapPos(), new int[2] {
                     GetMapPos()[0] + 1, GetMapPos()[1]
                 });
             }
             if (dir == Tile.Direction.WEST)
             {
                 travel.X = -0.01f;
                 Global.action.tileMap.UpdateEventGrid(this, GetMapPos(), new int[2] {
                     GetMapPos()[0] - 1, GetMapPos()[1]
                 });
             }
         }
     }
 }
Example #21
0
        public Tile GetTile(int x, int y, Tile.Direction direction)
        {
            switch (direction)
            {
            case Tile.Direction.EAST:
                return(m_tiles[x + 1, y]);

            case Tile.Direction.WEST:
                return(m_tiles[x - 1, y]);

            case Tile.Direction.SOUTH:
                return(m_tiles[x, y + 1]);

            case Tile.Direction.NORTH:
                return(m_tiles[x, y - 1]);
            }
            return(null);
        }
Example #22
0
    public override void VisualEffect()
    {
        Player player = GameManager.instance.CurrentPlayer;

        Tile.Direction direction  = GameManager.instance.playerController.currentMouseDirection;
        Tile           playerTile = GameManager.instance.map.tiles[player.mapPosition.x, player.mapPosition.y];

        switch (direction)
        {
        case Tile.Direction.North:
            if (!playerTile.north)
            {
                vfxWallInstance.transform.position = player.transform.position + new Vector3(0, 0, 0.5f + GameManager.instance.map.tilePadding / 2);
                vfxWallInstance.transform.LookAt(player.transform.position + Vector3.forward);
            }
            break;

        case Tile.Direction.East:
            if (!playerTile.east)
            {
                vfxWallInstance.transform.position = player.transform.position + new Vector3(0.5f + GameManager.instance.map.tilePadding / 2, 0, 0);
                vfxWallInstance.transform.LookAt(player.transform.position + Vector3.right);
            }
            break;

        case Tile.Direction.South:
            if (!playerTile.south)
            {
                vfxWallInstance.transform.position = player.transform.position + new Vector3(0, 0, -0.5f - GameManager.instance.map.tilePadding / 2);
                vfxWallInstance.transform.LookAt(player.transform.position - Vector3.forward);
            }
            break;

        case Tile.Direction.West:
            if (!playerTile.west)
            {
                vfxWallInstance.transform.position = player.transform.position + new Vector3(-0.5f - GameManager.instance.map.tilePadding / 2, 0, 0);
                vfxWallInstance.transform.LookAt(player.transform.position - Vector3.right);
            }
            break;
        }
    }
Example #23
0
    public override bool Use(Tile.Direction direction)
    {
        Wall result = GameManager.instance.map.tiles[GameManager.instance.CurrentPlayer.mapPosition.x, GameManager.instance.CurrentPlayer.mapPosition.y].CreateWall(direction, GameManager.instance.CurrentPlayer);

        if (result)
        {
            if (result.back.north && result.back.south && result.back.east && result.back.west)
            {
                if (!GameManager.instance.playerController.IsTileOccupied(result.back.mapPosition.x, result.back.mapPosition.y))
                {
                    Tile.ClaimTile(result.back, GameManager.instance.CurrentPlayer);
                    GameManager.instance.CheckWinConditions();
                    return(true);
                }
            }
            GameManager.instance.playerController.UseMoves(cost);
            return(true);
        }
        return(false);
    }
Example #24
0
    public bool ChangeToMatch(WaveElement origin, Tile.Direction to)
    {
        if (collapsed)
        {
            return(false);
        }

        bool changed = false;

        for (int i = 0; i < this.coeff.Length; i++)
        {
            bool edgeMatchFound = false;
            for (int j = 0; j < origin.coeff.Length; j++)
            {
                if (this.coeff[i] && origin.coeff[j])
                {
                    //if (possibleTiles[j].side[(int)to] == possibleTiles[i].side[(int)from])
                    Tile checkedTile = this.possibleTiles[i].tile;
                    Tile originTile  = origin.possibleTiles[j].tile;
                    if (checkedTile.Match(originTile, to))
                    {
                        edgeMatchFound = true;
                        break;
                    }
                }
            }

            if (!edgeMatchFound && coeff[i]) //if the edge doesn't match and the tile isn't already disabled
            {
                Remove(i);
                changed = true;
            }
        }

        if (changed)
        {
            CalculateProbAndEntropy();
        }

        return(changed);
    }
Example #25
0
        public void Move(Tile.Direction direction)
        {
            switch (direction)
            {
            case Tile.Direction.EAST:
                x += 1;
                break;

            case Tile.Direction.WEST:
                x -= 1;
                break;

            case Tile.Direction.SOUTH:
                y += 1;
                break;

            case Tile.Direction.NORTH:
                y -= 1;
                break;
            }
        }
Example #26
0
        public void Update()
        {
            switch (m_stateMachine.CurrentState)
            {
            case GameManagerStateMachine.State.WAIT_FOR_INPUT:
                Tile.Direction input = m_gameInput.GetNewInput();
                if (input != Tile.Direction.NONE)
                {
                    Debug.Log("Input detected : " + input);
                    MoveDetails moveDetails             = m_game.Move(input);
                    List <SoundMixer.SoundFX> allSounds =
                        SoundMixer.GetMoveSounds(moveDetails);
                    if (moveDetails.Status != MoveDetails.MoveStatus.ABORTED)
                    {
                        allSounds.AddRange(SoundMixer.GetNextPlayerSounds(
                                               moveDetails, m_game
                                               ));
                    }
                    m_soundManager.PlayAllSounds(allSounds);
                    m_stateMachine.MoveNext(
                        GameManagerStateMachine.Event.INPUT_RECEIVED
                        );
                }
                break;

            case GameManagerStateMachine.State.PLAYING_SOUNDS:
                if (m_soundManager.Done())
                {
                    m_stateMachine.MoveNext(
                        GameManagerStateMachine.Event.SOUND_FINISHED
                        );
                }
                break;

            default:
                Debug.LogError("Unknown state: " + m_stateMachine.CurrentState);
                break;
            }
        }
    /// <summary>
    /// Devuelve la direccion hacia la que se encuentra "b" respecto a "a"
    /// </summary>
    private Tile.Direction TileDirection(int a, int b)
    {
        Tile.Direction dir = Tile.Direction.UNDEFINED;
        if (a == b + 1)
        {
            dir = Tile.Direction.LEFT;
        }
        else if (a == b - 1)
        {
            dir = Tile.Direction.RIGHT;
        }
        else if (a == b - cols)
        {
            dir = Tile.Direction.UP;
        }
        else if (a == b + cols)
        {
            dir = Tile.Direction.DOWN;
        }

        return(dir);
    }
Example #28
0
    void Action()
    {
        //Turn
        if (Input.GetAxisRaw("Horizontal") > 0)
        {
            Direction = Tile.Direction.Right; //Direita
        }
        else if (Input.GetAxisRaw("Horizontal") < 0)
        {
            Direction = Tile.Direction.Left; //Esquerda
        }
        else if (Input.GetAxisRaw("Vertical") > 0)
        {
            Direction = Tile.Direction.Up; //Cima
        }
        else if (Input.GetAxisRaw("Vertical") < 0)
        {
            Direction = Tile.Direction.Down; //Baixo
        }
        if (CanMove() || CanPushing())
        {
            if (sliderSt.Use(1))   //Usa Stamina
            {
                Move();
                SoundManager.instance.PlaySE(somAndando);

                if (CanPushing())
                {
                    Push();
                    SoundManager.instance.PlaySE(somEmpurrando);
                }
            }
            else
            {
                DialogInBattle.Instance.Player("player-stamina");
            }
        }
    }
Example #29
0
 public void Move(Tile.Direction dir)
 {
     if (dir == Tile.Direction.NORTH)
     {
         //jump
     }
     else if (dir == Tile.Direction.SOUTH)
     {
         //crouch
     }
     else if (dir == Tile.Direction.EAST)
     {
         velocity.X = speed;
         animation  = animations["Walking"];
         flipped    = false;
     }
     else if (dir == Tile.Direction.WEST)
     {
         velocity.X = -speed;
         animation  = animations["Walking"];
         flipped    = true;
     }
 }
    /// <summary>
    /// Dado un index de la tabla de tiles, lo establece a seleccionado o no
    /// Si se selecciona, se anyade al camino actual
    /// Si se deselecciona, se quita del camino actual
    /// </summary>
    /// <param name="boardIndex">Index de la tabla a tratar</param>
    /// <param name="pressed">Si se selecciona o no</param>
    private void PressTile(int boardIndex, bool pressed)
    {
        Tile tileComponent = board_[boardIndex].GetComponent <Tile>();

        boolBoard_[boardIndex] = pressed;
        tileComponent.SetPressed(pressed);

        if (pressed)
        {
            if (path_.Count > 0) // se anyade a un camino existente
            {
                int            lastTileIndex = path_[path_.Count - 1];
                Tile.Direction dir           = TileDirection(boardIndex, lastTileIndex);
                tileComponent.AddPath(dir);
            }

            path_.Add(boardIndex); // se anyade como inicio de camino
        }
        else
        {
            path_.Remove(boardIndex);
        }
    }
Example #31
0
    public TilePos addDirection(Tile.Direction dir)
    {
        TilePos returnVal = new TilePos(this);

        if (dir == Tile.Direction.Up)
        {
            returnVal.y++;
        }
        if (dir == Tile.Direction.Right)
        {
            returnVal.x++;
        }
        if (dir == Tile.Direction.Down)
        {
            returnVal.y--;
        }
        if (dir == Tile.Direction.Left)
        {
            returnVal.x--;
        }

        return(returnVal);
    }
Example #32
0
 public void SetDir(Tile.Direction dir)
 {
     this.dir = dir;
     if (animations != null){
         animation = animations[dir.ToString()];
         animation.PauseSet(0);
     }
     travel = new Vector2(0f);
 }
Example #33
0
 /// <summary>
 /// Called when a directional button is being held.
 /// </summary>
 /// <param name="dir">The direction requested for motion</param>
 public void Move(Tile.Direction dir)
 {
     //DIRECT CLONE IN OWPLAYER...
     if (travel.X == 0 && travel.Y == 0){
         this.dir = dir;
         animation = animations[dir.ToString()];
         if (GetTileCollision() && GetBuildingCollision() && GetEventCollision()){
             if (!animation.running) animation.Start();
             else animation.running = true;
             if (dir == Tile.Direction.NORTH){
                 travel.Y = +0.01f;
                 Global.action.tileMap.UpdateEventGrid(this, GetMapPos(), new int[2] { GetMapPos()[0], GetMapPos()[1] + 1 });
             }
             if (dir == Tile.Direction.SOUTH){
                 travel.Y = -0.01f;
                 Global.action.tileMap.UpdateEventGrid(this, GetMapPos(), new int[2] { GetMapPos()[0], GetMapPos()[1] - 1 });
             }
             if (dir == Tile.Direction.EAST){
                 travel.X = +0.01f;
                 Global.action.tileMap.UpdateEventGrid(this, GetMapPos(), new int[2] { GetMapPos()[0] + 1, GetMapPos()[1] });
             }
             if (dir == Tile.Direction.WEST){
                 travel.X = -0.01f;
                 Global.action.tileMap.UpdateEventGrid(this, GetMapPos(), new int[2] { GetMapPos()[0] - 1, GetMapPos()[1] });
             }
         }
     }
 }