add dithering back, only zoom when right clicking

Assets/BouncePad.cs

@@ -0,0 +1,6 @@
+using UnityEngine;
+
+public class BouncePad : MonoBehaviour
+{
+    public float bounciness = 1;
+}

Assets/BouncePad.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4fa1a488b56d8274fbeadd3c4fa613c5

Assets/Diggem_Island_Test_High.fbx.meta

@@ -0,0 +1,110 @@
+fileFormatVersion: 2
+guid: 6c111ce829d1706468fa324e2283ab11
+ModelImporter:
+  serializedVersion: 24200
+  internalIDToNameTable: []
+  externalObjects: {}
+  materials:
+    materialImportMode: 2
+    materialName: 0
+    materialSearch: 1
+    materialLocation: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    removeConstantScaleCurves: 0
+    motionNodeName: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    importConstraints: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 0
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    useSRGBMaterialColor: 1
+    sortHierarchyByName: 1
+    importPhysicalCameras: 1
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    nodeNameCollisionStrategy: 1
+    fileIdsGeneration: 2
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    keepQuads: 0
+    weldVertices: 1
+    bakeAxisConversion: 0
+    preserveHierarchy: 0
+    skinWeightsMode: 0
+    maxBonesPerVertex: 4
+    minBoneWeight: 0.001
+    optimizeBones: 1
+    generateMeshLods: 0
+    meshLodGenerationFlags: 0
+    maximumMeshLod: -1
+    meshOptimizationFlags: -1
+    indexFormat: 0
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVMarginMethod: 1
+    secondaryUVMinLightmapResolution: 40
+    secondaryUVMinObjectScale: 1
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+    strictVertexDataChecks: 0
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 0
+    blendShapeNormalImportMode: 1
+    normalSmoothingSource: 0
+  referencedClips: []
+  importAnimation: 1
+  humanDescription:
+    serializedVersion: 3
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    globalScale: 1
+    rootMotionBoneName: 
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  autoGenerateAvatarMappingIfUnspecified: 1
+  animationType: 2
+  humanoidOversampling: 1
+  avatarSetup: 0
+  addHumanoidExtraRootOnlyWhenUsingAvatar: 1
+  importBlendShapeDeformPercent: 1
+  remapMaterialsIfMaterialImportModeIsNone: 0
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Doug.prefab

@@ -3224,8 +3224,9 @@ MonoBehaviour:
   - {fileID: 6038027350876930962}
   walkSpeed: 2
   sprintMultiplier: 1.5
-  gravity: 5
+  gravity: 0.03
   rotationSpeed: 40
+  jumpHeight: 250
   cameraController: {fileID: 5478143440182735446}
 --- !u!114 &5478143440182735446
 MonoBehaviour:

Assets/FastTravelIcon.cs

@@ -0,0 +1,17 @@
+using UnityEngine;
+
+public class FastTravelIcon : MonoBehaviour
+{
+    public Transform TravelLocation;
+    TeleportHandler TeleportHandler;
+
+    private void Start()
+    {
+        TeleportHandler = GameObject.FindWithTag("Player").GetComponent<TeleportHandler>();
+    }
+
+    public void GoToLocation()
+    {
+        TeleportHandler.FastTravel(TravelLocation, true);
+    }
+}

Assets/FastTravelIcon.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: c3711c2e3d35fde4c8fd02cebc72979d

Assets/Items/TestTnt.prefab

@@ -4926,6 +4926,100 @@ ParticleSystemRenderer:
   m_MeshWeighting1: 1
   m_MeshWeighting2: 1
   m_MeshWeighting3: 1
+--- !u!1 &6363008927783646894
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 3726223533882090415}
+  - component: {fileID: 3526635589839092049}
+  - component: {fileID: 7545598716694529264}
+  - component: {fileID: 7668621773188834713}
+  m_Layer: 0
+  m_Name: ExplodeRadius
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 0
+--- !u!4 &3726223533882090415
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6363008927783646894}
+  serializedVersion: 2
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 18.43488, y: 18.43488, z: 18.43488}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 6754763150105653226}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!135 &3526635589839092049
+SphereCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6363008927783646894}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 1
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 3
+  m_Radius: 0.5
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!114 &7545598716694529264
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6363008927783646894}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fcf160d0f430fff438a4e57b70f778b2, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: Assembly-CSharp::Explosion
+--- !u!54 &7668621773188834713
+Rigidbody:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6363008927783646894}
+  serializedVersion: 5
+  m_Mass: 1
+  m_LinearDamping: 0
+  m_AngularDamping: 0.05
+  m_CenterOfMass: {x: 0, y: 0, z: 0}
+  m_InertiaTensor: {x: 1, y: 1, z: 1}
+  m_InertiaRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ImplicitCom: 1
+  m_ImplicitTensor: 1
+  m_UseGravity: 0
+  m_IsKinematic: 0
+  m_Interpolate: 0
+  m_Constraints: 0
+  m_CollisionDetection: 0
 --- !u!1 &7529463216777598777
 GameObject:
   m_ObjectHideFlags: 0
@@ -4964,6 +5058,7 @@ Transform:
   - {fileID: 2953567605728542920}
   - {fileID: 6184526720724378978}
   - {fileID: 4002096401500763546}
