net.dreditor.core 0.1.4 → 0.1.6

package/Scripts/Cameras/CameraShake.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 993311bb0cf3ac74ba78e84e385f53e2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Scripts/Cameras/CameraShakeArea.cs

@@ -0,0 +1,77 @@
+//Author: Happy30
+using System.Collections;
+using System.Collections.Generic;
+using DREditor.EventObjects;
+using UnityEngine;
+
+namespace DREditor.Cameras
+{
+
+    public class CameraShakeArea : MonoBehaviour
+    {
+        private bool _active;
+        private bool _enabled;
+        public FloatWithEvent ShakeOmega;
+
+        private Transform _player;
+
+        public float MaxShake;
+        private float shake;
+
+        public BoolWithEvent CameraShakeMode;
+
+        // Start is called before the first frame update
+        void Start()
+        {
+            _enabled = true;
+            shake = MaxShake;
+        }
+
+        // Update is called once per frame
+        void Update()
+        {
+            if (!_active || !_enabled) return;
+
+            ShakeOmega.Value = MaxShake - (MaxShake - (shake / Vector3.Distance(_player.position, transform.position)));
+
+
+        }
+
+
+        void OnTriggerEnter(Collider col)
+        {
+            if (col.CompareTag("Player"))
+            {
+                CameraShakeMode.Value = true;
+                _player = col.transform;
+                _active = true;
+            }
+        }
+
+        void OnTriggerExit(Collider col)
+        {
+            if (col.CompareTag("Player"))
+            {
+                CameraShakeMode.Value = false;
+                ShakeOmega.Value = 0;
+                _active = false;
+            }
+        }
+
+        public void Disable()
+        {
+            CameraShakeMode.Value = false;
+            ShakeOmega.Value = 0;
+            _enabled = false;
+
+        }
+
+
+        void OnDrawGizmos()
+        {
+            // Draw a semitransparent blue cube at the transforms position
+            Gizmos.color = new Color(0, 1, 1, 1);
+            Gizmos.DrawWireSphere(transform.position, transform.localScale.x / 2);
+        }
+    }
+}

package/Scripts/Cameras/CameraShakeArea.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 2e9172c755115334284867b4847d6a29
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences:
+  - ShakeOmega: {fileID: 11400000, guid: 3a8f6033ae1d20f4da84ad77ca67b831, type: 2}
+  - CameraShakeMode: {fileID: 11400000, guid: 6ff2e26671b4a5647835a591f656eaca, type: 2}
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Scripts/Cameras/Crouch.cs

@@ -0,0 +1,63 @@
+//Author: Happy30
+//Edited by: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+namespace DREditor.Cameras
+{
+    
+    [RequireComponent(typeof(CharacterController))]
+    public class Crouch : MonoBehaviour
+    {
+        private CharacterController _characterController;
+        [SerializeField] bool disable = false;
+        private float targetHeight;
+
+        public float CrouchHeight;
+        float NormalHeight;
+        public float CrouchOmega;
+
+        public bool ToggleToCrouch;
+        [Tooltip("")]
+        [SerializeField] protected InputActionReference crouch;
+        void Awake()
+        {
+            _characterController = GetComponent<CharacterController>();
+            NormalHeight = _characterController.height;
+            targetHeight = NormalHeight;
+        }
+
+        private void Start()
+        {
+            if (disable)
+                return;
+#if ENABLE_INPUT_SYSTEM
+            crouch.action.started += cont => CrouchCall();
+            crouch.action.canceled += cont => UnCrouchCall();
+#endif
+        }
+        void CrouchCall()
+        {
+            if (ToggleToCrouch)
+            {
+                targetHeight = targetHeight == NormalHeight ? CrouchHeight : NormalHeight;
+                return;
+            }
+            targetHeight = CrouchHeight;
+        }
+        void UnCrouchCall()
+        {
+            if (ToggleToCrouch)
+                return;
+            targetHeight = NormalHeight;
+        }
+
+        void Update()
+        {
+            
+            _characterController.height = Mathf.Lerp(_characterController.height, targetHeight, CrouchOmega * Time.deltaTime);
+
+            //ETween.Step(_characterController.height, targetHeight, CrouchOmega);
+        }
+    }
+}

