public void Update(PlayerButton input, Facing facing, Boolean paused)
		{
			m_inputbuffer.Add(input, facing);

			if (paused == false)
			{
				foreach (BufferCount count in m_commandcount.Values) count.Tick();
			}

			foreach (Command command in Commands)
			{
				if (command.IsValid == false) continue;

				if (CommandChecker.Check(command, m_inputbuffer) == true)
				{
					Int32 time = command.BufferTime;
					if (paused == true) ++time;

					m_commandcount[command.Name].Set(time);
				}
			}

			m_activecommands.Clear();
			foreach (var data in m_commandcount) if (data.Value.IsActive == true) m_activecommands.Add(data.Key);
		}

 protected bool FacingChanged(Facing f)
 {
     if (f != pFaceDirection)
         return true;
     else
         return false;
 }

		public virtual void CacheMovement(Facing direction, MovementSpeed speed) {
			if (this.CacheMovements) {
				this.Queue.Enqueue(new Movement(direction, speed));
			} else {
				this.Entity.TryMove(direction, speed);
			}
		}

 public static void SetupRobotFixture(this Mock<IRobot> mockRobot, int x, int y, Facing f, bool placed)
 {
     mockRobot.SetupProperty(r => r.X, x);
     mockRobot.SetupProperty(r => r.Y, y);
     mockRobot.SetupProperty(r => r.F, f);
     mockRobot.SetupProperty(r => r.Placed, placed);
 }

 public AddStructure(Position position, StructureType structureType, Facing frontFace)
     : this()
 {
     Position = position;
     StructureType = structureType;
     FrontFace = frontFace;
 }

 public Sprite(Vector2 position, float maxSpeed, Facing facing)
 {
     this.position = position;
     this.maxSpeed = maxSpeed;
     this.facing = facing;
     this.movement = Vector2.Zero;
 }

		public void Add(PlayerButton input, Facing facing)
		{
			if (facing == Facing.Left)
			{
				if (((input & PlayerButton.Left) == PlayerButton.Left) != ((input & PlayerButton.Right) == PlayerButton.Right))
				{
					input ^= PlayerButton.Left;
					input ^= PlayerButton.Right;
				}
			}

			if (((input & PlayerButton.Up) == PlayerButton.Up) && ((input & PlayerButton.Down) == PlayerButton.Down))
			{
				input &= ~PlayerButton.Up;
				input &= ~PlayerButton.Down;
			}

			if (((input & PlayerButton.Left) == PlayerButton.Left) && ((input & PlayerButton.Right) == PlayerButton.Right))
			{
				input &= ~PlayerButton.Left;
				input &= ~PlayerButton.Right;
			}

			m_buffer.Add(input);
			m_size = m_buffer.Size;
		}

    // Update is called once per frame
    void Update()
    {
        if (!Manager.DialogOpen)
        {
            if (Input.GetKey(KeyCode.D) && tr.position == position)
            {
                if(CanMove(Vector3.right))
                    position += Vector3.right * 0.32f;
                direction = Facing.Right;
            }
            else if (Input.GetKey(KeyCode.A) && tr.position == position)
            {
                if (CanMove(Vector3.left))
                    position += Vector3.left * 0.32f;
                direction = Facing.Left;
            }
            else if (Input.GetKey(KeyCode.W) && tr.position == position)
            {
                if (CanMove(Vector3.up))
                    position += Vector3.up * 0.32f;
                direction = Facing.Up;
            }
            else if (Input.GetKey(KeyCode.S) && tr.position == position)
            {
                if (CanMove(Vector3.down))
                    position += Vector3.down * 0.32f;
                direction = Facing.Down;
            }

            transform.position = Vector3.MoveTowards(transform.position, position, Time.deltaTime * moveSpeed);
        }
    }

    // Update is called once per frame
    void FixedUpdate()
    {
        rigidbody.AddForce(gravityBoost * down);

        if (Input.touchCount > 0) {

            if (Input.GetTouch(0).position.x > Screen.width/2) {

                rigidbody.AddForce(jumpForceBoost * jumpRightVector);

                if (facing == Facing.Left) {
                    transform.localScale =

                        new Vector3(

                            transform.localScale.x * -1,
                            transform.localScale.y,
                            transform.localScale.z

                            )

                            ;
                    facing = Facing.Right;
                }

            } else {

                rigidbody.AddForce(jumpForceBoost * jumpLeftVector);

                if (facing == Facing.Right) {
                    transform.localScale =

                        new Vector3(

                            transform.localScale.x * -1,
                            transform.localScale.y,
                            transform.localScale.z

                            )

                            ;
                    facing = Facing.Left;
                }

            }

            gameObject.GetComponent<SpriteRenderer>().sprite = pig_wings_down;

        } else {

            gameObject.GetComponent<SpriteRenderer>().sprite = pig_wings_up;

        }

        if (Input.GetKeyDown(KeyCode.Escape)) {
            Debug.Log("Escape key in pig behaviour");
            Application.LoadLevel(0);
        }
    }

        private TimeSpan timer; // Contador de tempo.

        #endregion Fields

        #region Constructors

        protected Animation(Facing facing, State state)
        {
            timer = TimeSpan.Zero;
            this.color = Color.White;
            this.state = state;
            this.facing = facing;
            this.loopList = new List<Point>();
        }

 public virtual void Update()
 {
     Facing f = CalculateFacing();
     if (FacingChanged(f))
     {
         FaceDirection = f;
     }
 }

 void Application_Place_ValidPlacementParams_Allowed(string command, int xInput, int yInput, Facing fInput, 
     [Frozen] Mock<IRobotService> mockRobotService, Application sut)
 {
     sut.ProcessCommand(command);
     mockRobotService.Verify(rs => rs.Place(It.Is<int>(x => x == xInput),
                                              It.Is<int>(y => y == yInput),
                                              It.Is<Facing>(f => f == fInput)), Times.Once());
 }

    void ChangeWallInDirection(Facing direction, WallType newType)
    {
        GrabTilesFromSelection();

        string prefabPath = "";
        Wall newWall = null;

        switch(newType) {
            case WallType.Basic:
                prefabPath = "Assets/Prefabs/Walls/Basic Wall.prefab";
                break;
            case WallType.Laser:
                prefabPath = "Assets/Prefabs/Walls/Laser Wall.prefab";
                break;
            default:
                Debug.Log("No path for replacement prefab!");
                break;
        }

        var prefab = Resources.LoadAssetAtPath(prefabPath, typeof(Wall));

        if (null == prefab) {
            Debug.Log("Replacement prefab not found!");
            return;
        }

        foreach (Tile tile in selectedTiles) {
            Wall wallToChange = tile.adjacentWalls[(int)direction];

            if (null == wallToChange) {
                Debug.Log("Wall doesn't exist in that direction!");
                continue;
            }

            if (wallToChange.wallType == newType) {
                Debug.Log("Existing wall is already this type.");
                continue;
            }

            newWall = (Wall)GameObject.Instantiate(prefab, wallToChange.transform.position, wallToChange.transform.rotation);
            newWall.transform.parent = wallToChange.transform.parent;
            newWall.facing = wallToChange.facing;
            newWall.adjacentTiles = wallToChange.adjacentTiles;
            newWall.Setup();
            TileVisualizer.instance.SetVisualizationForWall(newWall);

            foreach (Tile adjTile in wallToChange.adjacentTiles) {
                if (adjTile.adjacentWalls[(int)direction] == wallToChange) {
                    adjTile.adjacentWalls[(int)direction] = newWall;
                }
                if (adjTile.adjacentWalls[(int)Utils.UTurnFacing(direction)] == wallToChange) {
                    adjTile.adjacentWalls[(int)Utils.UTurnFacing(direction)] = newWall;
                }
            }

            DestroyImmediate(wallToChange.gameObject);
        }
    }

        void RobotService_Left_NotPlaced_Ignored(Facing start, Facing expected, [Frozen]Mock<IRobot> mockRobot, RobotService sut)
        {
            mockRobot.SetupProperty(x => x.Placed, false);
            mockRobot.SetupProperty(x => x.F, start);

            sut.Left();

            mockRobot.VerifySet(r => r.F = expected, Times.Never());
        }

        void RobotService_Left_Placed_Allowed(Facing start, Facing expected, [Frozen]Mock<IRobot> mockRobot, RobotService sut)
        {
            mockRobot.SetupProperty(x => x.Placed, true);
            mockRobot.SetupProperty(x => x.F, start);

            sut.Left();

            mockRobot.VerifySet(r => r.F = expected, Times.Once());
        }

    /// <summary>
    /// Listen onLeftWall, onRightWall and start moving
    /// </summary>
    override public void Start() {
      base.Start();

      pc2d.onLeftWall += OnLeftWall;
      pc2d.onRightWall += OnRightWall;

      facing = initialFacing;
      input.SetX((float) facing);
    }

        // Used in the game ending to force the player to begin moving against its will
        public void BeginWalkingRight()
        {
            playerState = PlayerState.Walk;
            ObjectState = ObjectState.Grounded;
            facing = Facing.Right;
            sprite.PlayAnimation("Walk");

            SetHorizontalSpeed(180f);
        }

        public void Fire(Vector2 centerPosition, Facing facing)
        {
            _facing = facing;
            Sprite.TextureAtlas.Frame = _facing == Facing.Right ? 0 : 1;

            MovementVector = _facing == Facing.Right ? new Vector2(12.0f, 0.0f) : new Vector2(-12.0f, 0.0f);

            IsAlive = true;
            CenterPosition = centerPosition;
        }

 private static bool FacesThisWay(Vector3 v, Vector3 dir, Facing p, ref float maxDot, ref Facing ret)
 {
     float t = Vector3.Dot(v, dir);
      if (t > maxDot) {
     ret = p;
     maxDot = t;
     return true;
      }
      return false;
 }

        public void Fire(Vector2 position, Facing facing, Character user)
        {
            if (this.FireRate < this.WeaponType.FireRate)
                return;

            Bullet bullet = this.WeaponType.BulletType.Pool.New();
            bullet.Fire(position, facing, user);
            GameManager.BulletLayer.AddChild(bullet);

            this.FireRate = 0;
        }