public static double ClientReceive()
 {
     double t = clientBuffer;
     clientBuffer = EmptyBuffer;
     phase = Phase.Send;
     return t;
 }

        public override string Update(Job job, Phase phase, string body = null, string contentType = null, string accept = null)
        {
            job.UpdateState(JobStateType.INPROGRESS, "UPDATE to " + phase.Name);
            string response;
            if (!contentType.ToLower().Equals("application/xml"))
            {
                response = "Invalid Content-Type, expecting application/xml";
                job.UpdatePhaseState(phase.Name, PhaseStateType.FAILED, response);
                throw new RejectedException(response);
            }

            LearnerPersonal data;
            try {
                data = SerialiserFactory.GetXmlSerialiser<LearnerPersonal>().Deserialise(body);
            } catch(Exception e)
            {
                response = "Error decoding xml data: " + e.Message;
                job.UpdatePhaseState(phase.Name, PhaseStateType.FAILED, response);
                throw new RejectedException(response, e);
            }

            NameType name = data.PersonalInformation.Name;
            job.UpdatePhaseState(phase.Name, PhaseStateType.COMPLETED, "UPDATE");
            response = "Got UPDATE message for " + phase.Name + "@" + job.Id + " with content type " + contentType + " and accept " + accept + ".\nGot record for learner:" + name.GivenName + " " + name.FamilyName;
            return response;
        }

        public OperationalSpeedCommand GetSpeedCommand()
        {
            OperationalVehicleState vs = Services.StateProvider.GetVehicleState();
            OperationalSpeedCommand cmd = new OperationalSpeedCommand();
            cmd.brakePressure = TahoeParams.brake_hold;
            cmd.engineTorque = 0;

            if (result != CompletionResult.Failed) {
                if (phase == Phase.Braking) {
                    // chek if we can transition to shifting
                    if (Math.Abs(vs.speed) < 0.05 && vs.brakePressure >= TahoeParams.brake_hold-1) {
                        phase = Phase.Shifting;
                    }
                }

                if (phase == Phase.Shifting) {
                    cmd.transGear = gear;

                    if (vs.transGear == gear) {
                        result = CompletionResult.Completed;
                    }
                }
            }

            return cmd;
        }

		internal override void OnACK_UpdateWindow(RUDPOutgoingPacket packet)
		{
			//---- Reset
			_outOfOrderCount = 0;

			//---- Check the phase
			if (CWND <= _ssthresh)
				Phase = Phase.SlowStart;
			else
				Phase = Phase.CongestionAvoidance;

			//---- Slow start
			if (Phase == Phase.SlowStart)
			{
				// Exponential grow
				CWND += _rudp.MTU;
			}

			//---- Congestion avoidance
			if (Phase == Phase.CongestionAvoidance)
			{
				// (increase of 1 packet every RTT)
				// This is a linear growth of cwnd.
				CWND += (_rudp.MTU * _rudp.MTU) / CWND;
			}

			//---- Check boundaries
			CWND = Math.Max(Math.Min(_awnd, _cwnd), _rudp._mtu);

			//---- Update slow start threshold
			if (_ssthresh < CWND)
				_ssthresh = Math.Min(64 * 1024, CWND);
		}

    void DisplayTexts(Phase phase)
    {
        string topTextString    = "";
        string bottomTextString = "";

        switch (phase)
        {
            case Phase.Memorizes:
                topTextString    = this.maxMonsterNumber + HIKI;
                bottomTextString = MEMORIZES_BOTTOM;
                break;

            case Phase.Player:
                topTextString = ATO + (this.maxMonsterNumber - this.killedMonster) + HIKI;;
                bottomTextString = GAME_BOTTOM;
                break;
        }

        this.topText.guiText.text    = topTextString;
        this.bottomText.guiText.text = bottomTextString;

        this.levelText.guiText.enabled  = true;
        this.topText.guiText.enabled    = true;
        this.bottomText.guiText.enabled = true;
    }

    protected override void StateChanged() {
        switch((EntityState)prevState) {
            case EntityState.Normal:
                bodyCtrl.inputEnabled = false;
                
                ToPhase(Phase.None);
                break;
        }

        base.StateChanged();
                        
        switch((EntityState)state) {
            case EntityState.Normal:
                mNextPhase = Phase.TargetStrike;
                bodyCtrl.inputEnabled = true;
                ToPhase(Phase.Move);
                break;
                
            case EntityState.Dead:
                ToPhase(Phase.Dead);
                break;
                
            case EntityState.Invalid:
                ToPhase(Phase.None);
                break;
        }
    }

        public void ToStringTest()
        {
            var complex = new Complex(3.1, 2.5);
            var exp = new Phase(new ComplexNumber(complex));

            Assert.Equal("phase(3.1+2.5i)", exp.ToString());
        }

 static void ResSetup(Status s)
 {
     if (s == Status.Cancelled)
     phase = Phase.Inactive;
       else
     phase = Phase.Active;
 }

        public void ExecuteTest1()
        {
            var complex = new Complex(3.1, 2.5);
            var exp = new Phase(new ComplexNumber(complex));

            Assert.Equal(complex.Phase, exp.Execute());
        }

        public ActionResult delete(int id)
        {
            PhaseRepository phase_rep = new PhaseRepository();
            Phase phase = new Phase();

            //GET PHASE
            try
            {
                phase = phase_rep.getPhase(id);
            }
            catch (Exception exception)
            {
                //IF THERE IS A MESS UP, RETURN ERROR TO FRONT
                TempData["flash"] = "Unable to retrieve phase: " + exception.Message;
                return RedirectToAction("Index");
            }

            //DELETE PHASE
            try
            {
               phase_rep.delete(phase);
               TempData["flash"] = "Deleted phase.";
               return RedirectToAction("Index");
            }
            catch (Exception exception)
            {
                TempData["flash"] = "Unable to delete phase: " + exception.Message;
                return RedirectToAction("Index");
            }
        }

        public static List<Phase> GetPhases1()
        {
            List<Phase> results = new List<Phase>();
            Phase p = new Phase();            
            p.Id = REGISTERED;
            p.Name = "REGISTERED";
            results.Add(p);
            
            p = new Phase();
            p.Id = SCANNING;
            p.Name = "SCANNING";
            results.Add(p);

            p = new Phase();
            p.Id = MANIPULATION;
            p.Name = "MANIPULATION";
            results.Add(p);

            p = new Phase();
            p.Id = PRINTING;
            p.Name = "PRINTING";
            results.Add(p);

            return results;
        }

    /// <summary>
    /// The update methods follows the flow of:
    /// Input (user enters input (swipe,touch))
    /// Player character processes input
    /// Non-player characters process input
    /// </summary>

    public void Update()
    {
        switch (gamePhase)
        {
            case Phase.INPUT:
                {

                    if(inputManager.TouchListener(out command))
                    {
                        gamePhase = Phase.PLAYER;
                    }
                    break;
                }
            case Phase.PLAYER:
                {
                    player.GetComponent<Player>().PhaseBehavior(command);
                    gamePhase = Phase.ENEMY;
                    break;
                }
            case Phase.ENEMY:
                {
                    foreach(GameObject e in enemies)
                    {
                        e.GetComponent<Enemy>().PhaseBehavior(command);
                    }
                    gamePhase = Phase.INPUT;
                    break;
                }
        }
    }

 private void SetPhase(Phase phase)
 {
     if (this.phase != phase)
     {
         this.phase = phase;
         switch (phase)
         {
             case Phase.None:
                 PlayMusic("");
                 break;
             case Phase.Intro:
                 PlayMusic("Intro Music");
                 break;
             case Phase.Scene:
                 PlayMusic("Scene Music");
                 break;
             case Phase.EndingInfiltratorWins:
                 PlayMusic("Outro Music Good");
                 break;
             case Phase.EndingSectWins:
                 PlayMusic("Outro Music Evil");
                 break;
         }
     }
 }

 public static void ChangePhase(Phase phase)
 {
     if (instance != null)
     {
         instance.SetPhase(phase);
     }
 }

    public override void onStartRide()
    {
        foreach (motor m in motors)
        {
            m.GetAxis(this.gameObject);
        }

        base.onStartRide();
        foreach (motor m in motors)
        {
            m.Enter();
        }
        if (phases.Count <= 0)
        {
            animating = false;
            return;
        }
        foreach (motor m in motors)
        {
            m.Enter();
        }

        animating = true;
        phaseNum = 0;
        currentPhase = phases[phaseNum];
        currentPhase.running = true;
        currentPhase.Enter();
        currentPhase.Run();
    }

 static void Calibrate()
 {
     double data = double.Parse(buffer);
     // compute with data (not shown)
     phase = Phase.WaitForEvent;
     //    CalRequested = false;
 }

	public void lowerRoof(){
		if( m_Phase == Phase.Wait ) {
			m_Tweener.Play(true);
			m_Phase = Phase.InMotion;
		} else {
			Debug.Log("Error! Invalid tween state of the roof");
		}
	}

        public LoginSocket(long s, uint addr, int port)
            : base(s, addr, port)
        {
            phase = Phase.Seed;
            PredefinedPacketSizes = new int[] { 4, 62 };

            Trace.WriteLine("Login socket created.", "Communication");
        }

	public void startDone(){
		if( m_Phase == Phase.InMotion ){
			m_Tweener.tweenGroup = 1;
			m_Phase = Phase.Wait;
		} else {
			Debug.Log("Error! Invalid tween state of the roof");
		}
	}

 /// <summary>
 /// Servo smoothly from the joint's present position to a new target position and stay there.
 /// Do this in a constant period (i.e. large movements happen more quickly).
 /// This is a good way to move a head towards a target of interest.
 /// </summary>
 /// <param name="target">Target position of joint</param>
 /// <param name="period">Time over which the movement should take place</param>
 public void ServoWithinPeriod(float target, float period)
 {
     begin = state;						// start from where you are now
     end = target;						// end at target
     attackPeriod = period;				// in this many seconds' time
     sustainPeriod = float.MaxValue;		// stay there indefinitely
     phase = Phase.Transition;
 }