package/Scripts/Cameras/Crouch.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b5c4b16930dddb84ca0b761b6f67f8a1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Scripts/Cameras/DRTrialCamera.cs

@@ -0,0 +1,158 @@
+// Main Trial Camera Script for DREditor Author: SeleniumSoul
+//Edited by: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using UnityEngine;
+
+namespace DREditor.Cameras
+{
+    [AddComponentMenu("DREditor/Cameras/DR Trial Camera")]
+    public class DRTrialCamera : MonoBehaviour
+    {
+        public GameObject CameraPivot;
+        public Animator CameraAnimator;
+
+        [SerializeField] float DefaultRadius = 8.11f;
+
+        [SerializeField] protected float seatFocus;
+        public virtual float SeatFocus { get => seatFocus; set => seatFocus = value; }
+        
+        public float SeatRadius;
+
+        public bool RadiusLock = true;
+
+        [SerializeField] protected bool smoothFocus;
+
+        public bool SmoothFocus { get => smoothFocus; set => smoothFocus = value; }
+
+        public float SmoothTransitionTime = 10f;
+        public int HeadmasterPosition = 0;
+        public float HeamasterSeatHeightOffset = 12f;
+        public float HeadmasterSeatDistance = 12f;
+        public float[] CharHeightOffset = new float[16];
+        private float AnchorAngle;
+        private bool FocusOnHeadmaster = false;
+
+        private bool Replace = false;
+        private float HeightOverride;
+
+
+        void Start()
+        {
+            if (CameraPivot == null)
+            {
+                CameraPivot = gameObject.transform.GetChild(0).gameObject;
+            }
+            if (CameraAnimator == null)
+            {
+                CameraAnimator = CameraPivot.GetComponent<Animator>();
+            }
+
+            AnchorAngle = 360f / CharHeightOffset.Length;
+        }
+
+        void Update()
+        {
+            RadiusLock = CameraPivot.GetComponent<RadiusLock>().Locked;
+            if (FocusOnHeadmaster)
+            {
+                UpdatePositionAndRotation(new Vector3(0, HeamasterSeatHeightOffset, 0),
+                    Quaternion.AngleAxis(HeadmasterPosition * AnchorAngle, Vector3.up));
+            }
+            else if (Replace)
+            {
+                //UnityEngine.Debug.LogWarning("USING REPLACE");
+                UpdatePositionAndRotation(new Vector3(0, HeightOverride, 0), Quaternion.AngleAxis(SeatFocus * AnchorAngle, Vector3.up));
+            }
+            else
+            {
+                if (Mathf.RoundToInt(SeatFocus) >= CharHeightOffset.Length)
+                    SeatFocus = 0;
+                try
+                {
+                    UpdatePositionAndRotation(new Vector3(0, CharHeightOffset[Mathf.RoundToInt(SeatFocus)], 0), 
+                        Quaternion.AngleAxis(SeatFocus * AnchorAngle, Vector3.up));
+                }
+                catch
+                {
+                    UnityEngine.Debug.LogWarning("Camera Seat focus issue with: " + Mathf.RoundToInt(SeatFocus));
+                }
+            }
+        }
+        void LateUpdate()
+        {
+            if (RadiusLock)
+            {
+                if(FocusOnHeadmaster)
+                {
+                    CameraPivot.transform.localPosition = new Vector3(0, 0, HeadmasterSeatDistance);
+                } else
+                {
+                    CameraPivot.transform.localPosition = new Vector3(0, 0, SeatRadius);
+                }
+            } 
+        }
+
+        void UpdatePositionAndRotation(Vector3 targetPosition, Quaternion targetRotation)
+        {
+            if (SmoothFocus)
+                transform.SetPositionAndRotation(
+                    Vector3.Lerp(transform.position, targetPosition, SmoothTransitionTime * Time.deltaTime),
+                    Quaternion.Lerp(transform.rotation, targetRotation, SmoothTransitionTime * Time.deltaTime));
+            else
+                transform.SetPositionAndRotation(targetPosition, targetRotation);
+        }
+
+        public void SetHeadmasterFocus(bool value)
+        {
+            FocusOnHeadmaster = value;
+        }
+
+        public bool IsFocusedOnHeadmaster()
+        {
+            return FocusOnHeadmaster;
+        }
+
+        public void ChangeFocus(float charnum)
+        {
+            SeatFocus = charnum;
+        }
+
+        public void TriggerAnim(int id)
+        {
+            CameraAnimator.SetTrigger(id);
+        }
+
+        public void TriggerAnim(string tag)
+        {
+            CameraAnimator.SetTrigger(tag);
+        }
+        public void ResetTrigger(string tag) => CameraAnimator.ResetTrigger(tag);
+        public void TriggerAnim(float seat, string animname = "noCamAnim")
+        {
+            SeatFocus = seat;
+            CameraAnimator.SetTrigger(animname);
+        }
+
+        public void SetOverride(bool to)
+        {
+            Replace = to;
+        }
+        public void SetDefaultValues()
+        {
+            SetOverride(false);
+
+            SeatRadius = DefaultRadius;
+        }
+
+        public virtual void ApplyOverrides(float height, float distance, float seatFocus, bool dontPan)
+        {
+            HeightOverride = height;
+
+            SeatRadius = distance;
+
+            if (!dontPan)
+                SeatFocus = seatFocus;
+
+            SetOverride(true);
+        }
+    }
+}