+  - {fileID: 3726223533882090415}
   m_Father: {fileID: 0}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!33 &8008322410806594511
@@ -5087,6 +5182,7 @@ MonoBehaviour:
   m_EditorClassIdentifier: Assembly-CSharp::Tnt
   explodeLight: {fileID: 5338768621936571555}
   explodeParticle: {fileID: 5366483297162523608}
+  explosion: {fileID: 7545598716694529264}
   fuseTime: 2
   explosionLengthTime: 0.2
 --- !u!1 &8211024835675607581

Assets/MapPlayerIcon.cs

@@ -0,0 +1,34 @@
+using UnityEngine;
+
+public class MapPlayerIcon : MonoBehaviour
+{
+    public Vector3 RealMapBottomRight;
+    public Vector3 RealMapTopLeft;
+
+    RectTransform MapTransform;
+    RectTransform PlayerIconTransform;
+
+    void Start()
+    {
+        PlayerIconTransform = GetComponent<RectTransform>();
+        MapTransform = PlayerIconTransform.parent.GetComponent<RectTransform>();
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        Vector3 playerPos = GameManager.Instance.PlayerController.transform.position;
+
+        float worldMinX = RealMapTopLeft.x;
+        float worldMaxX = RealMapBottomRight.x;
+        float worldMinZ = RealMapBottomRight.z;
+        float worldMaxZ = RealMapTopLeft.z;
+
+        // translate player position to percentage of map for x and y
+        float normalizedX = Mathf.InverseLerp(worldMinX, worldMaxX, playerPos.x);
+        float normalizedY = Mathf.InverseLerp(worldMinZ, worldMaxZ, playerPos.z);
+
+        // anchor is 0, subtract 0.5 for accurate coords
+        PlayerIconTransform.anchoredPosition = new Vector2((normalizedX - 0.5f) * MapTransform.rect.width, (normalizedY -0.5f) * MapTransform.rect.height);
+    }
+}

Assets/MapPlayerIcon.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: f08acec5e7dc5004a9b3427a8e19b5f4

Assets/Scripts/Management/CameraController.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Unity.VisualScripting;
+using UnityEditor.Rendering;
 using UnityEngine;
 using UnityEngine.UIElements;
 using static Unity.Cinemachine.CinemachineTargetGroup;
