+ init

1 files changed, 327 insertions, 0 deletions

diff --git a/GameCode/SuperBasicController.cs b/GameCode/SuperBasicController.cs
new file mode 100644
index 0000000..6456afc
--- /dev/null
+++ b/GameCode/SuperBasicController.cs
@@ -0,0 +1,327 @@
+using Photon.Pun;
+using Photon.Pun.Simple;
+using UnityEngine;
+
+public class SuperBasicController : NetComponent
+{
+	public bool is2D;
+
+	[Range(0f, 300f)]
+	public float turnSpeed = 150f;
+
+	[Range(0f, 4f)]
+	public float moveSpeed = 4f;
+
+	public bool autoMove = true;
+
+	private Vector3 targRotDelta;
+
+	private Vector3 targPosDelta;
+
+	private float appliedDeltaT;
+
+	private Animator animator;
+
+	private SyncAnimator syncAnimator;
+
+	private SyncTransform syncTransform;
+
+	private SyncCannon syncLauncher;
+
+	private SyncContactScan syncHitscan;
+
+	private bool triggerJump;
+
+	private bool triggerFade;
+
+	private bool triggerTurnLeft;
+
+	private bool triggerUpperBodyRun;
+
+	private bool triggerUpperBodyIdle;
+
+	private bool triggerTeleport;
+
+	private bool freakingOut;
+
+	private bool triggerHitscan;
+
+	private bool triggerProjectile;
+
+	private bool triggerBlend;
+
+	public override void OnAwake()
+	{
+		base.OnAwake();
+		animator = base.transform.GetNestedComponentInChildren<Animator, NetObject>(includeInactive: true);
+		syncAnimator = base.transform.GetNestedComponentInChildren<SyncAnimator, NetObject>(includeInactive: true);
+		syncTransform = GetComponent<SyncTransform>();
+		syncLauncher = base.transform.GetNestedComponentInChildren<SyncCannon, NetObject>(includeInactive: true);
+		syncHitscan = base.transform.GetNestedComponentInChildren<SyncContactScan, NetObject>(includeInactive: true);
+	}
+
+	private void Update()
+	{
+		if (!base.IsMine)
+		{
+			return;
+		}
+		float t = (Time.time - Time.fixedTime) / Time.fixedDeltaTime;
+		Interpolate(t);
+		if (Input.GetKeyDown(KeyCode.Space))
+		{
+			triggerJump = true;
+		}
+		if (Input.GetKeyDown(KeyCode.Alpha2))
+		{
+			triggerFade = true;
+		}
+		if (Input.GetKeyDown(KeyCode.Alpha1))
+		{
+			triggerTurnLeft = true;
+		}
+		if (Input.GetKeyDown(KeyCode.Alpha4))
+		{
+			if (freakingOut)
+			{
+				triggerUpperBodyIdle = true;
+			}
+			else
+			{
+				triggerUpperBodyRun = true;
+			}
+			freakingOut = !freakingOut;
+		}
+		if (Input.GetKeyDown(KeyCode.F))
+		{
+			triggerProjectile = true;
+		}
+		if (Input.GetKeyDown(KeyCode.R))
+		{
+			triggerHitscan = true;
+		}
+		if (Input.GetKeyDown(KeyCode.T))
+		{
+			triggerTeleport = true;
+		}
+		if (Input.GetKeyDown(KeyCode.B))
+		{
+			triggerBlend = true;
+		}
+	}
+
+	private void FixedUpdate()
+	{
+		if (!base.IsMine)
+		{
+			return;
+		}
+		Vector3 move = new Vector3(0f, 0f, 0f);
+		Vector3 turn = new Vector3(0f, 0f, 0f);
+		if ((bool)animator && animator.isActiveAndEnabled)
+		{
+			if (Input.GetKey(KeyCode.W))
+			{
+				animator.SetBool("walking", value: true);
+				animator.SetFloat("speed", 1f);
+			}
+			else if (Input.GetKey(KeyCode.S))
+			{
+				animator.SetBool("walking", value: true);
+				animator.SetFloat("speed", -0.5f);
+			}
+			else
+			{
+				animator.SetBool("walking", value: false);
+				animator.SetFloat("speed", 0f);
+			}
+			if (triggerJump)
+			{
+				if ((bool)syncAnimator)
+				{
+					syncAnimator.SetTrigger("jump");
+				}
+				triggerJump = false;
+			}
+			else if (triggerTurnLeft)
+			{
+				if ((bool)syncAnimator)
+				{
+					syncAnimator.SetTrigger("turnLeft");
+				}
+				triggerTurnLeft = false;
+			}
+			if (triggerFade)
+			{
+				if ((bool)syncAnimator)
+				{
+					syncAnimator.CrossFadeInFixedTime("Jump", 0.25f);
+				}
+				triggerFade = false;
+			}
+			if (triggerBlend)
+			{
+				animator.SetFloat("blender", Mathf.Abs(Mathf.Sin(Time.time)));
+			}
+			else
+			{
+				animator.SetFloat("blender", -1f);
+			}
+			if (triggerUpperBodyRun)
+			{
+				if ((bool)syncAnimator)
+				{
+					syncAnimator.SetTrigger("upperBodyRun");
+				}
+				triggerUpperBodyRun = false;
+			}
+			else if (triggerUpperBodyIdle)
+			{
+				if ((bool)syncAnimator)
+				{
+					syncAnimator.SetTrigger("upperBodyIdle");
+				}
+				triggerUpperBodyIdle = false;
+			}
+		}
+		if (!animator || !animator.applyRootMotion)
+		{
+			if (Input.GetKey(KeyCode.W))
+			{
+				move += Vector3.forward;
+			}
+			else if (Input.GetKey(KeyCode.S))
+			{
+				move -= Vector3.forward;
+			}
+		}
+		if (Input.GetKey(KeyCode.A))
+		{
+			move -= Vector3.right;
+		}
+		if (Input.GetKey(KeyCode.D))
+		{
+			move += Vector3.right;
+		}
+		if (Input.GetKey(KeyCode.E))
+		{
+			turn += Vector3.up;
+		}
+		if (Input.GetKey(KeyCode.Q))
+		{
+			turn -= Vector3.up;
+		}
+		if (Input.touchCount > 0)
+		{
+			Touch touch = Input.GetTouch(0);
+			Vector2 vector = new Vector2(touch.rawPosition.x / (float)Screen.width, touch.rawPosition.y / (float)Screen.height);
+			if (vector.y > 0.66f)
+			{
+				if (vector.x > 0.66f)
+				{
+					triggerHitscan = true;
+				}
+				else if (vector.x < 0.33f)
+				{
+					triggerJump = true;
+				}
+			}
+			else if (vector.y < 0.33f)
+			{
+				if (vector.x > 0.66f)
+				{
+					move += Vector3.right;
+				}
+				else if (vector.x < 0.33f)
+				{
+					move -= Vector3.right;
+				}
+				else if ((bool)animator)
+				{
+					animator.SetBool("walking", value: true);
+					animator.SetFloat("speed", -0.5f);
+				}
+			}
+			else if (vector.x > 0.66f)
+			{
+				turn += Vector3.up;
+			}
+			else if (vector.x < 0.33f)
+			{
+				turn -= Vector3.up;
+			}
+			else if ((bool)animator)
+			{
+				animator.SetBool("walking", value: true);
+				animator.SetFloat("speed", 1f);
+			}
+		}
+		if (autoMove && !Application.isFocused)
+		{
+			turn += new Vector3(0f, Mathf.Sin(Time.time * 0.5f), 0f);
+			if ((bool)animator)
+			{
+				animator.SetBool("walking", value: true);
+				animator.SetFloat("speed", Mathf.Sin(Time.time) * 0.5f);
+			}
+		}
+		Interpolate(1f);
+		Move(move, turn);
+		appliedDeltaT = 0f;
+		if (triggerHitscan)
+		{
+			if ((bool)syncHitscan)
+			{
+				syncHitscan.QueueTrigger();
+			}
+			triggerHitscan = false;
+		}
+		if (triggerProjectile)
+		{
+			if ((bool)syncLauncher)
+			{
+				syncLauncher.QueueTrigger();
+			}
+			triggerProjectile = false;
+		}
+		if (triggerTeleport)
+		{
+			if ((bool)syncTransform)
+			{
+				syncTransform.FlagTeleport();
+				base.transform.localPosition = default(Vector3);
+				base.transform.localRotation = default(Quaternion);
+			}
+			triggerTeleport = false;
+		}
+	}
+
+	private void OnAnimatorMove()
+	{
+		if (base.IsMine)
+		{
+			animator.ApplyBuiltinRootMotion();
+			base.transform.rotation = animator.rootRotation;
+			base.transform.position = animator.rootPosition;
+		}
+	}
+
+	private void Move(Vector3 move, Vector3 turn)
+	{
+		if (is2D)
+		{
+			move = new Vector3(move.x, move.z, 0f);
+			turn = new Vector3(0f, 0f, turn.y);
+		}
+		targRotDelta = turn * turnSpeed * Time.fixedDeltaTime;
+		targPosDelta = move * moveSpeed * Time.fixedDeltaTime;
+	}
+
+	private void Interpolate(float t)
+	{
+		t -= appliedDeltaT;
+		appliedDeltaT += t;
+		base.transform.rotation = base.transform.rotation * Quaternion.Euler(targRotDelta * t);
+		base.transform.position += base.transform.rotation * (targPosDelta * t);
+	}
+}