net.dreditor.core 0.1.5 → 0.1.6

package/Scripts/Cameras/PnCCamera.cs

@@ -0,0 +1,194 @@
+//Camera Script for DREditor Author: SeleniumSoul
+//Rework Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+namespace DREditor.Cameras
+{
+    using Debug = UnityEngine.Debug;
+    [AddComponentMenu("DREditor/Cameras/Point and Click Camera")]
+    public class PnCCamera : SceneEventListener
+    {
+        //Public parameters
+
+        [SerializeField] protected bool controllable = true;
+        public bool Controllable { get => controllable; set => controllable = value; }
+        public Vector3 CharPosition = new(0f, 1f, 0f);
+        [SerializeField] protected float MaxLAngle = 30f;
+        [SerializeField] protected float MaxRAngle = 30f;
+        [SerializeField] protected float MaxTAngle = 20f;
+        [SerializeField] protected float MaxBAngle = 20f;
+        [SerializeField] protected float CamSpeed = 3f;
+        [SerializeField] protected float InitialHAngle = 0f;
+        [SerializeField] protected float InitialVAngle = 0f;
+        [SerializeField] protected float CamDistance = 10f;
+
+        //Focus on Object
+        public GameObject TargetObject;
+        public Vector3 TargetAimRotation;
+        public float TargetCamDistance = 5f;
+
+        //variables for calculation
+        public float CamHAngle, CamVAngle;
+        protected Vector3 TargetFocus;
+        protected Quaternion FinalAimRotation;
+        protected Vector3 FinalCamPosition;
+
+        protected int invertXInt;
+
+        [Tooltip("")]
+        [SerializeField] protected InputActionReference tpfdMove;
+
+        [SerializeField] ValueWithEvent<bool, BoolEvent> invertX = null;
+
+
+
+        
+        void Update()
+        {
+            if (Controllable)
+                UpdateOnControlled();
+            else if (TargetObject != null)
+            {
+                SetTargetFocus(TargetObject.transform.position);
+
+                FinalAimRotation = Quaternion.Lerp(transform.rotation, Quaternion.Euler(TargetAimRotation), Time.deltaTime * 30f);
+
+                FinalCamPosition = Vector3.Lerp(transform.position, TargetFocus - (transform.forward * TargetCamDistance), Time.deltaTime * 30f);
+            }
+        }
+
+
+        protected virtual void UpdateOnControlled()
+        {
+            ClearTarget();
+
+            invertXInt = invertX.Value ? -1 : 1;
+
+            Calculate(updateZ: false);
+        }
+
+        public Vector3 GetCalculatedPosition(bool updateZ = false)
+        {
+            OnPrecalculation();
+
+            Calculate(updateZ);
+
+            return FinalCamPosition;
+        }
+
+        protected virtual void OnPrecalculation()
+        {
+            ClearPosition();
+
+            ClearTarget();
+        }
+
+        public Quaternion GetCalculatedRotation()
+        {
+            GetCalculatedPosition(updateZ: true);
+
+            return FinalAimRotation;
+        }
+
+
+        protected virtual void Calculate(bool updateZ = false)
+        {
+            CamHAngle += Mathf.Clamp(tpfdMove.action.ReadValue<Vector2>().x * invertXInt, -1, 1) * (CamSpeed * 10) * Time.deltaTime;
+
+            CamVAngle += Mathf.Clamp(tpfdMove.action.ReadValue<Vector2>().y, -1, 1) * (CamSpeed * 10) * Time.deltaTime;
+
+            CamHAngle = Mathf.Clamp(CamHAngle, -MaxLAngle, MaxRAngle);
+
+            CamVAngle = Mathf.Clamp(CamVAngle, -MaxBAngle, MaxTAngle);
+
+            FinalAimRotation = Quaternion.Euler(-CamVAngle + InitialVAngle, CamHAngle + InitialHAngle, 0);
+
+            Vector3 direction = updateZ ? new Vector3(0, 0, 1) : transform.forward;
+
+            FinalCamPosition = (TargetFocus - new Vector3(0, CamVAngle / 30f)) - (direction * CamDistance);
+        }
+
+
+        public void FocusCamera(string TarObj)
+        {
+            FocusCamera(GameObject.Find(TarObj), Vector3.zero, 8f);
+
+            Debug.Log($"REPORT: {nameof(PnCCamera)}: Focusing on " + TargetObject.name + "using a string.");
+        }
+
+        public void FocusCamera(GameObject target, Vector3 rotation, float distance)
+        {
+            ControlSwitch(false);
+
+            SetTargetObject(target);
+
+            TargetAimRotation = rotation;
+
+            TargetCamDistance = distance;
+
+            Debug.Log($"REPORT: {nameof(PnCCamera)}: Focusing on a spot manually.");
+        }
+
+        public void ControlSwitch(bool option)
+        {
+            Controllable = option;
+        }
+
+        
+
+        protected virtual void ClearTarget()
+        {
+            SetTargetObject(null);
+
+            SetTargetFocus(CharPosition);
+        }
+
+        protected virtual void SetTargetObject(GameObject target) => TargetObject = target;
+        protected virtual void SetTargetFocus(Vector3 target) => TargetFocus = target;
+
+        public void ClearPosition()
+        {
+            CamHAngle = 0;
+
+            CamVAngle = 0;
+        }
+
+        protected virtual void LateUpdate() => transform.SetPositionAndRotation(FinalCamPosition, FinalAimRotation);
+
+        public override void OnEventRaised()
+        {
+            base.OnEventRaised();
+
+            enabled = false;
+        }
+
+        public void SetInitialAngles(float InitialHAngle, float InitialVAngle)
+        {
+            this.InitialHAngle = InitialHAngle;
+
+            this.InitialVAngle = InitialVAngle;
+        }
+
+        public virtual void SetPositions(float CamDistance, Vector3 CharPosition)
+        {
+            this.CamDistance = CamDistance;
+
+            this.CharPosition = CharPosition;
+        }
+
+        public virtual void SetAngles(float MaxLAngle, float MaxRAngle, float MaxTAngle, float MaxBAngle)
+        {
+            this.MaxLAngle = MaxLAngle;
+
+            this.MaxRAngle = MaxRAngle;
+
+            this.MaxTAngle = MaxTAngle;
+
+            this.MaxBAngle = MaxBAngle;
+        }
+
+        public virtual Vector3 GetFinalPosition() => FinalCamPosition;
+    }
+}