@@ -8,38 +9,35 @@
 
 public class CameraController : MonoBehaviour
 {
-    public float camTargetRotation { get; private set; } = 0;
-    public CameraControlMode CamControlMode { get; private set; } = CameraControlMode.SnapRotate;
+    [Header("Target")]
+    [SerializeField] private Transform target;
+    [SerializeField] private Vector3 targetOffset = new Vector3(0f, 1.5f, 0f);
     public Camera MainCamera;
+    public Transform playerCamHome;
 
-    private bool isCamRotating = false;
-
-    [Header("Rotation")]
-    public float mouseSensitivity = 200f;
-    public float minPitch = -30f;
-    public float maxPitch = 60f;
-    public float distance = 5f;
-    private float yaw;
-    private float pitch;
+    [Header("Orbit")]
+    [SerializeField] private float distance = 5f;
+    [SerializeField] private float minDistance = 1f;
+    [SerializeField] private float maxDistance = 8f;
+    [SerializeField] private float rotationSpeed = 180f;
+    [SerializeField] private float rotationOffset = 270f;
+    [SerializeField] private float minPitch = -30f;
+    [SerializeField] private float maxPitch = 75f;
 
     [Header("Zoom")]
-    public float followSpeed = 10f;
-    public float maxDistance = 6f;
-    public float minDistance = 1f;
-    public float zoomSpeed = 5f;
-    public float heightOffset = -0.5f;
-    private float currentDistance;
-    private float distanceVelocity;
+    [SerializeField] private float zoomSpeed = 2f;
+    [SerializeField] private float zoomSmoothness = 10f;
 
-    [Header("Collision")]
-    public float collisionRadius = 0.3f;
-    public float collisionOffset = 0.2f;
-    public LayerMask collisionMask;
+    [Header("Camera Collision")]
+    [SerializeField] private LayerMask collisionLayers;
+    [SerializeField] private float collisionRadius = 0.25f;
+    [SerializeField] private float collisionOffset = 0.1f;
+    [SerializeField] private float positionSmoothness = 15f;
 
     [Header("Occlusion Settings")]
-    public LayerMask obstructionMask;
-    public float fadedAlpha = 0.25f;
-    public float fadeSpeed = 5f;
+    [SerializeField] private LayerMask obstructionMask;
+    [SerializeField] private float fadedAlpha = 0.25f;
+    [SerializeField] private float fadeSpeed = 5f;
 
     private Dictionary<Renderer, float> currentAlpha =
         new Dictionary<Renderer, float>();
@@ -47,228 +45,119 @@ public class CameraController : MonoBehaviour
     private Dictionary<Renderer, float> targetAlpha =
         new Dictionary<Renderer, float>();
 
-    public Transform playerCamHome;
-    Transform dougBody;
+    private float yaw;
+    private float pitch = 20f;
+    private float targetDistance;
+    private Vector3 currentVelocity;
 
-    private void Update()
+    public Vector3 Forward
     {
+        get
+        {
+            Vector3 forward = MainCamera.transform.forward;
+            forward.y = 0f;
+            return forward.normalized;
+        }
+    }
+    public Vector3 Right
+    {
+        get
+        {
+            Vector3 right = MainCamera.transform.right;
+            right.y = 0f;
+            return right.normalized;
+        }
+    }
+
+    private void Start()
+    {
+        targetDistance = distance;
+
+        Vector3 startingAngles = MainCamera.transform.eulerAngles;
+        yaw = startingAngles.y + rotationOffset;
+        pitch = startingAngles.x;
+
+        if (pitch > 180f)
+        {
+            pitch -= 360f;
+        }
+    }
+
+    private void LateUpdate()
+    {
+        if (target == null)
+        {
+            if (GameManager.Instance.PlayerController.DougBody != null)
+                target = GameManager.Instance.PlayerController.DougBody.transform;
+            else
+                return;
+        }
+
         UpdateOcclusion();
         UpdateFade();
-
-        if (Input.GetMouseButton(1))
-        {
-            HandleFreeCamRotation();
-        }
-        else
-        {
-            CamAvoidCollisions();
-        }
+        HandleRotation();
+        HandleZoom();
+        UpdateCameraPosition();
     }
 
-    void Start()
+    private void HandleRotation()
     {
-        Vector3 angles = playerCamHome.transform.eulerAngles;
-
-        yaw = angles.y;
-        pitch = angles.x;
-        currentDistance = distance;
-    }
-
-    /// <summary>
-    /// Trigger cam rotation
-    /// </summary>
-    public void RotateCam()
-    {
-        if (!isCamRotating)
+        if (!Input.GetMouseButton(1))
         {
-            float currentY = playerCamHome.transform.rotation.eulerAngles.y;
-            camTargetRotation = currentY + 90f;
-            isCamRotating = true;
-        }
-    }
-
-    /// <summary>
-    /// Set cam rotation immediately
-    /// </summary>
-    void SnapToRotation(float rotation)
-    {
-        if (CamControlMode == CameraControlMode.SnapRotate)
-        {
-            playerCamHome.RotateAround(
-                transform.position,
-                Vector3.up,
-                rotation
-            );
-
-            camTargetRotation = rotation;
-        }
-    }
-
-    /// <summary>
-    /// Move cam to desired rotation (every frame)
-    /// </summary>
-    void HandleSnapCamRotation()
-    {
-        float currentY = playerCamHome.transform.rotation.eulerAngles.y;
-        float step = 200 * Time.deltaTime;
-        float newY = Mathf.MoveTowardsAngle(currentY, camTargetRotation, step);
-
-        playerCamHome.RotateAround(
-            transform.position,
-            Vector3.up,
-            newY - currentY
-        );
-
-        if (Mathf.Abs(Mathf.DeltaAngle(newY, camTargetRotation)) < 0.01f)
-        {
-            isCamRotating = false;
-        }
-    }
-
-    /// <summary>
-    /// Move cam to desired free rotation (every frame)
-    /// </summary>
-    void HandleFreeCamRotation()
-    {
-        if (dougBody == null)
-        {
-            if (GameManager.Instance.PlayerController.DougBody != null)
-                dougBody = GameManager.Instance.PlayerController.DougBody.transform;
-            else
-                return;
+            UnityEngine.Cursor.visible = true;
+            UnityEngine.Cursor.lockState = CursorLockMode.None;
+            return;
         }
 
-        Vector3 target = new Vector3(dougBody.position.x, dougBody.position.y + heightOffset, dougBody.position.z);
+        UnityEngine.Cursor.visible = false;
+        UnityEngine.Cursor.lockState = CursorLockMode.Locked;
 
-        // Mouse Input
-        float mouseX = Input.GetAxis("Mouse X");
-        float mouseY = Input.GetAxis("Mouse Y");
-
-        yaw += mouseX * mouseSensitivity * Time.deltaTime;
-        pitch -= mouseY * mouseSensitivity * Time.deltaTime;
+        yaw += Input.GetAxis("Mouse X") * rotationSpeed * Time.deltaTime;
+        pitch -= Input.GetAxis("Mouse Y") * rotationSpeed * Time.deltaTime;
 
         pitch = Mathf.Clamp(pitch, minPitch, maxPitch);
-
-        // Rotation
-        Quaternion rotation = Quaternion.Euler(pitch, yaw, 0);
-
-        // Zoom
-        float scroll = Input.GetAxis("Mouse ScrollWheel");
-
-        if (Mathf.Abs(scroll) > 0.0001f)
-        {
-            distance -= scroll * zoomSpeed;
-            distance = Mathf.Clamp(distance, minDistance, maxDistance);
-        }
-
-        currentDistance = Mathf.SmoothDamp(
-            currentDistance,
-            distance,
-            ref distanceVelocity,
-            0.05f);
-
-        float adjustedDistance = currentDistance;
-
-        Vector3 desiredDirection =
-            rotation * Vector3.back;
-
-        // Camera obstruction handling
-        if (Physics.SphereCast(
-            target,
-            collisionRadius,
-            desiredDirection,
-            out RaycastHit hit,
-            currentDistance,
-            collisionMask,
-            QueryTriggerInteraction.Ignore))
-        {
-            adjustedDistance =
-                Mathf.Max(
-                    hit.distance - collisionOffset,
-                    minDistance);
-        }
-
-        // Desired Position
-        Vector3 offset = rotation * Vector3.forward * -adjustedDistance;
-        Vector3 desiredPosition = target + offset;
-
-        if (desiredPosition.y < dougBody.position.y)
-        {
-            desiredPosition.y = dougBody.position.y;
-        }
-
-        // Smooth Follow
-        playerCamHome.transform.position = Vector3.Lerp(
-            playerCamHome.transform.position,
-            desiredPosition,
-            followSpeed * Time.deltaTime
-        );
-
-        // Look at player
-        playerCamHome.transform.LookAt(target + Vector3.up);
     }
 
-    void CamAvoidCollisions()
+    private void HandleZoom()
     {
-        if (dougBody == null)
+        if (!Input.GetMouseButton(1))
         {
-            if (GameManager.Instance.PlayerController.DougBody != null)
-                dougBody = GameManager.Instance.PlayerController.DougBody.transform;
-            else
-                return;
+            return;
         }
 
-        Vector3 target = new Vector3(dougBody.position.x, dougBody.position.y + heightOffset, dougBody.position.z);
-        Quaternion rotation = Quaternion.Euler(pitch, yaw, 0);
-        Vector3 desiredDirection = rotation * Vector3.back;
+        float scrollInput = Input.GetAxis("Mouse ScrollWheel");
 
-        float adjustedDistance = currentDistance;
+        targetDistance -= scrollInput * zoomSpeed;
+        targetDistance = Mathf.Clamp(targetDistance, minDistance, maxDistance);
 
-        if (Physics.SphereCast(
-            target,
-            collisionRadius,
-            desiredDirection,
-            out RaycastHit hit,
-            currentDistance,
-            collisionMask,
-            QueryTriggerInteraction.Ignore))
+        distance = Mathf.Lerp(distance, targetDistance, zoomSmoothness * Time.deltaTime);
+    }
+
+    private void UpdateCameraPosition()
+    {
+        Vector3 targetPosition = target.position + targetOffset;
+
+        Quaternion orbitRotation = Quaternion.Euler(pitch, yaw, 0f);
+
+        Vector3 desiredDirection = orbitRotation * Vector3.back;
+        Vector3 desiredPosition = targetPosition + desiredDirection * distance;
+
+        float correctedDistance = distance;
+
+        if (Physics.SphereCast(targetPosition, collisionRadius, desiredDirection, out RaycastHit hit, distance, collisionLayers, QueryTriggerInteraction.Ignore))
         {
-            adjustedDistance =
-                Mathf.Max(
-                    hit.distance - collisionOffset,
-                    minDistance);
+            correctedDistance = Mathf.Max(minDistance, hit.distance - collisionOffset);
         }
 
-        // Desired Position
-        Vector3 offset = rotation * Vector3.forward * -adjustedDistance;
-        Vector3 desiredPosition = target + offset;
+        Vector3 finalPosition = targetPosition + desiredDirection * correctedDistance;
 
-        if (desiredPosition.y < dougBody.position.y)
-        {
-            desiredPosition.y = dougBody.position.y;
-        }
+        MainCamera.transform.position = Vector3.SmoothDamp(MainCamera.transform.position, finalPosition, ref currentVelocity, 1f / positionSmoothness);
 
-        // Smooth Follow
-        playerCamHome.transform.position = Vector3.Lerp(
-            playerCamHome.transform.position,
-            desiredPosition,
-            followSpeed * Time.deltaTime
-        );
-
-        // Look at player
-        playerCamHome.transform.LookAt(target + Vector3.up);
+        MainCamera.transform.rotation = Quaternion.LookRotation(targetPosition - MainCamera.transform.position, Vector3.up);
     }
 
     void UpdateOcclusion()
     {
-        if (dougBody == null)
-        {
-            if (GameManager.Instance.PlayerController.DougBody != null)
-                dougBody = GameManager.Instance.PlayerController.DougBody.transform;
-            else
-                return;
-        }
-
         // Reset all renderers to visible
         foreach (Renderer r in new List<Renderer>(targetAlpha.Keys))
         {
@@ -276,12 +165,12 @@ void UpdateOcclusion()
         }
 
         Vector3 dir =
-            MainCamera.transform.position - dougBody.position;
+            MainCamera.transform.position - target.position;
 
         float dist = dir.magnitude;
 
         RaycastHit[] hits = Physics.RaycastAll(
-            dougBody.position,
+            target.position,
             dir.normalized,
             dist,
             obstructionMask,

Assets/Scripts/Management/PlayerController.cs

@@ -1,4 +1,5 @@
 using System.Collections;
+using TMPro;
 using Unity.VisualScripting.Antlr3.Runtime;
 using UnityEngine;
 using static UnityEngine.GraphicsBuffer;
@@ -10,15 +11,17 @@ public class PlayerController : MonoBehaviour
     public Tool[] tools;
     float toolUseTimestamp = 0;
 
-    public float walkSpeed;
+    public float walkSpeed = 2;
     public float sprintMultiplier = 1.5f;
-    public float gravity = 10;
-    public float rotationSpeed = 15;
+    public float gravity = 0.05f;
+    public float rotationSpeed = 40;
+    public float jumpHeight = 200f;
 
     Interactable nearestInteractable;
     public CameraController cameraController;
     private CharacterController characterController;
     private Vector3 moveDir;
+    private float verticalVelocity;
     private bool hasControl = true; // set this to false if we want to stop reading player inputs
     private bool canUseTools = true; // set this to false if we want to stop reading player tool use
     private bool isSprinting = false;
@@ -40,23 +43,7 @@ void Update()
         // TODO: Move input detection somewhere else
         if (Input.GetKeyDown(KeyCode.Escape))
         {
-            if (!paused)
-            {
-                Cursor.lockState = CursorLockMode.None;
-                Time.timeScale = 0;
-                canUseTools = false;
-                hasControl = false;
-                GameManager.Instance.MenuController.ShowScreen("Pause");
-            }
-            else
-            {
-                Time.timeScale = 1;
-                canUseTools = true;
-                hasControl = true;
-                GameManager.Instance.MenuController.HideAllScreens();
-            }
-
-            paused = !paused;
+            TogglePause();
         }
 
         if (hasControl)
@@ -69,6 +56,7 @@ void Update()
 
             CheckWeaponChange();
             ApplyWalk();
+            TryJump();
         }
 
         if (canUseTools)
@@ -77,10 +65,44 @@ void Update()
         }
 
         CheckSprint();
+        ApplySpeed();
         ApplyGravity();
         DoMovement();
     }
 
