public void setAnimation(Movement.PlayerState newState, float animationSpeed)
 {
     m_actualState = newState;
     m_step = 0;
     m_stepStatus = 0;
     m_animationSpeed = animationSpeed;
 }

 public Entity ReplaceMoveInput(Movement newMovement)
 {
     var component = CreateComponent<MoveInputComponent>(ComponentIds.MoveInput);
     component.movement = newMovement;
     ReplaceComponent(ComponentIds.MoveInput, component);
     return this;
 }

 // Use this for initialization
 void Start()
 {
     guiText = gameObject.GetComponent<GUIText>();
     textBackground = GameObject.Find("ScoreBackground").GetComponent<GUITexture>();
     mic = GameObject.Find ("Beat Detector").GetComponent<MicrophoneInput>();
     player = GameObject.Find ("Player").GetComponent<Movement>();
 }

 /// <summary>
 /// Check if the next move is possible
 /// </summary>
 /// <param name="position">Current position</param>
 /// <param name="movement">Next movement</param>
 /// <param name="newPosition">If the movement is valid this out parametr holds new location</param>
 /// <returns>Possibility of movement</returns>
 private bool Check(Point position, Movement movement, out Point newPosition)
 {
     Point oldPosition = position;
     switch (movement)
     {
         case Movement.Up:
             position.X--;
             break;
         case Movement.Left:
             position.Y--;
             break;
         case Movement.Down:
             position.X++;
             break;
         case Movement.Right:
             position.Y++;
             break;
         default:
             newPosition = position;
             return false;
     }
     newPosition = position;
     if (position.X <= 0 || position.X >= Playground.playgroundSize - 1 || position.Y <= 0 || position.Y >= Playground.playgroundSize - 1) return false;
     Square square = Program.playground.board[position.X][position.Y];
     if (square == Square.Empty || square == Square.Fire || square == character) return true;
     else return false;
 }

 public Alma(int x, int y, Tile.ID type)
     : base(x, y, type)
 {
     AlmaMove = new Movement(Properties.Resources.alma_movement,150);
     dir = Hero.Direction.Down;
     loadRoll();
 }

    /* This method extracts the data from the temporary XML object and places it
     * in runtime movement object that will be processed on the spot.
    */
    IEnumerator ExtractMovement(XmlDocument xml)
    {
        Movement movement;

        //Set the name of the test being run in the global variable
        gs.setTestName(xml.SelectSingleNode("Test/Name").InnerText);

        //Move through each tagged item within the xml document
        foreach (XmlNode node in xml.SelectNodes("Test/Movement")){
            movement = new Movement();

            //Extract and assign tagged items within the xmlDoc to object variables within Movement class
            movement.MovementID = node.SelectSingleNode("MovementId").InnerText;
            movement.MovementDesc = node.SelectSingleNode("MovementDesc").InnerText;

            //Assign MovementDetails to Movement Class variables
            foreach (XmlNode detail in node.SelectNodes("MovementDetail")){
                movement.Sequence = detail.SelectSingleNode("SequenceId").InnerText;
                movement.Path = detail.SelectSingleNode("Path").InnerText;
                movement.PathDesc = detail.SelectSingleNode("PathDesc").InnerText;
                movement.Gait = detail.SelectSingleNode("Gait").InnerText;

                //Call LoadMovement Coroutine method and pass movement object
                //and wait for the finish of Coroutine to process further information.
                yield return StartCoroutine(ProcessMovement(movement));
            }
        }
    }

 void Start()
 {
     move = (Movement)GetComponent(typeof(Movement));
     rend = (Renderer)GetComponent(typeof(Renderer));
     warming = false;
     oldQuote = 0;
 }

 /// <summary>
 /// 	Get the basics components the player need
 /// </summary>
 void Awake()
 {
     moveEnnemy = GetComponent<Movement>();
     jumpEnnemy = GetComponent<Jump>();
     toHunt = Player.GetComponent<Rigidbody2D> ();
     myself = GetComponent<Rigidbody2D> ();
 }

	// Use this for initialization
	void Start () {
		currentHealth = topHealth;
		Player = FindObjectOfType<Movement> ();
		//InvokeRepeating ("decreaseHealth", 1f,1f);
		die = FindObjectOfType<Die> ();
		decreaseHealth();
	}

        public void Game_AddMove_RaisesIsWonEventWhenAddingWinningMoveOnMainDiagonal()
        {
            //Arrange
            NotificationEventArgs<Game> argsWhenGameIsWon = null;
            _game.WonGame += new EventHandler<NotificationEventArgs<Game>>((o, e) => { argsWhenGameIsWon = e; });

            Movement m1 = new Movement(0, 0, 'x', _p1, true);
            Movement m2 = new Movement(1, 1, 'x', _p1, true);
            Movement m3 = new Movement(2, 2, 'x', _p1, true);

            Movement m4 = new Movement(0, 1, 'o', _p2, false);
            Movement m5 = new Movement(0, 2, 'o', _p2, false);

            //Act
            bool moveAdded = _game.AddMove(m1, _p1.Id);

            moveAdded = _game.AddMove(m4, _p2.Id);
            moveAdded = _game.AddMove(m5, _p2.Id);

            moveAdded = _game.AddMove(m2, _p1.Id);
            moveAdded = _game.AddMove(m3, _p1.Id);

            //Assert
            Assert.AreEqual<Game>(argsWhenGameIsWon.Value, _game);
            Assert.IsNotNull(_game.Winner);
        }

 void OnEnable()
 {
     // get relevant components
     playerRigidbody = GameObject.FindWithTag ("Player").GetComponent<Rigidbody> ();
     playerMovement = GameObject.FindWithTag ("Player").GetComponent<Movement> ();
     playerPMat = (PhysicMaterial) Resources.Load ("PhysicMaterials/Ball");
 }

    // Update is called once per frame
    void Update()
    {
        if(isMine)
        {
            // get movement direction
            float mX = Input.GetAxis("Horizontal") * moveSpeed;
            float mY = Input.GetAxis("Vertical") * moveSpeed;

            this.transform.position += (new Vector3(mX, 0f, mY))*Time.deltaTime;

            if (Time.time >= timeOfLastMoveCmd + 0.1f && lastReceivedMove != this.transform.position)
            {
                lastReceivedMove = this.transform.position;
                timeOfLastMoveCmd = Time.time;

                // send move command to server every 0.1 seconds
                Dictionary<byte, object> requestDict = new Dictionary<byte, object>();

                Movement moveMent = new Movement();
                moveMent.actorID = actorInfo.actor.actorID;
                moveMent.posX = this.transform.position.x;
                moveMent.posY = this.transform.position.z;

                requestDict.Add((byte)Parameter.Data,LMLiblary.General.GeneralFunc.Serialize(moveMent));

                StarCollectorClient.connection.OpCustom((byte)AckRequestType.MoveCommand, requestDict, false);
                this.GetComponent<CheckRegion>().Load();
            }

            //transform.position = Vector3.Lerp(transform.position,lastReceivedMove, Time.deltaTime * 20f);
        }
    }

        public static bool IsArcValid (Movement from, Analyzer.Node.Movement to) {
            if (from == Movement.Unknown) {
                return
                    to == Analyzer.Node.Movement.JustDown ||
                    to == Analyzer.Node.Movement.JustDownOrStayDown;
            } else if (from == Movement.Tap) {
                return
                    to == Analyzer.Node.Movement.JustDown ||

                    to == Analyzer.Node.Movement.JustDownOrStayDown;
            } else if (from == Movement.ForceDownStart) {
                return
                    to == Analyzer.Node.Movement.StayDown ||
                    to == Analyzer.Node.Movement.Relax;
            } else if (from == Movement.ForceDown) {
                return
                    to == Analyzer.Node.Movement.StayDown ||

                    to == Analyzer.Node.Movement.Relax;
            } else if (from == Movement.PassiveDown) {
                return
                    to == Analyzer.Node.Movement.JustDown ||
                    to == Analyzer.Node.Movement.JustDownOrStayDown;
            } else {
                throw new ArgumentException();
            }
        }

    public bool checkPush(Direction direction, int force)
    {
        GameObject next = faces[(int)direction];
        if (next != null)
        {
            force--;
            if(next.tag == "pushable" && force >= 0)
            {
                attached = next.GetComponent<Movement>();
                if (attached.checkPush(direction, force))
                {
                    moving = direction;
                    return true;
                }else
                {
                    attached = null;
                    return false;
                }

            }
            else
            {
                return false;
            }
        } else
        {
            return true;
        }
    }

 public new void Awake()
 {
     base.Awake();
     myCamera = GameObject.FindGameObjectWithTag("Player1Camera");
     movement = GetComponent<Movement>();
     shipName = name;
 }

 public void Move(Movement movement)
 {
     switch (movement)
     {
         case Movement.L:
             torso.ApplyForce(new Vector2(-speed, 0), torso.Position);
             break;
     
         case Movement.R:
             torso.ApplyForce(new Vector2(speed, 0), torso.Position);
             break;
     
         case Movement.U:
             torso.ApplyForce(new Vector2(0, -speed), torso.Position);
             break;
     
         case Movement.D:
             torso.ApplyForce(new Vector2(0, speed), torso.Position);
             break;
     }
     if (canJump)
         if (movement == Movement.J)
         {
             torso.ApplyForce(new Vector2( -m_gravRef.m_downDirection.X, -m_gravRef.m_downDirection.Y) * 35, torso.Position);
             canJump = false;
         }
 }

 void Awake()
 {
     var gd = GameObject.Find("/GameDirector");
     gameDirector = gd.GetComponent<GameDirector>();
     id = GetComponent<Id>();
     movement = GetComponent<Movement>();
 }

 /// <summary>
 /// Load the components required for this script.
 /// </summary>
 protected void Awake()
 {
     animator     = GetComponent<Animator>();
     audioSource  = GetComponent<AudioSource>();
     shipMovement = GetComponent<Movement>();
     shipShooter  = GetComponent<Shooter>();
 }

 void Start()
 {
     float h = Screen.height / 4;
     rect = new Rect (Screen.width/2-h, Screen.height/2-h, h*2, h*2);
     movement = GetComponent<Movement>();
     highscores = GetComponent<Highscores>();
 }

 private void Awake()
 {
     this.mTrans = base.transform;
     this.mPanel = base.GetComponent<UIPanel>();
     if (this.mPanel.clipping == UIDrawCall.Clipping.None)
     {
         this.mPanel.clipping = UIDrawCall.Clipping.Invisible;
     }
     if ((this.movement != Movement.Custom) && (this.scale.sqrMagnitude > 0.001f))
     {
         if ((this.scale.x == 1f) && (this.scale.y == 0f))
         {
             this.movement = Movement.Horizontal;
         }
         else if ((this.scale.x == 0f) && (this.scale.y == 1f))
         {
             this.movement = Movement.Vertical;
         }
         else if ((this.scale.x == 1f) && (this.scale.y == 1f))
         {
             this.movement = Movement.Unrestricted;
         }
         else
         {
             this.movement = Movement.Custom;
             this.customMovement.x = this.scale.x;
             this.customMovement.y = this.scale.y;
         }
         this.scale = Vector3.zero;
     }
     if (Application.isPlaying)
     {
         this.mPanel.onChange = (UIPanel.OnChangeDelegate) Delegate.Combine(this.mPanel.onChange, new UIPanel.OnChangeDelegate(this.OnPanelChange));
     }
 }