package/Scripts/Cameras/DRTrialCamera.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bc2c1e5853a3c6249b10c271cc096253
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Scripts/Cameras/FollowPlayer.cs

@@ -0,0 +1,29 @@
+//Author: Happy30
+using UnityEngine;
+
+namespace DREditor.Cameras
+{
+
+    public class FollowPlayer : MonoBehaviour
+    {
+        public Transform Player;
+        public float YOffset;
+        public float FollowSpeedOmega;
+
+        public Vector3 GetPlayerPosition()
+        {
+            return Vector3.Lerp(transform.position, Player.position + Vector3.up * YOffset, FollowSpeedOmega * Time.deltaTime);
+
+            //ETween.Step(transform.position, Player.position + Vector3.up * YOffset, FollowSpeedOmega);
+        }
+        public Vector3 GetPlayerNoLerp()
+        {
+            return Player.position + Vector3.up * YOffset;
+        }
+        public Quaternion GetPlayerRotation()
+        {
+            return Player.rotation;
+        }
+
+    }
+}

package/Scripts/Cameras/FollowPlayer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cd49434e8000b6c4c81a0af8ea126a2c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Scripts/Cameras/Headbobbing.cs

@@ -0,0 +1,91 @@
+//Author: Happy30
+using System;
+using DREditor.EventObjects;
+using UnityEngine;
+
+namespace DREditor.Cameras
+{
+    //TO DO: apply deltatime to headbobbing so that it behaves correctly even on framerates that exceed 60 fps
+    public class Headbobbing : MonoBehaviour
+    {
+        private float timer;
+
+        [Range(5f, 20f)]
+        public float BobSpeed;
+
+        [Range(0f, 3f)]
+        public float BobAmount;
+
+        public Transform Camera;
+
+        public CharacterController Controller;
+        public BoolWithEvent InDialogue;
+
+        public SceneEvent PlayerStep;
+        public BoolWithEvent Running;
+
+
+        private float speed;
+        private float amount;
+
+        void FixedUpdate()
+        {
+
+            speed = Running.Value ? BobSpeed * 2 : BobSpeed;
+            amount = Running.Value ? BobAmount * 2 : BobAmount;
+
+        }
+
+        public float GetYBobAmount()
+        {
+            if (InDialogue.Value) return 0f;
+
+
+            var waveslice = 0.0f;
+
+
+            if (Math.Abs(Controller.velocity.magnitude) < 0.01f)
+            {
+                if (Math.Abs(timer) > 0.01f)
+                {
+                    PlayerStep.Raise();
+                }
+                timer = 0.0f;
+                //Standing still step sound
+            }
+            else
+            {
+                waveslice = Mathf.Sin(timer);
+                timer = timer + speed * Time.deltaTime;
+                if (timer > Mathf.PI * 2)
+                {
+                    timer = timer - (Mathf.PI * 2);
+                    PlayerStep.Raise();
+                    //playerSFX.pitch = Random.Range(0.8f, 1.2f);
+                    //playerSFX.PlayOneShot(footstepConcrete, 0.50f);
+
+                }
+            }
+
+            if (waveslice != 0)
+            {
+                float translateChange = waveslice * (amount / 100);
+                float totalAxes = Controller.velocity.magnitude;
+                totalAxes = Mathf.Clamp(totalAxes, 0.0f, 1.0f);
+                translateChange = totalAxes * translateChange;
+
+                return translateChange;
+            }
+
+            return 0;
+        }
+
+
+
+    }
+}
+    
+    
+    
+    
+