+    public void TogglePause()
+    {
+        if (!paused)
+        {
+            Cursor.lockState = CursorLockMode.None;
+            Time.timeScale = 0;
+            canUseTools = false;
+            hasControl = false;
+            GameManager.Instance.MenuController.ShowScreen("Pause");
+        }
+        else
+        {
+            Time.timeScale = 1;
+            canUseTools = true;
+            hasControl = true;
+            GameManager.Instance.MenuController.HideAllScreens();
+        }
+
+        paused = !paused;
+    }
+
+    #region Movement Calculation/Input Processing
+    /// <summary>
+    /// If player presses space, jump
+    /// </summary>
+    private void TryJump()
+    {
+        if (characterController.isGrounded && Input.GetKeyDown(KeyCode.Space))
+        {
+            verticalVelocity = Mathf.Sqrt(jumpHeight * -2f * -gravity);
+        }
+    }
+
     /// <summary>
     /// Checks if shift is being held, isSprinting is true if it is
     /// </summary>
@@ -127,61 +149,34 @@ void ApplyWalk()
             verticalMovement = Input.GetAxisRaw("Vertical");
             horizontalMovement = Input.GetAxisRaw("Horizontal");
         }
+        Vector3 input = Vector3.ClampMagnitude(new Vector3(horizontalMovement, 0f, verticalMovement), 1f);
 
