quakeball/Assets/Scripts/Players/Player.cs

339 lines
15 KiB
C#
Raw Normal View History

2020-08-02 02:52:38 +02:00
using UnityEngine;
using NeonTea.Quakeball.Networking.Packets;
using NeonTea.Quakeball.Util;
2020-08-08 06:00:17 +02:00
using NeonTea.Quakeball.Networking;
using NeonTea.Quakeball.Networking.Instances;
2020-08-08 07:23:23 +02:00
using NeonTea.Quakeball.Combat;
2020-08-08 14:37:55 +02:00
using NeonTea.Quakeball.Interface;
2020-08-10 17:41:07 +02:00
using NeonTea.Quakeball.Animation;
2020-08-02 02:52:38 +02:00
2020-08-07 20:23:21 +02:00
namespace NeonTea.Quakeball.Players {
2020-08-02 02:52:38 +02:00
/// <summary>The central glue class for players (both local and remote).</summary>
/// <remarks>Other classes will handle netcode/inputs, and then speak to this class in order to make the little people run around.</remarks>
[RequireComponent(typeof(CharacterController))]
public class Player : MonoBehaviour {
/// <summary>The duration after running off a cliff, during which the player should still be considered grounded.</summary>
2020-08-02 02:52:38 +02:00
public float CoyoteTime;
2020-08-08 03:44:45 +02:00
public float PingBias;
2020-08-02 02:52:38 +02:00
2020-08-06 19:58:10 +02:00
public MoveStyle[] MoveStyles;
2020-08-05 23:15:28 +02:00
public Transform Gun;
2020-08-06 19:58:10 +02:00
public Animator GunBobber;
2020-08-02 02:52:38 +02:00
2020-08-10 17:41:07 +02:00
public SoldierProceduralAnimator SoldierProceduralAnimator;
2020-08-08 15:40:26 +02:00
[Tooltip("GameObjects that are disabled on death and re-enabled on respawn.")]
public GameObject[] DisabledOnDeath;
2020-08-08 05:20:23 +02:00
[Header("Shooting")]
[Tooltip("For raycasting the shoot target.")]
public Transform CameraRoot;
public Transform BulletSourcePoint;
public LayerMask BulletHitLayer;
2020-08-08 08:09:34 +02:00
public float Cooldown;
2020-08-08 05:20:23 +02:00
[Header("Visuals")]
public DesyncLerper[] Lerpables;
public float Lean;
2020-08-08 07:23:23 +02:00
public GameObject LaserPrefab;
public ParticleSystem Splatter;
2020-08-08 07:59:44 +02:00
[Header("Audio")]
2020-08-08 08:50:55 +02:00
public AudioSource GunShotAudioSource;
public AudioClip RaygunClip;
public AudioSource HitAudioSource;
public AudioSource LocalHitAudioSource;
2020-08-08 07:59:44 +02:00
[Header("Player rotation status")]
/// <summary>The pitch of the player's head.</summary>
public float Pitch;
/// <summary>The total yaw of the player. Head yaw is Yaw - BodyYaw.</summary>
public float Yaw;
2020-08-02 02:52:38 +02:00
[Header("Player movement status")]
/// <summary>The direction the player is going.</summary>
public Vector3 MoveDirection;
/// <summary>The amount of movement the player wants to happen.</summary>
/// <remarks>Without analog controls, always 0 or 1.</remarks>
public float InputSpeed;
/// <summary>The way the player is moving.</summary>
2020-08-06 19:58:10 +02:00
public byte CurrentMoveStyle = 0;
public MoveStyle MoveStyle => MoveStyles[CurrentMoveStyle];
2020-08-02 02:52:38 +02:00
[Header("Runtime computed values")]
/// <summary>The speed at which the player is currently moving across the ground.</summary>
public Vector3 GroundVelocity;
/// <summary>The speed at which the player is rising or falling.</summary>
public Vector3 GravitationalVelocity;
/// <summary>The timestamp of when the player was last on the ground.</summary>
public float GroundedTime;
2020-08-08 06:00:17 +02:00
/// <summary> The possible networked Id of this Player instance </summary>
public ulong NetId;
2020-08-08 14:37:55 +02:00
/// <summary> Is the player dead</summary>
public bool IsDead;
public float LatestGroundedY;
2020-08-02 02:52:38 +02:00
[Header("Misc. technical knobs")]
public float GroundCastLength = 0.2f;
public LayerMask GroundLayer;
[Header("Debug settings")]
public bool ShowGroundCast;
2020-08-05 23:15:28 +02:00
public bool ShowMoveVector;
2020-08-02 02:52:38 +02:00
private CharacterController CharacterController;
private Vector3 FeetPosition;
2020-08-08 08:09:34 +02:00
private float LastShot;
2020-08-08 14:37:55 +02:00
private float TimeofDeath;
2020-08-08 08:09:34 +02:00
/// <summary>Creates a PlayerUpdatePckt representing this Player's current status, for sending to other peers.</summary>
2020-08-07 23:59:51 +02:00
public PlayerUpdatePckt CreateUpdatePacket(ulong id = 0) {
2020-08-07 22:09:31 +02:00
return new PlayerUpdatePckt(MoveDirection, CurrentMoveStyle, Pitch, Yaw, id);
}
/// <summary>Updates this Player with the given packet.</summary>
public void ProcessUpdatePacket(PlayerUpdatePckt packet) {
2020-08-10 17:41:07 +02:00
if (!IsDead) {
Pitch = packet.Pitch;
Yaw = packet.Yaw;
MoveDirection = packet.MoveDirection;
CurrentMoveStyle = packet.MoveStyle;
}
}
/// <summary>Creates a PlayerSyncPacket representing this Player's position and velocity, for sending to the server.</summary>
2020-08-08 00:21:02 +02:00
public PlayerSyncPacket CreateSyncPacket(ulong id = 0, bool unsynced = false) {
return new PlayerSyncPacket(id, unsynced, transform.position, GroundVelocity);
2020-08-07 23:59:51 +02:00
}
/// <summary>Applies the sync packet, checking it for cheatiness if shouldApply is false.</summary>
2020-08-08 00:21:02 +02:00
public bool ProcessSyncPacket(PlayerSyncPacket syncPckt, bool shouldApplyWithoutInspection = true) {
bool ShouldApply = shouldApplyWithoutInspection;
if (!shouldApplyWithoutInspection) {
// TODO: Gaze into the crystal ball to determine the nefariousness level of the packet and update ShouldApply accordingly.
2020-08-08 00:26:28 +02:00
ShouldApply = true;
}
if (ShouldApply) {
Vector3 Delta = transform.position - syncPckt.Location;
if (Delta.magnitude < 1) {
// Player is close enough to the sync packet, lerp them over.
foreach (DesyncLerper Lerper in Lerpables) {
Lerper.Offset(Delta);
}
}
transform.position = syncPckt.Location;
2020-08-08 00:26:28 +02:00
GroundVelocity = syncPckt.GroundVelocity;
}
2020-08-08 00:21:02 +02:00
return ShouldApply;
2020-08-07 23:59:51 +02:00
}
public bool Jump() {
2020-08-08 03:44:45 +02:00
bool IsCoyoteTime = Time.time - GroundedTime <= CoyoteTime + PingBias;
if (IsCoyoteTime || IsGrounded()) {
GravitationalVelocity = Vector3.up * MoveStyle.JumpVelocity;
Vector3 Pos = transform.position;
Pos.y = LatestGroundedY;
transform.position = Pos;
return true;
} else {
return false;
}
}
2020-08-08 04:26:17 +02:00
public void Shoot() {
2020-08-08 08:09:34 +02:00
float delta = Time.time - LastShot;
if (Net.Singleton.Instance is Server) {
float ping = ((Server)Net.Singleton.Instance).Players[NetId].Ping;
delta += ping;
}
if (delta < Cooldown) {
return;
}
LastShot = Time.time;
2020-08-08 07:23:23 +02:00
Vector3 GunPoint = BulletSourcePoint.position;
Vector3 ShotDelta = CameraRoot.forward * 1000f;
2020-08-08 05:20:23 +02:00
Vector3 From = CameraRoot.position;
Vector3 Direction = CameraRoot.forward;
2020-08-08 07:38:10 +02:00
RaycastHit[] Hits = Physics.RaycastAll(From, Direction, 1000f, BulletHitLayer);
2020-08-08 15:11:29 +02:00
System.Array.Sort(Hits, (a, b) => { return a.distance.CompareTo(b.distance); });
2020-08-08 07:35:36 +02:00
foreach (RaycastHit Hit in Hits) {
2020-08-08 10:32:07 +02:00
ShotDelta = Hit.point - GunPoint;
2020-08-08 07:35:36 +02:00
Player Player = Hit.rigidbody != null ? Hit.rigidbody.GetComponent<Player>() : null;
if (Player == this) {
continue;
}
if (Player != null) {
if (Net.Singleton.Instance is Server) {
2020-08-08 09:08:10 +02:00
((Server)Net.Singleton.Instance).SendHit(NetId, Player.NetId);
Player.Hit(NetId);
2020-08-08 05:20:23 +02:00
}
}
2020-08-08 07:35:36 +02:00
break;
2020-08-08 05:20:23 +02:00
}
2020-08-08 07:23:23 +02:00
GameObject LaserEffect = Instantiate(LaserPrefab);
Laser Laser = LaserEffect.GetComponent<Laser>();
Laser.From = GunPoint;
Laser.To = GunPoint + ShotDelta;
2020-08-08 07:59:44 +02:00
2020-08-08 08:50:55 +02:00
GunShotAudioSource.PlayOneShot(RaygunClip);
2020-08-08 04:26:17 +02:00
}
2020-08-08 09:08:10 +02:00
public void Hit(ulong sourceUid) {
2020-08-10 17:41:07 +02:00
Terminal.Singleton.Println($"{NetId} hit sourceIid: {sourceUid}");
2020-08-08 08:50:37 +02:00
if (Net.Singleton.Instance is Server) {
2020-08-08 14:37:55 +02:00
((Server)Net.Singleton.Instance).HandlePlayerDeath(NetId, sourceUid);
2020-08-08 08:50:37 +02:00
}
2020-08-08 09:08:10 +02:00
bool IsLocal = true;
if (Net.Singleton.Instance != null) {
IsLocal = Net.Singleton.Instance.LocalPlayer.Id == sourceUid;
}
Splatter.Play();
2020-08-08 08:50:55 +02:00
HitAudioSource.Play();
2020-08-08 09:34:09 +02:00
if (IsLocal) {
Net.Singleton.Instance.LocalPlayer.Controlled.LocalHitAudioSource.Play();
}
2020-08-08 06:00:17 +02:00
}
2020-08-08 14:37:55 +02:00
/// <summary>Called when this Player is dead</summary>
public void Dead(ulong killer) {
2020-08-10 17:41:07 +02:00
Terminal.Singleton.Println($"{killer} killed me: {NetId}, deadness currently: {IsDead}");
2020-08-08 14:37:55 +02:00
if (IsDead) {
return;
}
if (Net.Singleton.Instance != null && Net.Singleton.Instance.LocalPlayer.Id == NetId) {
string name = $"Connection {killer}";
GameObject.FindGameObjectWithTag("DeadScreen").GetComponent<DeadScreen>().StartCountdown(name);
2020-08-08 15:22:46 +02:00
Net.Singleton.Instance.LocalPlayer.Controlled.GetComponent<LocalPlayer>().DisableInput += 1;
2020-08-08 14:37:55 +02:00
}
2020-08-10 17:41:07 +02:00
SoldierProceduralAnimator.StartRagdoll();
2020-08-08 14:37:55 +02:00
TimeofDeath = Time.time;
2020-08-08 15:22:46 +02:00
MoveDirection = Vector3.zero;
2020-08-08 15:40:26 +02:00
foreach (GameObject obj in DisabledOnDeath) {
obj.SetActive(false);
}
2020-08-08 14:37:55 +02:00
IsDead = true;
}
/// <summary>Called when this Player is respawned, after dying.</summary>
public void Respawn(Vector3 location) {
2020-08-10 17:41:07 +02:00
Terminal.Singleton.Println($"Respawned (I am {NetId}), deadness before proper resurrection: {IsDead}");
2020-08-10 02:19:21 +02:00
if (Net.Singleton.Instance != null && Net.Singleton.Instance.LocalPlayer.Id == NetId && IsDead) {
2020-08-08 14:37:55 +02:00
GameObject.FindGameObjectWithTag("DeadScreen").GetComponent<DeadScreen>().Open = false;
2020-08-08 15:22:46 +02:00
Net.Singleton.Instance.LocalPlayer.Controlled.GetComponent<LocalPlayer>().DisableInput -= 1;
2020-08-08 14:37:55 +02:00
}
transform.position = location;
2020-08-10 17:41:07 +02:00
SoldierProceduralAnimator.StopRagdoll();
2020-08-08 15:40:26 +02:00
foreach (GameObject obj in DisabledOnDeath) {
obj.SetActive(true);
}
2020-08-08 14:37:55 +02:00
IsDead = false;
}
2020-08-02 02:52:38 +02:00
public bool IsGrounded() {
return CharacterController.isGrounded && Vector3.Dot(GravitationalVelocity, Vector3.down) >= 0;
2020-08-02 02:52:38 +02:00
}
2020-08-10 01:27:48 +02:00
/// <summary>The normal of the ground below the player. If there is no ground, it's <c>Vector3.up</c> by default.</summary>
private Vector3 GroundCast() {
RaycastHit hit;
Vector3 feetPosition = FeetPosition + transform.position + CharacterController.center + Vector3.down * CharacterController.height / 2;
if (ShowGroundCast) {
Debug.DrawLine(feetPosition, feetPosition - Vector3.up, Color.red, 1f);
}
if (Physics.Raycast(feetPosition, -Vector3.up, out hit, GroundCastLength, GroundLayer)) {
return hit.normal;
} else {
return Vector3.up;
}
}
2020-08-02 02:52:38 +02:00
private void Awake() {
CharacterController = GetComponent<CharacterController>();
FeetPosition = transform.position + CharacterController.center - Vector3.up * (CharacterController.height / 2 + CharacterController.skinWidth / 2);
if (GameObject.FindObjectOfType<Util.PhysicsSyncer>() == null) {
Debug.LogWarning("Player.Awake: There is no PhysicsSyncer in this scene! Some code will not work as expected.");
}
2020-08-02 02:52:38 +02:00
}
private void Update() {
2020-08-08 14:37:55 +02:00
if (Net.Singleton.Instance is Server) {
if (IsDead && (Time.time - TimeofDeath > 3)) {
((Server)Net.Singleton.Instance).HandlePlayerRespawn(NetId);
}
}
float TargetLean = -Vector3.Dot(GroundVelocity / MoveStyle.TargetVelocity, CameraRoot.right) * MoveStyle.LeanDegrees;
Lean = Mathf.Lerp(Lean, TargetLean, 30f * Time.deltaTime);
CameraRoot.localEulerAngles = new Vector3(Pitch, Yaw, Lean);
2020-08-08 14:37:55 +02:00
}
2020-08-08 14:37:55 +02:00
private void LateUpdate() {
UpdateMovement();
2020-08-02 02:52:38 +02:00
}
private void UpdateMovement() {
2020-08-02 02:52:38 +02:00
bool Grounded = IsGrounded();
bool FallingDown = Vector3.Dot(Vector3.down, GravitationalVelocity) > 0;
if (Grounded && FallingDown) {
2020-08-10 01:27:48 +02:00
GravitationalVelocity = GroundCastLength * Vector3.down;
} else if (!Grounded) {
GravitationalVelocity += Physics.gravity * Time.deltaTime;
2020-08-02 02:52:38 +02:00
}
2020-08-10 18:42:06 +02:00
Vector3 GroundNormal = GroundCast();
2020-08-02 02:52:38 +02:00
float FrictionVelocityFactor = Mathf.Max(GroundVelocity.magnitude, MoveStyle.StopVelocity);
float Deccel = FrictionVelocityFactor * Time.deltaTime;
2020-08-10 18:42:06 +02:00
if (Grounded || GroundNormal != Vector3.up) {
2020-08-02 02:52:38 +02:00
Deccel *= MoveStyle.Friction;
} else {
Deccel *= MoveStyle.AirFriction;
}
float FrictionedVelocity = Mathf.Max(0, GroundVelocity.magnitude - Deccel);
GroundVelocity = GroundVelocity.normalized * FrictionedVelocity;
Vector3 FixedHeading = Vector3.ProjectOnPlane(MoveDirection, GroundNormal).normalized;
float CurrentSpeed = Vector3.Dot(GroundVelocity, FixedHeading);
float Acceleration = MoveStyle.TargetVelocity * Time.deltaTime;
2020-08-10 18:42:06 +02:00
if (Grounded || GroundNormal != Vector3.up) {
2020-08-02 02:52:38 +02:00
Acceleration *= MoveStyle.Acceleration;
} else {
Acceleration *= MoveStyle.AirAcceleration;
}
Acceleration = Mathf.Min(Acceleration, MoveStyle.TargetVelocity - CurrentSpeed);
GroundVelocity += FixedHeading * Acceleration;
2020-08-10 18:42:06 +02:00
CharacterController.Move((GravitationalVelocity + GroundVelocity) * Time.deltaTime);
2020-08-02 02:52:38 +02:00
if (CharacterController.isGrounded) {
GroundedTime = Time.time;
LatestGroundedY = transform.position.y;
}
if (GravitationalVelocity.y > 0.1 && Mathf.Abs(CharacterController.velocity.y) < 0.1) {
2020-08-10 01:27:48 +02:00
// Hit a roof while jumping, reset falling velocity downwards (same as "static gravity" when grounded)
GravitationalVelocity.y = GroundCastLength;
2020-08-02 02:52:38 +02:00
}
2020-08-10 18:42:06 +02:00
2020-08-05 23:15:28 +02:00
if (ShowMoveVector) {
2020-08-10 01:27:48 +02:00
Debug.DrawLine(transform.position + CharacterController.center, transform.position + CharacterController.center + GravitationalVelocity, Color.yellow, 1.0f);
Debug.DrawLine(transform.position + CharacterController.center, transform.position + CharacterController.center + GroundVelocity, Color.green, 1.0f);
2020-08-05 23:15:28 +02:00
}
2020-08-06 19:58:10 +02:00
float TargetBobbiness = Grounded ? GroundVelocity.magnitude / MoveStyle.TargetVelocity : 0;
GunBobber.SetLayerWeight(1, Mathf.Lerp(GunBobber.GetLayerWeight(1), TargetBobbiness, 10f * Time.deltaTime));
2020-08-02 02:52:38 +02:00
}
}
}