package/Scripts/Cameras/PnCCamera.cs.meta

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

package/Scripts/Cameras/SmoothMouseLook.cs

@@ -0,0 +1,241 @@
+//Author: Happy30
+using DREditor.EventObjects;
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+namespace DREditor.Cameras
+{
+    public class SmoothMouseLook : MonoBehaviour
+    {
+        [SerializeField] Vector2 _mouseAbsolute;
+        [SerializeField] Vector2 _smoothMouse;
+
+        [SerializeField] ValueWithEvent<bool, BoolEvent> invertX = null;
+        public bool XInvert => invertX != null? 
+            invertX.Value : InvertX;
+
+        [SerializeField] bool InvertX = false;
+
+
+        [SerializeField] ValueWithEvent<bool, BoolEvent> invertLook = null;
+
+        public bool LookInvert => invertLook != null?
+            invertLook.Value : InvertLook;
+
+        [SerializeField] bool InvertLook = false;
+
+        public Vector2 clampInDegrees = new Vector2(360, 180);
+        public bool lockCursor;
+        public Vector2 sensitivity = new Vector2(2, 2);
+        public Vector2 smoothing = new Vector2(3, 3);
+        public Vector2 targetDirection;
+        public Vector2 targetCharacterDirection;
+
+        public BoolWithEvent InDialogue;
+
+        [Tooltip("")]
+        [SerializeField] protected TransformWithEvent playerSpawnPoint = null;
+
+        [Tooltip("")]
+        [SerializeField] protected InputActionReference look;
+
+        // Assign this if there's a parent object controlling motion, such as a Character Controller.
+        // Yaw rotation will affect this object instead of the camera if set.
+        public GameObject characterBody;
+
+
+        void Start()
+        {
+            // Set target direction to the camera's initial orientation.
+            targetDirection = transform.localRotation.eulerAngles;
+
+            // Set target direction for the character body to its inital state.
+            if (characterBody)
+                targetCharacterDirection = characterBody.transform.localRotation.eulerAngles;
+        }
+
+        public void SetSenstitivity(float nextSensitivity)
+        {
+            nextSensitivity--;
+            sensitivity = new Vector2(nextSensitivity, nextSensitivity);
+        }
+        public Vector2 GetAbsolute() => _mouseAbsolute;
+        public Vector2 GetSmooth() => _smoothMouse;
+        //const Vector2 defaultSmooth = ;
+
+        public void SetCore()
+        {
+            ClearCorePos();
+
+            if (playerSpawnPoint.Value.Pos != Vector3.zero)
+                SetCorePos(new Vector2(playerSpawnPoint.Value.Rot.eulerAngles.y, characterBody.transform.localEulerAngles.x));
+            else
+                transform.localEulerAngles
+                    = new Vector2(characterBody.transform.localEulerAngles.x, playerSpawnPoint.Value.Rot.eulerAngles.y);
+        }
+
+        public void SetCorePos(Vector2 abs, Vector2? smooth = null)
+        {
+            ClearCorePos();
+
+            smooth ??= new Vector2(1.401298e-45f, 1.401298e-45f);
+
+            SetMice(abs, smooth);
+        }
+
+        public void ClearCorePos() => SetMice(Vector2.zero, Vector2.zero);
+
+        protected virtual void SetMice(Vector2 abs, Vector2? smooth = null)
+        {
+            _mouseAbsolute = abs;
+
+            _smoothMouse = (Vector2)smooth;
+        }
+
+        public Quaternion GetRotation(bool regular = true)
+        {
+            LockCursor();
+
+            // Get raw mouse input for a cleaner reading on more sensitive mice.
+#if ENABLE_INPUT_SYSTEM
+            var mouseDelta = look.action.ReadValue<Vector2>();
+#elif ENABLE_LEGACY_INPUT_MANAGER
+			var mouseDelta = new Vector2(Input.GetAxisRaw("Mouse X"), Input.GetAxisRaw("Mouse Y"));
+#endif
+            if (XInvert)
+                mouseDelta.x = -mouseDelta.x;
+
+            if (LookInvert)
+                mouseDelta.y = -mouseDelta.y;
+
+            var newSensiv = sensitivity;
+
+            if (InDialogue.Value)
+            {
+                newSensiv /= 20;
+            }
+
+            if (!regular)
+            {
+                mouseDelta.x = 0;
+
+                mouseDelta.y = 0;
+            }
+
+            // Scale input against the sensitivity setting and multiply that against the smoothing value.
+            mouseDelta = Vector2.Scale(mouseDelta, new Vector2(newSensiv.x * smoothing.x, newSensiv.y * smoothing.y));
+
+            UpdateAbsolute(mouseDelta);
+
+            UpdateTransform();
+
+            var targetOrientation = Quaternion.Euler(targetDirection);
+
+            return Quaternion.AngleAxis(-_mouseAbsolute.y, targetOrientation * Vector3.right) * targetOrientation;
+        }
+        public Quaternion DRGetRotation(bool regular = true)
+        {
+            LockCursor();
+
+            // Get raw mouse input for a cleaner reading on more sensitive mice.
+#if ENABLE_INPUT_SYSTEM
+            var mouseDelta = look.action.ReadValue<Vector2>();
+#elif ENABLE_LEGACY_INPUT_MANAGER
+			var mouseDelta = new Vector2(Input.GetAxisRaw("Mouse X"), Input.GetAxisRaw("Mouse Y"));
+#endif
+
+            if (!regular)
+            {
+                mouseDelta.x = 0;
+
+                mouseDelta.y = 0;
+            }
+
+            if (XInvert)
+                mouseDelta.x = -mouseDelta.x;
+
+            if (LookInvert)
+                mouseDelta.y = -mouseDelta.y;
+
+            var newSensiv = sensitivity;
+
+            if (InDialogue.Value)
+            {
+                newSensiv /= 20;
+            }
+
+            // Scale input against the sensitivity setting and multiply that against the smoothing value.
+            mouseDelta = Vector2.Scale(mouseDelta, new Vector2(newSensiv.x * smoothing.x, newSensiv.y * smoothing.y));
+
+            UpdateAbsolute(mouseDelta);
+
+            UpdateTransform();
+
+            _mouseAbsolute.y = Mathf.Lerp(_mouseAbsolute.y, 0f, 0.2f);
+
+            var targetOrientation = Quaternion.Euler(targetDirection);
+
+            return Quaternion.AngleAxis(-_mouseAbsolute.y, targetOrientation * Vector3.right) * targetOrientation;
+        }
+
+        protected virtual void UpdateAbsolute(Vector2 mouseDelta)
+        {
+            // Interpolate mouse movement over time to apply smoothing delta.
+            _smoothMouse.x = Mathf.Lerp(_smoothMouse.x, mouseDelta.x, 1f / smoothing.x);
+            _smoothMouse.y = Mathf.Lerp(_smoothMouse.y, mouseDelta.y, 1f / smoothing.y);
+
+            // Find the absolute mouse movement value from point zero.
+            _mouseAbsolute += _smoothMouse;
+
+            // Clamp and apply the local x value first, so as not to be affected by world transforms.
+            if (clampInDegrees.x < 360)
+                _mouseAbsolute.x = Mathf.Clamp(_mouseAbsolute.x, -clampInDegrees.x * 0.5f, clampInDegrees.x * 0.5f);
+
+            // Then clamp and apply the global y value.
+            if (clampInDegrees.y < 360)
+                _mouseAbsolute.y = Mathf.Clamp(_mouseAbsolute.y, -clampInDegrees.y * 0.5f, clampInDegrees.y * 0.5f);
+        }
+
+        protected virtual void UpdateTransform()
+        {
+            if (characterBody)
+            {
+                var yRotation = Quaternion.AngleAxis(_mouseAbsolute.x, Vector3.up);
+                characterBody.transform.localRotation = yRotation * Quaternion.Euler(targetCharacterDirection);
+            }
+            else
+            {
+                var yRotation = Quaternion.AngleAxis(_mouseAbsolute.x, transform.InverseTransformDirection(Vector3.up));
+                transform.localRotation *= yRotation;
+            }
+        }
+
+        protected virtual void LockCursor()
+        {
+            // Ensure the cursor is always locked when set
+            if (lockCursor)
+            {
+                Cursor.lockState = CursorLockMode.Locked;
+            }
+        }
+
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent isLoadingFile = null;
+
+        [Tooltip("")]
+        [SerializeField] protected TransformWithEvent mouseAbs = null;
+
+        public virtual void OnSetPlayerState() // Called from Scene Event Listener OnSetPlayerState Scene Event
+        {
+            if (isLoadingFile.Value)
+                SetCorePos(mouseAbs.Value.Pos);
+            else
+                SetCore();
+        }
+
+        public void ClearPlayerSpawnTransform() // Called from Scene Event Listener StartedNewGame Scene Event
+        {
+            playerSpawnPoint.Value.Clear();
+        }
+    }
+}