-        moveDir = new Vector3(horizontalMovement, 0, verticalMovement).normalized;
-
-        if (cameraController != null)
-        {
-            // re-matrix the rotation direction so movement is consistent no matter what
-            // the camera rotation is
-
-            Matrix4x4 matrix = Matrix4x4.Rotate(Quaternion.Euler(0, cameraController.playerCamHome.rotation.eulerAngles.y, 0));
-            moveDir = matrix.MultiplyPoint3x4(moveDir);
-        }
+        moveDir = cameraController.Forward * input.z + cameraController.Right * input.x;
     }
 
     /// <summary>
-    /// Apply gravity and speed to moveDir
+    /// Apply speed to moveDir
     /// </summary>
-    void ApplyGravity()
+    void ApplySpeed()
     {
         if (isSprinting)
             moveDir *= (walkSpeed * sprintMultiplier);
         else
             moveDir *= walkSpeed;
-
-        moveDir.y += -gravity;
     }
 
     /// <summary>
-    /// Move character with moveDir 
+    /// Apply gravity to moveDir
     /// </summary>
-    void DoMovement()
+    void ApplyGravity()
     {
-        characterController.Move(moveDir * Time.deltaTime);
-    }
+        // Makes sure we're grounded (built-in character controller is wonky)
+        if (characterController.isGrounded && verticalVelocity < 0)
+        {
+            verticalVelocity = -2f;
+        }
 
-    /// <summary>
-    /// Pass movement into character controller, lets us expose function without exposing
-    /// whole char controller
-    /// </summary>
-    public void CharacterControllerMove(Vector3 movement)
-    {
-        characterController.Move(movement);
-    }
-
-    /// <summary>
-    /// Auto-walk the character in the specified direction. Uses character's walk
-    /// speed and camera rotation (per-frame)
-    /// </summary>
-    public void WalkInDirection(Vector3 direction)
-    {
-        Vector3 forwardDir = direction;
-        forwardDir.y = 0; // don't move on the y axis
-
-        forwardDir *= walkSpeed;
-
-        characterController.Move(forwardDir * Time.deltaTime);
+        verticalVelocity += -gravity;
     }
 
     /// <summary>
@@ -241,44 +236,58 @@ void RotatePlayerTowardMouse()
             }
         }*/
 
