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 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(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 void OnGroundHit(ActorHeader.GroundHit _ground, ActorHeader.GroundHit _lastground, LayerMask _gfilter)
{
}
public void OnGroundHit(ActorHeader.GroundHit ground, ActorHeader.GroundHit lastground, LayerMask layermask)
{
}
