867 lines
31 KiB
C#
867 lines
31 KiB
C#
using System.Collections.Generic;
|
|
using FlaxEngine;
|
|
using Cabrito;
|
|
using System.Diagnostics;
|
|
using System.Threading.Tasks;
|
|
using FlaxEngine.Assertions;
|
|
|
|
namespace Game
|
|
{
|
|
public struct TraceInfo_Old
|
|
{
|
|
public RayCastHit[] hitInfos;
|
|
public bool startSolid;
|
|
|
|
// closest hit
|
|
public float fraction;
|
|
public Vector3 endPosition;
|
|
public Vector3 hitNormal;
|
|
public Vector3 hitPosition;
|
|
|
|
// furthest hit
|
|
//public float maxFraction;
|
|
//public Vector3 maxHitNormal;
|
|
//public Vector3 maxEndPosition;
|
|
}
|
|
|
|
public class PlayerMovement : Script
|
|
{
|
|
[Limit(0, 9000), Tooltip("Base Movement speed")]
|
|
public float MoveSpeed { get; set; } = 320;
|
|
|
|
private float viewPitch;
|
|
private float viewYaw;
|
|
private float viewRoll;
|
|
|
|
private InputEvent onExit = new InputEvent("Exit");
|
|
|
|
private const float collisionMargin = 0.031f * 1.666f;
|
|
|
|
Actor rootActor;
|
|
private RigidBody rigidBody;
|
|
public override void OnAwake()
|
|
{
|
|
base.OnAwake();
|
|
|
|
onExit.Triggered += () =>
|
|
{
|
|
if (Console.IsSafeToQuit)
|
|
Engine.RequestExit();
|
|
};
|
|
|
|
rootActor = Actor.GetChild(0);
|
|
|
|
rigidBody = Actor.As<RigidBody>();
|
|
rigidBody.CollisionEnter += OnCollisionEnter;
|
|
rigidBody.TriggerEnter += OnTriggerEnter;
|
|
rigidBody.TriggerExit += OnTriggerExit;
|
|
|
|
/*proxyBody.CollisionEnter += delegate(Collision collision) {
|
|
if (collision.OtherActor.AttachedRigidBody != null)
|
|
{
|
|
proxyCollision = true;
|
|
}
|
|
};
|
|
proxyBody.CollisionExit += delegate(Collision collision) {
|
|
if (collision.OtherActor.AttachedRigidBody != null)
|
|
{
|
|
proxyCollision = false;
|
|
}
|
|
};*/
|
|
}
|
|
|
|
private List<PhysicsColliderActor> touchingActors = new List<PhysicsColliderActor>();
|
|
private void OnTriggerEnter(PhysicsColliderActor colliderActor)
|
|
{
|
|
//if (colliderActor.AttachedRigidBody == null)
|
|
// return;
|
|
touchingActors.Add(colliderActor);
|
|
Console.Print("trogger: ");
|
|
}
|
|
|
|
private void OnTriggerExit(PhysicsColliderActor colliderActor)
|
|
{
|
|
//if (colliderActor.AttachedRigidBody == null)
|
|
// return;
|
|
|
|
touchingActors.Remove(colliderActor);
|
|
Console.Print("untrogger: ");
|
|
}
|
|
|
|
private void OnCollisionEnter(Collision collision)
|
|
{
|
|
//Console.Print("collision: ");
|
|
}
|
|
|
|
public override void OnDestroy()
|
|
{
|
|
base.OnDestroy();
|
|
|
|
onExit.Dispose();
|
|
}
|
|
|
|
public override void OnStart()
|
|
{
|
|
var initialEulerAngles = Actor.Orientation.EulerAngles;
|
|
viewPitch = initialEulerAngles.X;
|
|
viewYaw = initialEulerAngles.Y;
|
|
viewRoll = initialEulerAngles.Z;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks for overlapping colliders in place using the player's rigidbody.
|
|
/// </summary>
|
|
/// <param name="position">Position</param>
|
|
/// <returns></returns>
|
|
private Collider[] TracePlayer(Vector3 position, float extra = 0.0f)
|
|
{
|
|
Collider[] colliders = null;
|
|
|
|
bool collided = false;
|
|
var capsuleCollider = Actor.GetChild<CapsuleCollider>();
|
|
var boxCollider = Actor.GetChild<BoxCollider>();
|
|
var meshCollider = Actor.GetChild<MeshCollider>();
|
|
PhysicsColliderActor colliderActor = null;
|
|
if (capsuleCollider && capsuleCollider.IsActive)
|
|
{
|
|
colliderActor = capsuleCollider;
|
|
collided = Physics.OverlapCapsule(position,
|
|
capsuleCollider.Radius + extra, capsuleCollider.Height + extra,
|
|
out colliders, capsuleCollider.Orientation,
|
|
uint.MaxValue,
|
|
false);
|
|
}
|
|
else if (meshCollider && meshCollider.IsActive)
|
|
{
|
|
colliderActor = meshCollider;
|
|
collided = Physics.OverlapConvex(position,
|
|
meshCollider.CollisionData, meshCollider.Scale + extra,
|
|
out colliders, meshCollider.Orientation,
|
|
uint.MaxValue,
|
|
false);
|
|
}
|
|
else if (boxCollider && boxCollider.IsActive)
|
|
{
|
|
colliderActor = boxCollider;
|
|
collided = Physics.OverlapBox(position,
|
|
boxCollider.OrientedBox.Extents + extra,
|
|
out colliders, boxCollider.Orientation,
|
|
uint.MaxValue,
|
|
false);
|
|
}
|
|
else
|
|
Assert.Fail("No supported colliders found for rigidbody");
|
|
|
|
if (!collided)
|
|
return colliders;
|
|
|
|
List<Collider> collidersFiltered = new List<Collider>();
|
|
foreach (var collider in colliders)
|
|
{
|
|
if (collider == colliderActor)
|
|
continue;
|
|
|
|
collidersFiltered.Add(collider);
|
|
}
|
|
|
|
if (collidersFiltered.Count == 0)
|
|
return colliders; // self-collision?
|
|
|
|
return collidersFiltered.ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sweeps the player rigidbody in world and returns geometry which was hit during the trace.
|
|
/// </summary>
|
|
/// <param name="start">Start position</param>
|
|
/// <param name="end">End position</param>
|
|
/// <returns></returns>
|
|
private TraceInfo TracePlayer(Vector3 start, Vector3 end, float tolerance = 0.0f)
|
|
{
|
|
TraceInfo traceInfo = new TraceInfo();
|
|
|
|
Vector3 delta = end - start;
|
|
float maxDistance = delta.Length;
|
|
Vector3 direction = delta.Normalized;
|
|
|
|
bool collided = false;
|
|
var capsuleCollider = Actor.GetChild<CapsuleCollider>();
|
|
var boxCollider = Actor.GetChild<BoxCollider>();
|
|
var meshCollider = Actor.GetChild<MeshCollider>();
|
|
PhysicsColliderActor colliderActor = null;
|
|
if (capsuleCollider && capsuleCollider.IsActive)
|
|
{
|
|
colliderActor = capsuleCollider;
|
|
collided = Physics.CapsuleCastAll(start,
|
|
capsuleCollider.Radius + tolerance, capsuleCollider.Height,
|
|
direction, out traceInfo.hitInfos, capsuleCollider.Orientation, maxDistance,
|
|
uint.MaxValue,
|
|
false);
|
|
}
|
|
else if (meshCollider && meshCollider.IsActive)
|
|
{
|
|
colliderActor = meshCollider;
|
|
collided = Physics.ConvexCastAll(start,
|
|
meshCollider.CollisionData, meshCollider.Scale + tolerance,
|
|
direction, out traceInfo.hitInfos, meshCollider.Orientation, maxDistance,
|
|
uint.MaxValue,
|
|
false);
|
|
}
|
|
else if (boxCollider && boxCollider.IsActive)
|
|
{
|
|
colliderActor = boxCollider;
|
|
collided = Physics.BoxCastAll(start,
|
|
boxCollider.OrientedBox.Extents + tolerance,
|
|
direction, out traceInfo.hitInfos, boxCollider.Orientation, maxDistance, uint.MaxValue,
|
|
false);
|
|
}
|
|
|
|
if (collided)
|
|
{
|
|
List<RayCastHit> hitInfosFiltered = new List<RayCastHit>();
|
|
RayCastHit closest = new RayCastHit();
|
|
closest.Distance = float.MaxValue;
|
|
foreach (var hitInfo in traceInfo.hitInfos)
|
|
{
|
|
if (hitInfo.Collider == colliderActor)
|
|
continue;
|
|
|
|
hitInfosFiltered.Add(hitInfo);
|
|
|
|
if (hitInfo.Distance < closest.Distance && hitInfo.Distance != 0.0f)
|
|
closest = hitInfo;
|
|
}
|
|
|
|
if (hitInfosFiltered.Count == 0)
|
|
collided = false; // self-collision?
|
|
else //if (closest.Distance > 0f)
|
|
{
|
|
if (closest.Distance == float.MaxValue)
|
|
{
|
|
foreach (var hitInfo in hitInfosFiltered)
|
|
{
|
|
if (hitInfo.Distance < closest.Distance)
|
|
closest = hitInfo;
|
|
}
|
|
}
|
|
|
|
traceInfo.hitInfos = hitInfosFiltered.ToArray();
|
|
|
|
traceInfo.fraction = closest.Distance / maxDistance;
|
|
traceInfo.hitNormal = closest.Normal;
|
|
traceInfo.hitPosition = closest.Point;
|
|
traceInfo.endPosition = start + (delta * traceInfo.fraction);
|
|
|
|
if (traceInfo.fraction == 0f && maxDistance > 0f)
|
|
traceInfo.startSolid = true;
|
|
}
|
|
/*else
|
|
{
|
|
traceInfo.startSolid = true;
|
|
traceInfo.fraction = 0f;
|
|
}*/
|
|
}
|
|
|
|
if (!collided)
|
|
{
|
|
traceInfo.hitInfos = new RayCastHit[0];
|
|
traceInfo.fraction = 1f;
|
|
traceInfo.endPosition = end;
|
|
}
|
|
|
|
return traceInfo;
|
|
}
|
|
|
|
public override void OnDebugDraw()
|
|
{
|
|
base.OnDebugDraw();
|
|
|
|
var capsuleCollider = Actor.GetChild<CapsuleCollider>();
|
|
var boxCollider = Actor.GetChild<BoxCollider>();
|
|
var meshCollider = Actor.GetChild<MeshCollider>();
|
|
if (capsuleCollider && capsuleCollider.IsActive)
|
|
{
|
|
Quaternion rotation = capsuleCollider.LocalOrientation * Quaternion.Euler(0f, 90f, 0f);
|
|
DebugDraw.DrawWireTube(capsuleCollider.Position, rotation, capsuleCollider.Radius, capsuleCollider.Height, Color.GreenYellow * 0.8f);
|
|
}
|
|
else if (meshCollider && meshCollider.IsActive)
|
|
{
|
|
//Quaternion rotation = meshCollider.LocalOrientation * Quaternion.Euler(0f, 90f, 0f);
|
|
DebugDraw.DrawWireCylinder(meshCollider.Position, meshCollider.Orientation, capsuleCollider.Radius, capsuleCollider.Height + capsuleCollider.Radius * 2, Color.GreenYellow * 0.8f);
|
|
//DebugDraw.DrawWireTube(meshCollider.Position, rotation, meshCollider.Radius, meshCollider.Height, Color.GreenYellow * 0.8f);
|
|
}
|
|
else if (boxCollider && boxCollider.IsActive)
|
|
{
|
|
DebugDraw.DrawWireBox(boxCollider.OrientedBox.GetBoundingBox(), Color.GreenYellow * 0.8f);
|
|
}
|
|
}
|
|
|
|
private void SlideMove(ref Vector3 position, bool stepUp, ref Vector3 velocity, bool asdf = false)
|
|
{
|
|
if (velocity.IsZero)
|
|
return;
|
|
|
|
Vector3 originalPosition = position;
|
|
Vector3 originalVelocity = velocity;
|
|
|
|
float timeleft = Time.DeltaTime;
|
|
|
|
List<Vector3> hitNormals = new List<Vector3>();
|
|
|
|
for (int bump = 0; bump < 4; bump++)
|
|
{
|
|
Vector3 startPos = position;
|
|
Vector3 endPos = position + (velocity * timeleft);
|
|
|
|
TraceInfo trace = TracePlayer(startPos, endPos);
|
|
// TODO: handle portals here
|
|
|
|
float fraction = trace.fraction;
|
|
Vector3 hitNormal = trace.hitNormal;
|
|
|
|
if (trace.startSolid)
|
|
{
|
|
velocity = Vector3.Zero;
|
|
break;
|
|
}
|
|
|
|
if (physicsInteractions)
|
|
{
|
|
RigidBody rigidBody = Actor.As<RigidBody>();
|
|
foreach (var hit in trace.hitInfos)
|
|
{
|
|
if (hit.Collider.AttachedRigidBody == null || hit.Collider.AttachedRigidBody.IsKinematic)
|
|
continue;
|
|
|
|
Vector3 force = -hit.Normal * velocity.Length * rigidBody.Mass;
|
|
//Console.Print("move force: " + (force.Length / timeleft));
|
|
hit.Collider.AttachedRigidBody.AddForce(force, ForceMode.Force);
|
|
}
|
|
}
|
|
|
|
if (fraction > 0f)
|
|
{
|
|
position = trace.endPosition;
|
|
hitNormals.Clear(); // this is present in some forks, not in Q3
|
|
}
|
|
|
|
if (fraction >= 1f)
|
|
break;
|
|
|
|
timeleft *= 1.0f - fraction;
|
|
|
|
// this doesn't seem to do anything, we never have any hitNormals stored here
|
|
bool hitPreviousNormal = false;
|
|
foreach (Vector3 normal in hitNormals)
|
|
{
|
|
if (Vector3.Dot(hitNormal, normal) > 0.99)
|
|
{
|
|
// nudge away from the same wall we hit earlier and try again
|
|
velocity += hitNormal;
|
|
hitPreviousNormal = true;
|
|
break;
|
|
}
|
|
}
|
|
if (hitPreviousNormal)
|
|
continue;
|
|
|
|
hitNormals.Add(hitNormal);
|
|
if (hitNormals.Count != 1)
|
|
Console.Print("hitNormals: " + hitNormals.Count);
|
|
|
|
int plane;
|
|
Vector3 normalMargin = Vector3.Zero;
|
|
for (plane = 0; plane < hitNormals.Count; plane++)
|
|
{
|
|
Vector3 normal = hitNormals[plane];
|
|
|
|
// clip velocity
|
|
velocity -= normal * Vector3.Dot(velocity, normal);
|
|
//velocity = Vector3.ProjectOnPlane(velocity, normal);
|
|
|
|
//traceOffset = normal * 1f;
|
|
normalMargin += normal;
|
|
//position += normal * 0.031f;
|
|
|
|
int plane2;
|
|
for (plane2 = 0; plane2 < hitNormals.Count; plane2++)
|
|
{
|
|
if (plane == plane2)
|
|
continue;
|
|
|
|
if (Vector3.Dot(velocity, hitNormals[plane2]) < 0f)
|
|
break;
|
|
}
|
|
|
|
if (plane2 == hitNormals.Count)
|
|
break;
|
|
}
|
|
|
|
// push off slightly away from the walls to not get stuck
|
|
position += normalMargin.Normalized * collisionMargin;
|
|
|
|
if (plane == hitNormals.Count)
|
|
{
|
|
if (hitNormals.Count == 2)
|
|
{
|
|
Vector3 dir = Vector3.Cross(hitNormals[0], hitNormals[1]);
|
|
//dir.Normalize();
|
|
float dist = Vector3.Dot(dir, velocity);
|
|
velocity = dist * dir;
|
|
}
|
|
else
|
|
{
|
|
velocity = Vector3.Zero;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// nudge very slightly away from the wall to avoid getting stuck
|
|
//position += trace.hitNormal * 0.01f;
|
|
//velocity += trace.hitNormal * 0.01f;
|
|
}
|
|
|
|
// prevents bouncing against the wall
|
|
if (/*velocity.Length > 0f && */Vector3.Dot(velocity, originalVelocity) <= 0f)
|
|
{
|
|
velocity = Vector3.Zero;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
[ReadOnly]
|
|
public bool onGround = false;
|
|
|
|
private const float friction = 4f;
|
|
private const float stopspeed = 100f;
|
|
private const float accelerationGround = 10f;
|
|
private const float jumpVelocity = 270f;
|
|
|
|
private const float maxAirSpeed = 320f;
|
|
private const float maxAirStrafeSpeed = 30f; //Q2+
|
|
private const float airAcceleration = 0.4f * 0f; //Q2+
|
|
private const float airStopAcceleration = 2.5f * 0f; //Q2+
|
|
private const float airStrafeAcceleration = 70f * 0f; //CPM?
|
|
private const float strafeAcceleration = 10f; //QW
|
|
private const float airControl = 0f; //CPM
|
|
private bool physicsInteractions = true;
|
|
|
|
private bool jumped = false;
|
|
|
|
private Vector3 safePosition;
|
|
|
|
[ReadOnly]
|
|
public float CurrentVelocity { get { return currentVelocity.Length; } set {} }
|
|
|
|
private Vector3 currentVelocity;
|
|
public override void OnFixedUpdate()
|
|
{
|
|
Transform rootTrans = rootActor.Transform;
|
|
|
|
Vector3 inputDirection = new Vector3(InputManager.GetAxis("Horizontal"), 0.0f, InputManager.GetAxis("Vertical"));
|
|
Vector3 moveDirection = rootTrans.TransformDirection(inputDirection);
|
|
|
|
Vector3 position = rigidBody.Position;
|
|
Vector3 velocity = rigidBody.LinearVelocity;//currentVelocity;
|
|
|
|
Vector3 wishVelocity = Vector3.Zero;
|
|
if (!inputDirection.IsZero)
|
|
wishVelocity = moveDirection.Normalized * MoveSpeed;
|
|
|
|
#if false
|
|
Collider[] overlaps = TracePlayer(rigidBody.Position, 0.001f * 0f);
|
|
if (overlaps.Length > 0)
|
|
{
|
|
// overlapping with other objects
|
|
//Console.Print("overlap");
|
|
|
|
Collider playerCollider = null;
|
|
var capsuleCollider = Actor.GetChild<CapsuleCollider>();
|
|
var boxCollider = Actor.GetChild<BoxCollider>();
|
|
var meshCollider = Actor.GetChild<MeshCollider>();
|
|
if (capsuleCollider && capsuleCollider.IsActive)
|
|
{
|
|
playerCollider = capsuleCollider;
|
|
}
|
|
else if (meshCollider && meshCollider.IsActive)
|
|
{
|
|
playerCollider = meshCollider;
|
|
|
|
}
|
|
else if (boxCollider && boxCollider.IsActive)
|
|
{
|
|
playerCollider = boxCollider;
|
|
}
|
|
|
|
foreach (var overlap in overlaps)
|
|
{
|
|
if (Collider.ComputePenetration(playerCollider, overlap, out Vector3 direction, out float distance))
|
|
{
|
|
//Console.Print("overlap ok");
|
|
|
|
var type = overlap.Parent.GetType();
|
|
if (overlap.Parent.GetType() == typeof(RigidBody))
|
|
{
|
|
var otherRigidBody = overlap.Parent.As<RigidBody>();
|
|
|
|
var otherMomentum = otherRigidBody.LinearVelocity * otherRigidBody.Mass;
|
|
var myMomentum = rigidBody.LinearVelocity * rigidBody.Mass;
|
|
|
|
var newVelocity = (otherMomentum + myMomentum) / (otherRigidBody.Mass + rigidBody.Mass);
|
|
|
|
Console.Print(overlap.Parent.Name + ": "+ newVelocity.Length.ToString());
|
|
//otherRigidBody.LinearVelocity += -direction.Normalized * newVelocity;
|
|
otherRigidBody.AddForce(-direction.Normalized * newVelocity, ForceMode.Force);
|
|
}
|
|
|
|
position += direction * (distance + 0.001f);
|
|
|
|
/*var oldVelocity = velocity;
|
|
velocity = direction * (distance + 0.001f);
|
|
velocity /= Time.DeltaTime;
|
|
SlideMove(ref position, false, ref velocity);
|
|
velocity = oldVelocity;*/
|
|
//position += direction * (distance + 0.001f);
|
|
//velocity = Vector3.Zero;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
//Console.Print("overlap safepos");
|
|
position = safePosition;
|
|
velocity = Vector3.Zero;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*const float overlapResolveSpeed = 1.0f;
|
|
|
|
foreach (var overlap in overlaps)
|
|
{
|
|
var overlapRigidbody = overlap.Parent.GetType() == typeof(RigidBody) ? overlap.Parent.As<RigidBody>() : null;
|
|
if (overlapRigidbody != null)
|
|
{
|
|
Vector3 normal = (rigidBody.Position - overlapRigidbody.Position).Normalized;
|
|
position += normal * overlapResolveSpeed;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
position = safePosition;
|
|
velocity = Vector3.Zero;
|
|
break;
|
|
}
|
|
}*/
|
|
}
|
|
#endif
|
|
bool beingPushed = false;
|
|
if (touchingActors.Count > 0)
|
|
beingPushed = true;
|
|
|
|
|
|
|
|
/*bool beingPushed = false;
|
|
Collider[] overlaps = TracePlayer(rigidBody.Position);
|
|
if (overlaps.Length > 0)
|
|
{
|
|
//beingPushed = true;
|
|
|
|
Collider playerCollider = null;
|
|
var capsuleCollider = Actor.GetChild<CapsuleCollider>();
|
|
var boxCollider = Actor.GetChild<BoxCollider>();
|
|
var meshCollider = Actor.GetChild<MeshCollider>();
|
|
if (capsuleCollider && capsuleCollider.IsActive)
|
|
{
|
|
playerCollider = capsuleCollider;
|
|
}
|
|
else if (meshCollider && meshCollider.IsActive)
|
|
{
|
|
playerCollider = meshCollider;
|
|
|
|
}
|
|
else if (boxCollider && boxCollider.IsActive)
|
|
{
|
|
playerCollider = boxCollider;
|
|
}
|
|
|
|
|
|
foreach (var overlap in overlaps)
|
|
{
|
|
if (Collider.ComputePenetration(playerCollider, overlap, out Vector3 direction, out float distance))
|
|
{
|
|
beingPushed = true;
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
}
|
|
}*/
|
|
|
|
// categorize position
|
|
onGround = true;
|
|
Vector3 groundDelta = Physics.Gravity.Normalized * (collisionMargin*2);
|
|
TraceInfo traceGround = TracePlayer(position, position + groundDelta);
|
|
|
|
if (!traceGround.startSolid && traceGround.fraction < 1f &&
|
|
-Vector3.Dot(Physics.Gravity.Normalized, traceGround.hitNormal) < 0.7f)
|
|
{
|
|
// slope
|
|
// clip velocity
|
|
Vector3 bounce = groundDelta;
|
|
//Vector3 velocityProjected = Vector3.ProjectOnPlane(velocity, normal);
|
|
float backoff = Vector3.Dot(bounce, traceGround.hitNormal) * 2f;
|
|
bounce -= traceGround.hitNormal * backoff;
|
|
//velocity = velocityProjected;
|
|
|
|
Vector3 point = (position + groundDelta) +
|
|
(1f - traceGround.fraction) * bounce;
|
|
|
|
// retrace
|
|
traceGround = TracePlayer(position, position + point);
|
|
}
|
|
|
|
if (!traceGround.startSolid && (traceGround.fraction >= 1f ||
|
|
-Vector3.Dot(Physics.Gravity.Normalized, traceGround.hitNormal) < 0.7f))
|
|
{
|
|
// falling or sliding down a slope
|
|
onGround = false;
|
|
}
|
|
else
|
|
{
|
|
onGround = !traceGround.startSolid;
|
|
}
|
|
|
|
//onGround |= overlaps.Length > 0;
|
|
|
|
if (onGround && physicsInteractions && traceGround.hitInfos.Length > 0)
|
|
{
|
|
// apply resting force to rigid bodies under the player
|
|
//bool collided = false;
|
|
foreach (var hit in traceGround.hitInfos)
|
|
{
|
|
if (hit.Collider.AttachedRigidBody == null || hit.Collider.AttachedRigidBody.IsKinematic)
|
|
continue;
|
|
|
|
if (hit.Distance <= 0f)
|
|
continue;
|
|
|
|
//Console.Print(Physics.Gravity.Length.ToString());
|
|
Vector3 force = -hit.Normal * (Physics.Gravity.Length) * rigidBody.Mass * Time.DeltaTime;
|
|
hit.Collider.AttachedRigidBody.AddForceAtPosition(force, hit.Point, ForceMode.Impulse);
|
|
//collided = true;
|
|
//Console.Print("downforce: " + force.Length / Time.DeltaTime);
|
|
}
|
|
|
|
//if (collided)
|
|
// fraction = 1.0f; // finish movement and stop
|
|
}
|
|
|
|
/*if (!onGround)
|
|
Console.Print("air");
|
|
else
|
|
Console.Print("ground");*/
|
|
|
|
|
|
/*if (onGround)
|
|
{
|
|
// snap to ground
|
|
if (!traceGround.startSolid)
|
|
{
|
|
Vector3 newPos = rigidBody.Position;
|
|
|
|
if (traceGround.fraction < 1f)
|
|
{
|
|
//newPos += -Physics.Gravity.Normalized * traceGround.fraction;
|
|
}
|
|
rigidBody.Position = newPos;
|
|
}
|
|
}*/
|
|
/*if (traceGround.startSolid)
|
|
{
|
|
Console.Print("stuk: ");
|
|
|
|
rigidBody.Position = safePosition;
|
|
|
|
traceGround = TracePlayer(rigidBody.Position, rigidBody.Position + Physics.Gravity.Normalized,
|
|
false);
|
|
|
|
//onGround = true;
|
|
|
|
//currentVelocity.Y = 0f;
|
|
}
|
|
|
|
if (!traceGround.startSolid)
|
|
{
|
|
foreach (var hitInfo in traceGround.hitInfos)
|
|
{
|
|
var dot = Vector3.Dot(Physics.Gravity.Normalized, hitInfo.Normal);
|
|
if (-dot >= 0.7) //~45deg slope
|
|
{
|
|
//Console.Print("d: " + hitInfo.Distance);
|
|
Vector3 newPos = rigidBody.Position;
|
|
|
|
if (hitInfo.Distance > 0f)
|
|
newPos += Physics.Gravity.Normalized * (hitInfo.Distance - 0.01f);
|
|
else
|
|
newPos += hitInfo.Normal * 0.1f;
|
|
|
|
rigidBody.Position = newPos;
|
|
|
|
onGround = true;
|
|
currentVelocity.Y = 0f;
|
|
break;
|
|
|
|
//if (currentVelocity.Length > 0.01f)
|
|
// Console.Print("groundvel: " + currentVelocity.ToString());
|
|
//currentVelocity.Y = 0.0f;
|
|
}
|
|
}
|
|
}*/
|
|
|
|
// jump
|
|
if (onGround)
|
|
{
|
|
if (!jumped && InputManager.GetAction("Jump"))
|
|
{
|
|
//jumped = true;
|
|
|
|
velocity += Vector3.Up * jumpVelocity;
|
|
onGround = false;
|
|
}
|
|
else if (jumped) // jump released
|
|
jumped = false;
|
|
}
|
|
|
|
|
|
// ground friction
|
|
if (onGround)
|
|
{
|
|
float currentSpeed = velocity.Length;
|
|
|
|
float control = currentSpeed < stopspeed ? stopspeed : currentSpeed;
|
|
var drop = control * friction * Time.DeltaTime;
|
|
|
|
float newspeed = currentSpeed - drop;
|
|
if (newspeed < 0)
|
|
newspeed = 0;
|
|
|
|
if (currentSpeed < 0.0001f)
|
|
velocity *= 0;
|
|
else
|
|
velocity *= newspeed / currentSpeed;
|
|
}
|
|
|
|
//bool stepUp = false;
|
|
|
|
if (onGround) // ground acceleration
|
|
{
|
|
ApplyAcceleration(ref velocity, wishVelocity.Normalized, wishVelocity.Length, float.MaxValue, accelerationGround);
|
|
}
|
|
else // air acceleration
|
|
{
|
|
var wishspeed = wishVelocity.Length;
|
|
if (wishspeed > maxAirSpeed)
|
|
wishspeed = maxAirSpeed;
|
|
|
|
if (strafeAcceleration != 0f)
|
|
ApplyAcceleration(ref velocity, wishVelocity.Normalized, wishspeed, maxAirStrafeSpeed, strafeAcceleration);
|
|
|
|
//stepUp = true;
|
|
}
|
|
|
|
if (!onGround)
|
|
{
|
|
velocity += Physics.Gravity * Time.DeltaTime;
|
|
//Console.Print("grav");
|
|
}
|
|
//else
|
|
// Console.Print("Yv: " + currentVelocity.Y);
|
|
|
|
|
|
|
|
|
|
safePosition = rigidBody.Position;
|
|
currentVelocity = velocity;
|
|
if (!rigidBody.IsKinematic)
|
|
{
|
|
//rigidBody.IsKinematic = false;
|
|
//rigidBody.Position = position;
|
|
rigidBody.LinearVelocity = velocity;
|
|
//Console.Print("being pushed " + rigidBody.LinearVelocity.Length);
|
|
//rigidBody.AddForce(velocity + ((position - rigidBody.Position) * Time.DeltaTime), ForceMode.Impulse);
|
|
}
|
|
else
|
|
{
|
|
SlideMove(ref position, false, ref velocity);
|
|
|
|
//rigidBody.IsKinematic = true;
|
|
rigidBody.Position = position;
|
|
rigidBody.LinearVelocity = velocity;
|
|
}
|
|
|
|
/*if (proxyBody != null)
|
|
{
|
|
if (beingPushed)
|
|
{
|
|
//rigidBody.Position = proxyBody.Position;
|
|
rigidBody.LinearVelocity = proxyBody.LinearVelocity;
|
|
//rigidBody.Position += rigidBody.LinearVelocity * Time.DeltaTime;
|
|
}
|
|
else
|
|
{
|
|
var proxyVelocity = position - proxyBody.Position;
|
|
//proxyBody.LinearVelocity += proxyVelocity;
|
|
//rigidBody.Position = proxyBody.Position;
|
|
proxyBody.Position = position;
|
|
proxyBody.LinearVelocity = velocity;
|
|
}
|
|
}*/
|
|
|
|
//rigidBody.LinearVelocity = velocity;
|
|
|
|
//if (currentVelocity.Length > 0.01f)
|
|
// Console.Print("vel: " + currentVelocity.ToString());
|
|
}
|
|
|
|
void ApplyAcceleration(ref Vector3 velocity, Vector3 wishDir, float wishspeed, float maxWishspeed, float acceleration)
|
|
{
|
|
float wishspeedOrig = wishspeed;
|
|
if (wishspeed > maxWishspeed)
|
|
wishspeed = maxWishspeed;
|
|
|
|
float currentSpeed = Vector3.Dot(velocity, wishDir);
|
|
float addSpeed = wishspeed - currentSpeed;
|
|
if (addSpeed <= 0f)
|
|
return;
|
|
|
|
float accelSpeed = acceleration * wishspeedOrig * Time.DeltaTime;
|
|
if (accelSpeed > addSpeed)
|
|
accelSpeed = addSpeed;
|
|
|
|
velocity += accelSpeed * wishDir;
|
|
}
|
|
|
|
public override void OnUpdate()
|
|
{
|
|
float xAxis = InputManager.GetAxisRaw("Mouse X");
|
|
float yAxis = InputManager.GetAxisRaw("Mouse Y");
|
|
if (xAxis != 0.0f || yAxis != 0.0f)
|
|
{
|
|
var camera = rootActor.GetChild<Camera>();
|
|
|
|
viewPitch += yAxis;
|
|
viewYaw += xAxis;
|
|
|
|
viewPitch = Mathf.Clamp(viewPitch, -90.0f, 90.0f);
|
|
|
|
// root orientation must be set first
|
|
rootActor.Orientation = Quaternion.Euler(0, viewYaw, 0);
|
|
camera.Orientation = Quaternion.Euler(viewPitch, viewYaw, viewRoll);
|
|
}
|
|
}
|
|
}
|
|
}
|