-        Camera cam = cameraController.MainCamera;
-
-        Ray ray = cam.ScreenPointToRay(Input.mousePosition);
-
-        Vector3 targetPoint;
-
-        // 1. Try real world hit first (most stable)
-        if (Physics.Raycast(ray, out RaycastHit hit, 1000f))
+        // When rotating the cam with right mouse, look forward
+        if (Input.GetMouseButton(1))
         {
-            targetPoint = hit.point;
+            Quaternion targetRotation = Quaternion.LookRotation(cameraController.Forward);
+
+            DougBody.transform.rotation = Quaternion.Slerp(
+                DougBody.transform.rotation,
+                targetRotation,
+                rotationSpeed * Time.deltaTime
+            );
         }
         else
         {
-            // 2. Fallback to plane at player height
-            Plane plane = new Plane(Vector3.up, DougBody.transform.position);
+            Camera cam = cameraController.MainCamera;
 
-            if (!plane.Raycast(ray, out float enter))
+            Ray ray = cam.ScreenPointToRay(Input.mousePosition);
+
+            Vector3 targetPoint;
+
+            // 1. Try real world hit first (most stable)
+            if (Physics.Raycast(ray, out RaycastHit hit, 1000f))
+            {
+                targetPoint = hit.point;
+            }
+            else
+            {
+                // 2. Fallback to plane at player height
+                Plane plane = new Plane(Vector3.up, DougBody.transform.position);
+
+                if (!plane.Raycast(ray, out float enter))
+                    return;
+
+                targetPoint = ray.GetPoint(enter);
+            }
+
+            // 3. Flatten direction so we only rotate on Y axis
+            Vector3 direction = targetPoint - DougBody.transform.position;
+            direction.y = 0f;
+
+            if (direction.sqrMagnitude < 0.001f)
                 return;
 
-            targetPoint = ray.GetPoint(enter);
+            // 4. Convert to rotation
+            Quaternion targetRotation = Quaternion.LookRotation(direction.normalized);
+
+            // 5. Smooth rotation
+            DougBody.transform.rotation = Quaternion.Slerp(
+                DougBody.transform.rotation,
+                targetRotation,
+                rotationSpeed * Time.deltaTime
+            );
         }
-
-        // 3. Flatten direction so we only rotate on Y axis
-        Vector3 direction = targetPoint - DougBody.transform.position;
-        direction.y = 0f;
-
-        if (direction.sqrMagnitude < 0.001f)
-            return;
-
-        // 4. Convert to rotation
-        Quaternion targetRotation = Quaternion.LookRotation(direction.normalized);
-
-        // 5. Smooth rotation
-        DougBody.transform.rotation = Quaternion.Slerp(
-            DougBody.transform.rotation,
-            targetRotation,
-            rotationSpeed * Time.deltaTime
-        );
     }
 
     /// <summary>
@@ -292,61 +301,13 @@ void TryInteract()
         }
     }
 
-    private void OnTriggerEnter(Collider other)
-    {
-        Interactable interactable = other.GetComponent<Interactable>();
-
-        // store nearest interactable if it exists
-        if (interactable != null)
-        {
-            nearestInteractable = interactable;
-            interactable.MoveInsideRange();
-        }
-    }
-
-    private void OnTriggerExit(Collider other)
-    {
-        // just null out interactables when we leave an interactable trigger (we cant and shouldn't overlap interactables)
-        Interactable interactable = other.GetComponent<Interactable>();
-
-        // store nearest interactable if it exists
-        if (interactable != null && nearestInteractable != null)
-        {
-            nearestInteractable.MoveOutsideRange();
-            nearestInteractable = null;
-        }
-    }
-
     /// <summary>
-    /// Sets the character's "hasControl" bool. All input is ignored when false
+    /// Move character with moveDir 
     /// </summary>
-    public void SetCharacterControl(bool hasControl)
+    void DoMovement()
     {
-        this.hasControl = hasControl;
-    }
-
-    /// <summary>
-    /// Sets the character's "canUseTools" bool. Tool use input is ignored when false
-    /// </summary>
-    public void SetCharacterCanUseTools(bool canUseTools)
-    {
-        this.canUseTools = canUseTools;
-    }
-
-    /// <summary>
-    /// Gets the character's "hasControl" bool. All input is ignored when false
-    /// </summary>
-    public bool GetCharacterHasControl()
-    {
-        return hasControl;
-    }
-
-    /// <summary>
-    /// Expose the character controller's velocity
-    /// </summary>
-    public Vector3 GetVelocity()
-    {
-        return characterController.velocity;
+        moveDir.y = verticalVelocity;
+        characterController.Move(moveDir * Time.deltaTime);
     }
 
     /// <summary>
@@ -358,7 +319,7 @@ public Vector3 GetVelocity()
     /// try the previous tool if the tool at toolIndex is not unlocked.
     /// </param>
     /// </summary>
-    private void SwitchTools(int toolIndex, bool defaultToUp=true)
+    private void SwitchTools(int toolIndex, bool defaultToUp = true)
     {
         if (toolIndex < 0 || toolIndex >= tools.Length)
         {
@@ -422,5 +383,122 @@ private void SwitchTools(bool up)
             else SwitchTools(newIndex - 1, false);
         }
     }
