/**
* Move the player's position
*/
public void Move(float forward, float turn, float duration, bool jump)
{
if (Controller == null)
{
return;
}
LegUpdate(forward);
float bob_factor = 0f;
if (walking != 0)
{
bob_factor = Mathf.Abs(left_leg.walk_seq_step) / 300f;
}
var resting = crouch_spring.stable_pos == crouch_spring.pos;
crouch_spring.stable_pos = 0f + base_crouch_factor + (bob_factor * bob_amount);
if (resting)
{
crouch_spring.pos = crouch_spring.stable_pos;
}
crouch_spring.calculate(duration);
crouch_factor = Mathf.Round(Mathf.Clamp(crouch_spring.pos, -1.2f, 1.2f) * 100) / 100f;
//crouch_factor = crouch_spring.pos;
var temp = head.transform.localPosition;
temp.z = head_rest_y - crouch_factor * crouch_dist;
head.transform.localPosition = temp;
var previous_pos = state.pos;
JumpUpdate(jump, duration);
state.on_ground = Controller.isGrounded;
state.mass = get_total_mass();
InputTuple i = new InputTuple(forward, turn * 4f);
state.integrate(Time.fixedTime, duration, i);
transform.localEulerAngles = new Vector3(0, state.angle, 0);
var tp = head.transform.position;
tp.y -= .5f;
Debug.DrawLine(tp, tp + (state.velocity * 100), Color.red);
Debug.DrawLine(tp, tp + (state.accel * 10), Color.cyan);
Debug.DrawLine(tp, tp + (state.momentum * .1f), Color.black);
move = (previous_pos - state.pos);
if (move.magnitude > .001)
{
Controller.Move(move * -1f);
}
//Controller.SimpleMove(state.velocity);
}
private Derivative evaluate2(float t, float dt, Derivative d, InputTuple i)
{
var p = pos + (d.velocity * dt);
var m = momentum + (d.force * dt);
var a = angle + d.torque * dt;
var s = new Integrator(mass, p, Vector3.zero, m, a);
s.recalculate();
return(new Derivative(s.velocity, acceleration(dt, i), torque(dt, i)));
}
public void integrate(float t, float dt, InputTuple i)
{
var a = evaluate1(t, i);
var b = evaluate2(t, dt * .05f, a, i);
var c = evaluate2(t, dt * .05f, b, i);
var d = evaluate2(t, dt, c, i);
var factor = 2f;
var divisor = (1f / 6f);
var dposdt = ((a.velocity + ((b.velocity + c.velocity) * factor)) + d.velocity) * divisor;
var dmomenumdt = ((a.force + ((b.force + c.force) * factor)) + d.force) * divisor;
pos += dposdt;
momentum += (dmomenumdt * dt);
angle += divisor * dt * (a.torque + (factor * (b.torque + c.torque)) + d.torque);
recalculate();
}
public override Vector3 acceleration(float dt, InputTuple i)
{
forward_vector = transform.TransformDirection(Vector3.forward) * -1;
var v = forward_vector * i.forward;
// friction
if (on_ground)
{
friction = 1f;
}
else
{
friction = .02f;
}
var d = new Vector3(accel.x, 0, accel.z) - v;
if (d.magnitude > friction / 5f)
{
d = d.normalized;
d *= friction * 60000f * dt;
}
else
{
d *= friction * 60000f * dt;
}
if (!on_ground)
{
accel.y = -9800f * dt;
}
else
{
d.x -= momentum.x * friction * 2500f * dt;
d.z -= momentum.z * friction * 2500f * dt;
accel.y = Mathf.Max(accel.y, 0);
}
d.y = accel.y;
return(d);
}
public override float torque(float dt, InputTuple i)
{
spin = i.turn * 6000f * dt;
return(spin);
}
public virtual Vector3 acceleration(float dt, InputTuple i)
{
return(Vector3.zero);
}
public virtual float torque(float dt, InputTuple i)
{
return(0);
}
private Derivative evaluate1(float t, InputTuple i)
{
return(new Derivative(velocity, acceleration(0, i), torque(0, i)));
}
