public void Simulate(CookingPlayer pawn)
{
switch (CarriedProp.IsValid)
{
case true when pawn.Input.Pressed(InputButton.Use) || pawn.LifeState == LifeState.Dead:
Drop();
return;
case true when pawn.Input.Pressed(InputButton.Attack1):
DoThrow(pawn);
return;
}
if (LastPickup.Relative >= 1 && !CarriedProp.IsValid && pawn.Input.Pressed(InputButton.Use))
{
var traceResult = Trace.Ray(pawn.EyePos, pawn.EyePos + pawn.EyeRot.Forward * 85)
.Radius(4)
.Ignore(pawn)
.Run();
DebugOverlay.Text(traceResult.EndPos, $"Hit: {traceResult.Hit}, Entity: {(traceResult.Hit ? traceResult.Entity : "N/A")}", 5f);
if (traceResult.Hit && traceResult.Entity is IPickupable entity && CanPickup(entity))
{
DebugOverlay.Text(traceResult.EndPos - Vector3.Down * 5, "Picking up!", 5f);
DoPickup(entity, pawn);
}
}
//Log.Info( $"Testing: {CarriedProp.IsSet}" );
PhysicsManipulate(pawn);
}
public override void OnPlayerControlTick(Player owner)
{
base.OnPlayerControlTick(owner);
//DebugTrace( owner );
return;
if (!NavMesh.IsLoaded)
{
return;
}
timeSinceLast = 0;
var forward = owner.EyeRot.Forward * 2000;
var tr = Trace.Ray(owner.EyePos, owner.EyePos + forward)
.Ignore(owner)
.Run();
var closestPoint = NavMesh.GetClosestPoint(tr.EndPos);
DebugOverlay.Line(tr.EndPos, closestPoint, 0.1f);
DebugOverlay.Axis(closestPoint, Rotation.LookAt(tr.Normal), 2.0f, Time.Delta * 2);
DebugOverlay.Text(closestPoint, $"CLOSEST Walkable POINT", Time.Delta * 2);
NavMesh.BuildPath(Owner.WorldPos, closestPoint);
}
protected void ReflectBall(CollisionEventData eventData, float multiplier)
{
var reflect = Vector3.Reflect(eventData.PreVelocity.Normal, eventData.Normal.Normal).Normal;
var normalDot = eventData.PreVelocity.Normal.Dot(eventData.Normal);
// Don't do any reflection if we hit it at such an angle
if (normalDot <= 0.10)
{
return;
}
// Collision sound happens at this point, not entity
var sound = Sound.FromWorld(BounceSound.Name, eventData.Pos);
sound.SetVolume(0.2f + Math.Clamp(eventData.Speed / 1250.0f, 0.0f, 0.8f));
sound.SetPitch(0.5f + Math.Clamp(eventData.Speed / 1250.0f, 0.0f, 0.5f));
var particle = Particles.Create("particles/ball_hit.vpcf", eventData.Pos);
particle.SetPos(0, eventData.Pos);
particle.Destroy(false);
var newSpeed = Math.Max(eventData.PreVelocity.Length, eventData.Speed);
newSpeed *= multiplier;
// Adjust the speed depending on the hit normal, slight hit = more speed
newSpeed *= (1 - normalDot / 2);
var newVelocity = reflect * newSpeed;
// TODO: not a fan of this, should determine by the dot normal
newVelocity.z = 0;
PhysicsBody.Velocity = newVelocity;
PhysicsBody.AngularVelocity = Vector3.Zero;
if (Debug)
{
DebugOverlay.Text(eventData.Pos, $"V {eventData.PreVelocity.Length} -> {newSpeed}", 5f);
DebugOverlay.Text(eventData.Pos + Vector3.Up * 8, $"N. {normalDot}", 5f);
DebugOverlay.Line(eventData.Pos, eventData.Pos - (eventData.PreVelocity.Normal * 64.0f), 5f);
DebugOverlay.Line(eventData.Pos, eventData.Pos + (reflect * 64.0f), 5f);
}
}
public void OnFrame()
{
var pos = WorldPos;
var right = WorldRot.Right * 4;
var forward = WorldRot.Forward * 4;
var up = WorldRot.Up * 50;
var offset = Time.Now * 2.0f;
var offsetz = Time.Now * 0.1f;
var mode = (int)((Time.Now * 0.3f) % 5);
switch (mode)
{
case 0:
{
DebugOverlay.Text(pos, "Perlin");
break;
}
case 1:
{
DebugOverlay.Text(pos, "SparseConvolution");
break;
}
case 2:
{
DebugOverlay.Text(pos, "SparseConvolutionNormalized");
break;
}
case 3:
{
DebugOverlay.Text(pos, "Turbulence");
break;
}
case 4:
{
DebugOverlay.Text(pos, "Fractal");
break;
}
}
var size = 100;
pos -= right * size * 0.5f;
pos -= forward * size * 0.5f;
for (float x = 0; x < size; x++)
{
for (float y = 0; y < size; y++)
{
float val = 0;
switch (mode)
{
case 0:
{
val = Noise.Perlin(x * 0.1f + offset, y * 0.1f, offsetz) * 0.5f;
break;
}
case 1:
{
val = Noise.SparseConvolution(x * 0.1f + offset, y * 0.1f, offsetz) * 0.5f;
break;
}
case 2:
{
val = Noise.SparseConvolutionNormalized(x * 0.1f + offset, y * 0.1f, offsetz) * 0.5f;
break;
}
case 3:
{
val = Noise.Turbulence(2, x * 0.1f + offset, y * 0.1f, offsetz) * 0.5f;
break;
}
case 4:
{
val = Noise.Fractal(2, x * 0.1f + offset, y * 0.1f, offsetz) * 0.5f;
break;
}
}
var start = pos + x * right + y * forward;
DebugOverlay.Line(start, start + up * val, Color.Lerp(Color.Red, Color.Green, (val + 1.0f) / 2.0f));
}
}
}
private void StepMove()
{
var vecPos = Position;
var vecVel = Velocity;
//
// First try walking straight to where they want to go.
//
TryPlayerMove();
//
// mv now contains where they ended up if they tried to walk straight there.
// Save those results for use later.
//
var vecDownPos = Position;
var vecDownVel = Velocity;
//
// Reset original values to try some other things.
//
Position = vecPos;
Velocity = vecVel;
// Only step up as high as we have headroom to do so.
var trace = TraceBBox(Position, Position + Vector3.Up * (StepSize + DistEpsilon));
if (!trace.StartedSolid)
{
Position = trace.EndPos;
}
TryPlayerMove();
trace = TraceBBox(Position, Position + Vector3.Down * (StepSize + DistEpsilon * 2));
if (trace.Normal.z < GroundNormalZ)
{
if (Debug)
{
DebugOverlay.Text(vecDownPos, "step down", 2.0f);
}
Position = vecDownPos;
Velocity = vecDownVel.WithZ(0);
// out step height
return;
}
if (!trace.StartedSolid)
{
Position = trace.EndPos;
}
var vecUpPos = Position;
float flDownDist = (vecDownPos.x - vecPos.x) * (vecDownPos.x - vecPos.x) + (vecDownPos.y - vecPos.y) * (vecDownPos.y - vecPos.y);
float flUpDist = (vecUpPos.x - vecPos.x) * (vecUpPos.x - vecPos.x) + (vecUpPos.y - vecPos.y) * (vecUpPos.y - vecPos.y);
if (flDownDist > flUpDist)
{
Position = vecDownPos;
Velocity = vecDownVel;
}
else
{
// copy z value from slide move
Velocity = Velocity.WithZ(vecDownVel.z);
}
// out step height
}