package/Scripts/Cameras/Headbobbing.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 04a574d5bc7cb2e49a056803045e6cf0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Scripts/Cameras/ICameraEnabler.cs

@@ -0,0 +1,15 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+namespace DREditor.Cameras
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public interface ICameraEnabler
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="enabled"></param>
+        void InvokeCameraEnabled(bool enabled);
+    }
+}

package/Scripts/Cameras/ICameraEnabler.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 130cb9909033d334db1fbbf02eae95e8

package/Scripts/Cameras/MouseLook.cs

@@ -0,0 +1,78 @@
+//Author: Happy30
+using DREditor.EventObjects;
+using UnityEngine;
+
+
+namespace DREditor.Cameras
+{
+    public class MouseLook : MonoBehaviour
+    {
+        public BoolVariable InCutscene;
+        public float Sensivity;
+        public Transform Player;
+
+
+        void OnEnable()
+        {
+            Cursor.lockState = CursorLockMode.Locked;
+            InCutscene.Register();
+
+            if (!InCutscene.Value)
+            {
+                Cursor.lockState = CursorLockMode.Locked;
+            }
+        }
+
+        void OnDisable()
+        {
+            InCutscene.Unregister();
+        }
+
+        void Update()
+        {
+            if (InCutscene.Value) return;
+            FirstPersonView();
+        }
+
+        void FirstPersonView()
+        {
+            Player.transform.Rotate(0, Input.GetAxis("Mouse X") * Sensivity, 0);
+
+            var rotationX = -Input.GetAxis("Mouse Y") * Sensivity + transform.eulerAngles.x;
+            rotationX = ClampAngle(rotationX, -80, 80);
+
+
+
+
+            transform.rotation = Quaternion.Euler(new Vector3(rotationX, transform.eulerAngles.y, transform.eulerAngles.z));
+        }
+
+        //Make sure we can't make loops with the camera.
+        float ClampAngle(float angle, float min, float max)
+        {
+            if (angle < 90 || angle > 270)
+            {       // if angle in the critic region...
+                if (angle > 180)
+                {
+                    angle -= 360;
+                }// convert all angles to -180..+180
+                if (max > 180)
+                {
+                    max -= 360;
+                }
+                if (min > 180)
+                {
+                    min -= 360;
+                }
+            }
+            angle = Mathf.Clamp(angle, min, max);
+            if (angle < 0)
+            {
+                angle += 360;
+            }   // if angle negative, convert to 0..360
+            return angle;
+        }
+
+
+    }
+}

package/Scripts/Cameras/MouseLook.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4c50d2c6e6fbef54fa0df03fd657c1dc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: