private void FixedUpdate()
{
if (!_Actor)
{
return;
}
else
{
_Actor._position = transform.position;
Vector2 _mouse = new Vector2(
Input.GetAxisRaw("Mouse X"),
Input.GetAxisRaw("Mouse Y")
);
Quaternion R = LookRotate(
_View.rotation,
_mouse,
_MaxVerticalViewAngle
);
_View.rotation = R;
Cursor.lockState = CursorLockMode.Locked;
Vector2 _input =
new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical"));
Vector3 _wishvel = _View.rotation * new Vector3(_input[0], 0, _input[1]);
_wishvel = Vector3.ClampMagnitude(_wishvel, 1.0F);
if (_Actor.Ground.stable)
{
Vector3 _rit = Vector3.Cross(_wishvel, _Actor._orientation * new Vector3(0, 1, 0));
_rit.Normalize();
Vector3 _fwd = Vector3.Cross(_Actor.Ground.normal, _rit);
_fwd.Normalize();
_wishvel = _fwd * (_wishvel.magnitude);
_Actor.SetVelocity(_wishvel * _MaxMovementSpeed);
}
else
{
_Actor.SetVelocity(_Actor._velocity - Vector3.up * GlobalTime.FDT * 39.62F);
}
if (_Actor.Ground.stable && Input.GetAxis("Fire1") > 0)
{
_Actor.SetSnapEnabled(false);
_Actor.SetVelocity(_Actor._velocity + Vector3.up * 10F);
}
ActorHeader.Move(this, _Actor, GlobalTime.FDT);
transform.position = _Actor._position;
}
}
public override void Simulate(ActorArgs _args)
{
ActorHeader.Actor Actor = _args.Actor;
ActorHeader.GroundHit Ground = Actor.Ground;
Vector3 Velocity = Actor._velocity;
bool JumpRequest = (_args.ActionFlags & (1 << 2)) != 0;
if (Actor.SnapEnabled && Ground.stable && JumpRequest)
{
// Eliminate Y-component of our velocity and instead set it to whatever we'd like:
Velocity[1] = Mathf.Sqrt(2 * (_args.Gravity * _args.GravitationalMultiplier) * JumpHeight);
// We're only doing this since gravitational movement / vertical movement is always
// 100% in the 2nd component of our velocity. We'll never be implementing spherical gravity
// or anything like that as of this moment. Changing it won't be hard either if we
// ever want this functionality.
Actor.SetSnapEnabled(false); // disabling snapping until we've found the ground again
Cursor.lockState = CursorLockMode.Locked;
TimeJumpSnapshot = GlobalTime.T;
_args.AssignHold(WaitToSnapUntil); // wait a few milliseconds to begin snapping again
}
Actor.SetVelocity(Velocity);
}
public override void Simulate(ActorArgs _args)
{
ActorHeader.Actor Actor = _args.Actor;
ActorHeader.GroundHit Ground = Actor.Ground; // Ground is currently last frame as we have not moved until ActorMove() of this simulation
ActorHeader.GroundHit LastGround = Actor.LastGround; // LastGround is the frame prior to the last
Vector3 _v = Actor._velocity;
bool _applyfriction = _v.sqrMagnitude > 0F;
if (!_applyfriction)
{
return;
}
LastGroundSnapshot = (Ground.snapped && !LastGround.snapped)
? GlobalTime.T : LastGroundSnapshot;
float _vm = _v.magnitude;
// Determine whether to apply ground friction or air friction
bool _applygroundfriction = (Actor.SnapEnabled && Ground.stable) && (GlobalTime.T - LastGroundSnapshot) > GroundFrictionLeeway;
if (_applygroundfriction)
{
BehaviourHeader.ApplyFriction(ref _v, _vm, GroundFriction, GlobalTime.FDT);
}
else
{
BehaviourHeader.ApplyFriction(ref _v, _vm, AirFriction, GlobalTime.FDT);
}
Actor.SetVelocity(_v);
}
public void StartFrame()
{
float fdt = Time.fixedDeltaTime;
Actor.SetPosition(transform.position);
Actor.SetOrientation(transform.rotation);
Actor.SetVelocity(Actor.orientation * Vector3.forward * 20F);
}
public override void Simulate(ActorArgs _args)
{
ActorHeader.Actor Actor = _args.Actor;
Vector3 Velocity = Actor._velocity;
Vector3 Wish = _args.ViewWishDir;
//BehaviourHeader.DetermineWishVelocity(ref Velocity, Wish, MaximumFlySpeed, FlyAcceleration * GlobalTime.FDT);
BehaviourHeader.ApplyAcceleration(ref Velocity, Wish, MaximumFlySpeed, FlyAcceleration);
BehaviourHeader.ApplyFriction(ref Velocity, Velocity.magnitude, FlyAirFriction, GlobalTime.FDT);
Actor.SetVelocity(Velocity);
}
public override void Simulate(ActorArgs _args)
{
ActorHeader.Actor Actor = _args.Actor;
ActorHeader.GroundHit Ground = Actor.Ground;
Vector3 Forward = _args.ActorView.forward;
Vector3 Wish = _args.ViewWishDir;
bool Grounded = Actor.SnapEnabled && Ground.stable;
bool DashRequest = (GlobalTime.T - DashRequestSnapshot) > 0.1F &&
DashStamina >= DashCost &&
(_args.ActionFlags & (1 << 3)) != 0;
if (DashRequest) // valid dash
{
bool UseViewDir = Wish.sqrMagnitude == 0;
// Completely eradicate all velocity
Actor.SetVelocity(Vector3.zero);
DashStamina -= DashCost;
Vector3 DashDirection = UseViewDir ? Forward : Wish;
VectorHeader.ClipVector(ref DashDirection, new Vector3(0, 1, 0));
DashDirection.Normalize();
DashRequestSnapshot = GlobalTime.T;
_args.AssignHold(ApplyDashDuration);
Actor.SetVelocity(DashDirection * DashVelocityDelta);
DashEvents?.Invoke(_args, DashState.Enter);
}
else if (Grounded) // If we aren't actually dashing, let's rejuvenate our stamina if we're grounded.
{
DashStamina += DashGrowthRate * GlobalTime.FDT;
DashStamina = Mathf.Min(DashStamina, DashCap);
}
}
public override void Simulate(ActorArgs _args)
{
ActorHeader.Actor Actor = _args.Actor;
ActorHeader.GroundHit Ground = Actor.Ground;
Vector3 Velocity = Actor._velocity;
bool _validgravity = Actor.Ground.stable;
Velocity -= new Vector3(0, 1, 0) * (_args.Gravity * _args.GravitationalMultiplier * GlobalTime.FDT);
Actor.SetVelocity(Velocity);
return;
}
public override void Simulate(ActorArgs _args)
{
ActorHeader.Actor Actor = _args.Actor;
ActorHeader.GroundHit Ground = Actor.Ground;
ActorHeader.GroundHit LastGround = Actor.LastGround;
Vector3 Velocity = Actor._velocity;
Vector3 Wish = _args.ViewWishDir;
bool Grounded = Actor.SnapEnabled && Ground.stable;
if (Grounded && !LastGround.stable) // Landing
{
VectorHeader.ClipVector(ref Velocity, Ground.normal);
}
// Orient Wish Velocity to grounding plane
if (Grounded && OrientVelocityToGroundPlane)
{
VectorHeader.CrossProjection(ref Wish, new Vector3(0, 1, 0), Ground.normal);
}
else
{
// Clip Wish Velocity along upward plane if we're not orienting/stable as we may be able to fight gravity if not done
VectorHeader.ClipVector(ref Wish, new Vector3(0, 1, 0));
Wish.Normalize();
}
//if (Grounded) // Subtract max speed based on stability
// BehaviourHeader.DetermineWishVelocity(ref Velocity, Wish, MaximumGroundMoveSpeed, GroundAcceleration * GlobalTime.FDT);
//else
// BehaviourHeader.DetermineWishVelocity(ref Velocity, Wish, MaximumAirMoveSpeed, AirAcceleration * GlobalTime.FDT);
if (Grounded)
{
BehaviourHeader.ApplyAcceleration(ref Velocity, Wish, MaximumGroundMoveSpeed, GroundAcceleration);
}
else
{
BehaviourHeader.ApplyAcceleration(ref Velocity, Wish, MaximumAirMoveSpeed, AirAcceleration);
}
Actor.SetVelocity(Velocity);
return;
}
public override void Simulate(EnemyArgs _args)
{
if (_args.Target == null)
{
return;
}
ActorHeader.Actor _actor = _args.Actor;
Vector3 _targetv3 = _args.Target.position;
Vector3 _selfv3 = _args.Self.position;
Vector3 _lookv3 = _targetv3 - _selfv3;
_lookv3.Normalize();
_lookv3 *= 16F;
//_lookv3 = Vector3.ClampMagnitude(_lookv3, 1.0F);
_actor.SetVelocity(_lookv3);
}
private void Start()
{
_actor = GetComponent <ActorHeader.Actor>();
_actor.SetMoveType(ActorHeader.MoveType.Slide);
_actor.SetSnapType(ActorHeader.SlideSnapType.Toggled);
_actor.SetSnapEnabled(true);
// update actor state to transform state
_actions.Add((_actor) =>
{
CommandHeader.ApplyActorTransform(transform, _actor);
return(true);
});
// gravity
_actions.Add((_actor) =>
{
if (!_actor.Ground.stable)
{
_actor._velocity -= Vector3.up * 39.62F * GlobalTime.FDT;
}
return(true);
});
// bounce determinism
_actions.Add((_actor) =>
{
if (_bouncecount <= 0)
{
_actor.SetVelocity(Vector3.zero);
_actor.SetSnapEnabled(false);
return(false);
}
else
{
if (_actor.Ground.stable)
{
_bouncecount--;
_actor.SetSnapEnabled(false);
_actor.SetVelocity(_actor.Ground.normal * (_bouncecount));
}
return(true);
}
});
// snap detection procedure
_actions.Add((_actor) =>
{
if (_bouncecount <= 0)
{
return(false);
}
else
{
// wait at least two frames until we determine eligiblity to snap again.
if (!_actor.Ground.stable && !_actor.LastGround.stable)
{
_actor.SetSnapEnabled(true);
}
return(true);
}
});
// move procedure
_actions.Add((_actor) =>
{
if (_bouncecount <= 0)
{
return(false);
}
else
{
ActorHeader.Move(this, _actor, GlobalTime.FDT);
return(true);
}
});
// update transform state to actor state
_actions.Add((_actor) =>
{
CommandHeader.ApplyTransformActor(transform, _actor);
return(true);
});
}