package/Scripts/Cameras/SmoothMouseLook.cs.meta

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

package/Scripts/Cameras.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f9b88042999ee6b4c85163d99527536b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Scripts/Characters/Alias.cs

@@ -0,0 +1,27 @@
+//Original Author: SeleniumSoul
+//Reworked Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace DREditor.Characters
+{
+    [System.Serializable]
+    public class Alias
+    {
+        [FormerlySerializedAs("Name")] 
+        public string name = ""; 
+        public string Name { get => name; set => name = value; }
+
+        [FormerlySerializedAs("Nameplate")] 
+        public Texture2D nameplate; 
+        public Texture2D Nameplate { get => nameplate; set => nameplate = value; }
+
+        [FormerlySerializedAs("TrialNameplate")] 
+        public Texture2D trialNameplate; 
+        public Texture2D TrialNameplate { get => trialNameplate; set => trialNameplate = value; }
+
+        [FormerlySerializedAs("TrialPortrait")] 
+        public Texture2D trialPortrait; 
+        public Texture2D TrialPortrait { get => trialPortrait; set => trialPortrait = value; }
+    }
+}

package/Scripts/Characters/Alias.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6feb6afa18f63f24d8f2bcc6a3a73685

package/Scripts/Characters/Character.cs

@@ -0,0 +1,167 @@
+//Original Author: Happy30
+//Reworked Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace DREditor.Characters
+{    
+    [System.Serializable]
+    public class Character : ScriptableObject
+    {
+        public string translationKey;
+
+        [FormerlySerializedAs("LastName")]
+        public string lastName = "";
+        public string LastName { get => lastName; set => lastName = value; }
+
+        [FormerlySerializedAs("FirstName")]
+        public string firstName = "";
+        public string FirstName { get => firstName; set => firstName = value; }
+
+        [FormerlySerializedAs("DefaultSprite")] 
+        public Texture2D defaultSprite; 
+        public Texture2D DefaultSprite { get => defaultSprite; set => defaultSprite = value; }
+
+        [FormerlySerializedAs("TrialPortrait")] 
+        public Texture2D trialPortrait; 
+        public Texture2D TrialPortrait { get => trialPortrait; set => trialPortrait = value; }
+
+        [FormerlySerializedAs("NSDPortrait")] 
+        public Texture2D nSDPortrait; 
+        public Texture2D NSDPortrait { get => nSDPortrait; set => nSDPortrait = value; }//*
+
+        [FormerlySerializedAs("ActorPrefab")] 
+        public GameObject actorPrefab; 
+        public GameObject ActorPrefab { get => actorPrefab; set => actorPrefab = value; }//*
+
+#if UNITY_EDITOR
+        [FormerlySerializedAs("ShowSprites")]
+        public bool showSprites = false; // For editor window's use
+        public bool ShowSprites { get => showSprites; set => showSprites = value; }
+#endif
+        [FormerlySerializedAs("BlackExpression")] 
+        public Material blackExpression; 
+        public Material BlackExpression { get => blackExpression; set => blackExpression = value; }//*
+
+        [FormerlySerializedAs("TrialMaterial")] 
+        public Material trialMaterial; 
+        public Material TrialMaterial { get => trialMaterial; set => trialMaterial = value; }
+
+        [FormerlySerializedAs("MissingMat")] 
+        public Material missingMat; 
+        public Material MissingMat { get => missingMat; set => missingMat = value; }//*
+
+        [FormerlySerializedAs("MissingTex")] 
+        public Sprite missingTex; 
+        public Sprite MissingTex { get => missingTex; set => missingTex = value; }//*
+
+        public List<Expression> Expressions = new(); 
+
+        public List<Unlit> Sprites = new();// for using sprite renderers
+
+
+        public List<Alias> Aliases = new(); 
+
+
+        [FormerlySerializedAs("Nameplate")] 
+        public Texture2D nameplate; 
+        public Texture2D Nameplate { get => nameplate; set => nameplate = value; }
+
+        [FormerlySerializedAs("Headshot")] 
+        public Texture2D headshot; 
+        public Texture2D Headshot { get => headshot; set => headshot = value; }
+
+        [FormerlySerializedAs("TrialNameplate")] 
+        public Texture2D trialNameplate; 
+        public Texture2D TrialNameplate { get => trialNameplate; set => trialNameplate = value; }
+
+        [FormerlySerializedAs("TrialHeight")] 
+        public float trialHeight = 7.88f; 
+        public float TrialHeight { get => trialHeight; set => trialHeight = value; }
+
+        [FormerlySerializedAs("TrialPosition")] 
+        public int trialPosition = 0; 
+        public int TrialPosition { get => trialPosition; set => trialPosition = value; }
+
+
+        [FormerlySerializedAs("NotFTECharacter")] 
+        public bool notFTECharacter = false; 
+        public bool NotFTECharacter { get => notFTECharacter; set => notFTECharacter = value; } // if false then FTE character
+
+        [SelectType]
+        [SerializeReference]
+        public List<ICharacterData> datas = new();
+
+
+        public virtual void SetCharacterDatas(List<ICharacterData> datas) => this.datas = datas;
+
+
+        public virtual T Get<T>() where T : ICharacterData
+        {
+            foreach (var data in datas)
+                if (data is T soughtData)
+                    return soughtData;
+
+            return default;
+        }
+
+        public virtual bool Has<T>(out T soughtData) where T : ICharacterData
+        {
+            soughtData = default;
+
+            foreach (var data in datas)
+                if (data is T foundData)
+                    soughtData = foundData;
+
+            return soughtData is not null;
+        }
+
+        public void SetExpressions(List<Expression> Expressions) => this.Expressions = Expressions;
+
+        public void SetSprites(List<Unlit> Sprites) => this.Sprites = Sprites;
+
+        public int[] GetExpressionIntValues()
+        {
+
+            int[] values = new int[Expressions.Count + 1];
+            for (int i = 0; i < values.Length; i++)
+            {
+                values[i] = i;
+            }
+            return values;
+        }
+
+        public Texture GetSpriteByName(string name)
+        {
+            foreach(Unlit u in Sprites)
+            {
+                if (u.Name == name)
+                    return u.Sprite.texture;
+            }
+            UnityEngine.Debug.LogWarning("COULDN'T GET SPRITE BY NAME: " + name);
+            return null;
+        }
+
+        public string GetSpriteLabelByTexName(string name)
+        {
+            foreach (Unlit u in Sprites)
+            {
+                if (u.Sprite.texture.name == name)
+                    return u.Name;
+            }
+            UnityEngine.Debug.LogWarning("COULDN'T GET SPRITE LABEL BY TEX NAME: " + name);
+            return null;
+        }
+
+        public Expression GetExpressionMatching(string expressionName)
+        {
+            foreach (Expression expression in Expressions)
+                if (expression.Name == expressionName)
+                    return expression;
+
+            return null;
+        }
+    }
+}

package/Scripts/Characters/Character.cs.meta

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