+    #endregion
+
+    #region External Controls
+    /// <summary>
+    /// Pass movement into character controller, lets us expose function without exposing
+    /// whole char controller
+    /// </summary>
+    public void CharacterControllerMove(Vector3 movement)
+    {
+        characterController.Move(movement);
+    }
+
+    /// <summary>
+    /// Set the character controller's position
+    /// </summary>
+    public void CharacterControllerSetPosition(Vector3 pos)
+    {
+        characterController.enabled = false;
+        transform.position = pos;
+        characterController.enabled = true;
+    }
+
+    /// <summary>
+    /// Auto-walk the character in the specified direction. Uses character's walk
+    /// speed and camera rotation (per-frame)
+    /// </summary>
+    public void WalkInDirection(Vector3 direction)
+    {
+        Vector3 forwardDir = direction;
+        forwardDir.y = 0; // don't move on the y axis
+
+        forwardDir *= walkSpeed;
+
+        characterController.Move(forwardDir * Time.deltaTime);
+    }
+
+    /// <summary>
+    /// Sets the character's "hasControl" bool. All input is ignored when false
+    /// </summary>
+    public void SetCharacterControl(bool hasControl)
+    {
+        this.hasControl = hasControl;
+    }
+
+    /// <summary>
+    /// Sets the character's "canUseTools" bool. Tool use input is ignored when false
+    /// </summary>
+    public void SetCharacterCanUseTools(bool canUseTools)
+    {
+        this.canUseTools = canUseTools;
+    }
+
+    /// <summary>
+    /// Gets the character's "hasControl" bool. All input is ignored when false
+    /// </summary>
+    public bool GetCharacterHasControl()
+    {
+        return hasControl;
+    }
+
+    /// <summary>
+    /// Expose the character controller's velocity
+    /// </summary>
+    public Vector3 GetVelocity()
+    {
+        return characterController.velocity;
+    }
+
+    /// <summary>
+    /// Bounce off of object (upward), reverses downward velocity and multiplies it by
+    /// the bounciness
+    /// <param name="bounciness">How bouncy the surface is</param>
+    /// </summary>
+    public void Bounce(float bounciness)
+    {
+        if (verticalVelocity < -3f)
+        {
+            float bounceForce = -verticalVelocity * bounciness;
+            verticalVelocity = bounceForce;
+            moveDir.y = bounceForce;
+        }
+    }
+    #endregion
+
+    private void OnTriggerEnter(Collider other)
+    {
+        Interactable interactable = other.GetComponent<Interactable>();
+
+        // store nearest interactable if it exists
+        if (interactable != null)
+        {
+            nearestInteractable = interactable;
+            interactable.MoveInsideRange();
+        }
+    }
+
+    private void OnTriggerExit(Collider other)
+    {
+        // just null out interactables when we leave an interactable trigger (we cant and shouldn't overlap interactables)
+        Interactable interactable = other.GetComponent<Interactable>();
+
+        // store nearest interactable if it exists
+        if (interactable != null && nearestInteractable != null)
+        {
+            nearestInteractable.MoveOutsideRange();
+            nearestInteractable = null;
+        }
+    }
+
+    private void OnControllerColliderHit(ControllerColliderHit hit)
+    {
+        BouncePad bouncePad = hit.gameObject.GetComponent<BouncePad>();
+        if (bouncePad != null)
+        {
+            Bounce(bouncePad.bounciness);
+        }
+    }
 }
 

Assets/Scripts/Management/TeleportHandler.cs

@@ -13,6 +13,19 @@ private void Start()
         playerController = GetComponent<PlayerController>();
     }
 
+    /// <summary>
+    /// Triggers the fast travel coroutine
+    /// </summary>
+    public void FastTravel(Transform position, bool isPaused)
+    {
+        if (isPaused)
+        {
+            GameManager.Instance.PlayerController.TogglePause();
+        }
+
+        StartCoroutine(FastTravelCoroutine(position));
+    }
+
     /// <summary>
     /// Triggers the room entrance coroutine, only works if the character is not controllable (keeps from double transitioning)
     /// </summary>
@@ -74,4 +87,41 @@ IEnumerator EnterRoomCoroutine(RoomDoor door)
         playerController.SetCharacterControl(true);
     }
 
+    /// <summary>
+    /// Handle teleportation and timing for fast travel
+    /// </summary>
+    IEnumerator FastTravelCoroutine(Transform location)
+    {
+        float fadeDuration = 0.2f; // how long to fade to/from black
+        float fadeTime = 0;
+        Color blackScreenColor = Color.black;
+
+        playerController.SetCharacterControl(false);
+
+        while (fadeTime < fadeDuration)
+        {
+            blackScreenColor.a = Mathf.Lerp(0, 1, fadeTime / fadeDuration);
+            GameManager.Instance.BlackScreen.color = blackScreenColor;
+            fadeTime += Time.deltaTime;
+            yield return null;
+        }
+        fadeTime = 0;
+
+        playerController.CharacterControllerSetPosition(location.position);
+
+        while (fadeTime < fadeDuration)
+        {
+            blackScreenColor.a = Mathf.Lerp(1, 0, fadeTime / fadeDuration);
+            GameManager.Instance.BlackScreen.color = blackScreenColor;
+
+            fadeTime += Time.deltaTime;
+            yield return null;
+        }
+
+        fadeTime = 0;
+
+        yield return new WaitForSeconds(0.2f);
+        playerController.SetCharacterControl(true);
+    }
+
 }

Assets/Scripts/WorldInteraction/BurriedItem.cs

@@ -2,12 +2,23 @@
 
 public class BurriedItem : Diggable
 {
-    public GameObject ItemToSpawn;
+    // Spawnpoint is optional, will spawn at location of dig spot, translated up 
+    // on y-axis
     public Transform Spawnpoint;
+    public GameObject ItemToSpawn;
 
     public override void Dig()
     {
-        Instantiate(ItemToSpawn, Spawnpoint.position, Spawnpoint.rotation, null);
+        if (Spawnpoint == null)
+        {
+            Vector3 newPos = new Vector3(transform.position.x, transform.position.y + 0.2f, transform.position.z);
+            Instantiate(ItemToSpawn, newPos, transform.rotation, null);
+        }
+        else
+        {
+            Instantiate(ItemToSpawn, Spawnpoint.position, Spawnpoint.rotation, null);
+        }
+
         Destroy(gameObject);
     }
 }

Assets/Scripts/WorldInteraction/Explodable.cs

@@ -0,0 +1,34 @@
+using UnityEngine;
+
+// Put this on things that will explode when they enter the collision trigger
+// an Explosion script
+public class Explodable : MonoBehaviour
+{
+    // Light is optional (only if you want the exploded object to create light)
+    public Light explodeLight;
+    public ParticleSystem explodeParticle;
+    public float explosionLengthTime;
+
+    public void Explode()
+    {
+        if (explodeLight != null)
+        {
+            explodeLight.gameObject.SetActive(true);
+            explodeLight.transform.parent = null;
+
+            Destroy(explodeLight.gameObject, explosionLengthTime);
+        }
+
+        if (explodeParticle != null)
+        {
+            explodeParticle.gameObject.SetActive(true);
+            explodeParticle.transform.parent = null;
+            //explodeParticle.transform.localScale = new Vector3(0.05f, 0.05f, 0.05f);
+            explodeParticle.Play();
+
+            Destroy(explodeParticle.gameObject, explosionLengthTime);
+        }
+
+        Destroy(gameObject);
+    }
+}

Assets/Scripts/WorldInteraction/Explodable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 0c0bbb84f48543046b86f073995c09b1

Assets/Scripts/WorldInteraction/Explosion.cs

@@ -0,0 +1,18 @@
+using UnityEngine;
+
+// Put this on an empty game object with a trigger collider. Anything inside of this 
+// trigger collider with an Explodable script will explode
+public class Explosion : MonoBehaviour
+{
+    private void OnTriggerEnter(Collider other)
+    {
+        if (other != null)
+        {
+            Explodable explodable = other.GetComponent<Explodable>();
+            if (explodable != null)
+            {
+                explodable.Explode();
+            }
+        }
+    }
+}

Assets/Scripts/WorldInteraction/Explosion.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: fcf160d0f430fff438a4e57b70f778b2

Assets/Scripts/WorldInteraction/Talkable.cs

@@ -15,7 +15,11 @@ public class Talkable : Interactable
     public void Start()
     {
         voice = GetComponent<DialogueVoice>();
-        talkIndicator.SetActive(false);
+
+        if (talkIndicator != null)
+        {
+            talkIndicator.SetActive(false);
+        }
     }
 
     void DetermineDialogue()
@@ -90,17 +94,27 @@ public override void Interact()
         else
             GameManager.Instance.DialogueManager.DisplayNextSentence();
 
-        talkIndicator.SetActive(false);
+        if (talkIndicator != null)
+        {
+            talkIndicator.SetActive(false);
+        }
     }
 
     public override void MoveInsideRange()
     {
-        talkIndicator.SetActive(true);
+        if (talkIndicator != null)
+        {
+            talkIndicator.SetActive(true);
+        }
     }
 
     public override void MoveOutsideRange()
     {
         GameManager.Instance.DialogueManager.EndDialogue();
-        talkIndicator.SetActive(false);
+
+        if (talkIndicator != null)
+        {
+            talkIndicator.SetActive(false);
+        }
     }
 }

Assets/Scripts/WorldInteraction/Tnt.cs

@@ -4,6 +4,7 @@ public class Tnt : MonoBehaviour
 {
     public Light explodeLight;
     public ParticleSystem explodeParticle;
+    public Explosion explosion;
 
     public float fuseTime;
     public float explosionLengthTime;
@@ -17,6 +18,8 @@ void Update()
         if (!exploded && timer > fuseTime)
         {
             exploded = true;
+            explosion.gameObject.SetActive(true);
+            explosion.transform.parent = null;
             explodeLight.gameObject.SetActive(true);
             explodeLight.transform.parent = null;
             explodeParticle.gameObject.SetActive(true);
@@ -26,6 +29,7 @@ void Update()
 
             Destroy(explodeLight.gameObject, explosionLengthTime);
             Destroy(explodeParticle.gameObject, explosionLengthTime);
+            Destroy(explosion.gameObject, 0.1f);
 
             Destroy(gameObject);
         }

Assets/map.png.meta

@@ -0,0 +1,117 @@
+fileFormatVersion: 2
+guid: ff5af43c5cbc5064d90c8078a8b2e90a
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 0
+    wrapV: 0
+    wrapW: 0
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ProjectSettings/TagManager.asset

@@ -24,7 +24,7 @@ TagManager:
   - CameraObstructions
   - Water
   - UI
-  - 
+  - Dither
   - 
   - 
   -