Added new utility scripts: GameManager, DataManager, CameraController, HealthSystem, and TooltipManager

Author: Drchamyoung

.gitignore

@@ -0,0 +1,51 @@
+# Unity generated
+[Ll]ibrary/
+[Tt]emp/
+[Oo]bj/
+[Bb]uild/
+[Bb]uilds/
+[Ll]ogs/
+[Uu]ser[Ss]ettings/
+
+# Unity3D generated meta files
+*.pidb.meta
+*.pdb.meta
+*.mdb.meta
+
+# Unity3D generated file on crash reports
+sysinfo.txt
+
+# Builds
+*.apk
+*.aab
+*.unitypackage
+*.app
+
+# Crashlytics generated file
+crashlytics-build.properties
+
+# Visual Studio
+.vs/
+*.csproj
+*.unityproj
+*.sln
+*.suo
+*.tmp
+*.user
+*.userprefs
+*.pidb
+*.booproj
+*.svd
+*.pdb
+*.mdb
+*.opendb
+*.VC.db
+
+# OS generated
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db 

CameraController.cs

@@ -0,0 +1,39 @@
+using UnityEngine;
+
+public class CameraController : MonoBehaviour
+{
+    [Header("Target Settings")]
+    public Transform target;
+    public Vector3 offset = new Vector3(0, 5, -10);
+    
+    [Header("Smooth Settings")]
+    public float smoothSpeed = 5f;
+    public float rotationSpeed = 2f;
+    
+    [Header("Boundaries")]
+    public float minY = 2f;
+    public float maxY = 10f;
+    public float minX = -10f;
+    public float maxX = 10f;
+    
+    private void LateUpdate()
+    {
+        if (target == null) return;
+        
+        // Calculate desired position
+        Vector3 desiredPosition = target.position + offset;
+        
+        // Clamp position within boundaries
+        desiredPosition.y = Mathf.Clamp(desiredPosition.y, minY, maxY);
+        desiredPosition.x = Mathf.Clamp(desiredPosition.x, minX, maxX);
+        
+        // Smoothly move camera
+        Vector3 smoothedPosition = Vector3.Lerp(transform.position, desiredPosition, smoothSpeed * Time.deltaTime);
+        transform.position = smoothedPosition;
+        
+        // Look at target
+        Vector3 targetPosition = new Vector3(target.position.x, target.position.y, target.position.z);
+        Quaternion targetRotation = Quaternion.LookRotation(targetPosition - transform.position);
+        transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, rotationSpeed * Time.deltaTime);
+    }
+} 

DataManager.cs

@@ -0,0 +1,67 @@
+using UnityEngine;
+using System;
+
+public class DataManager : MonoBehaviour
+{
+    public static DataManager Instance { get; private set; }
+    
+    private void Awake()
+    {
+        if (Instance == null)
+        {
+            Instance = this;
+            DontDestroyOnLoad(gameObject);
+        }
+        else
+        {
+            Destroy(gameObject);
+        }
+    }
+    
+    public void SaveData(string key, object value)
+    {
+        if (value is int intValue)
+            PlayerPrefs.SetInt(key, intValue);
+        else if (value is float floatValue)
+            PlayerPrefs.SetFloat(key, floatValue);
+        else if (value is string stringValue)
+            PlayerPrefs.SetString(key, stringValue);
+        else
+            Debug.LogError($"Unsupported data type for saving: {value.GetType()}");
+            
+        PlayerPrefs.Save();
+    }
+    
+    public T LoadData<T>(string key, T defaultValue)
+    {
+        if (!PlayerPrefs.HasKey(key))
+            return defaultValue;
+            
+        if (typeof(T) == typeof(int))
+            return (T)Convert.ChangeType(PlayerPrefs.GetInt(key), typeof(T));
+        else if (typeof(T) == typeof(float))
+            return (T)Convert.ChangeType(PlayerPrefs.GetFloat(key), typeof(T));
+        else if (typeof(T) == typeof(string))
+            return (T)Convert.ChangeType(PlayerPrefs.GetString(key), typeof(T));
+        else
+        {
+            Debug.LogError($"Unsupported data type for loading: {typeof(T)}");
+            return defaultValue;
+        }
+    }
+    
+    public void DeleteData(string key)
+    {
+        if (PlayerPrefs.HasKey(key))
+        {
+            PlayerPrefs.DeleteKey(key);
+            PlayerPrefs.Save();
+        }
+    }
+    
+    public void DeleteAllData()
+    {
+        PlayerPrefs.DeleteAll();
+        PlayerPrefs.Save();
+    }
+} 

GameManager.cs

@@ -0,0 +1,47 @@
+using UnityEngine;
+using System.Collections;
+
+public class GameManager : MonoBehaviour
+{
+    public static GameManager Instance { get; private set; }
+    
+    public bool isGamePaused { get; private set; }
+    public bool isGameOver { get; private set; }
+    
+    private void Awake()
+    {
+        if (Instance == null)
+        {
+            Instance = this;
+            DontDestroyOnLoad(gameObject);
+        }
+        else
+        {
+            Destroy(gameObject);
+        }
+    }
+    
+    public void PauseGame()
+    {
+        isGamePaused = true;
+        Time.timeScale = 0f;
+    }
+    
+    public void ResumeGame()
+    {
+        isGamePaused = false;
+        Time.timeScale = 1f;
+    }
+    
+    public void GameOver()
+    {
+        isGameOver = true;
+        // Add your game over logic here
+    }
+    
+    public void RestartGame()
+    {
+        isGameOver = false;
+        // Add your restart logic here
+    }
+} 

HealthSystem.cs

@@ -0,0 +1,64 @@
+using UnityEngine;
+using UnityEngine.Events;
+
+public class HealthSystem : MonoBehaviour
+{
+    [Header("Health Settings")]
+    public float maxHealth = 100f;
+    public float currentHealth;
+    public bool isInvulnerable = false;
+    
+    [Header("Events")]
+    public UnityEvent onDeath;
+    public UnityEvent<float> onHealthChanged;
+    public UnityEvent<float> onDamageTaken;
+    public UnityEvent<float> onHealed;
+    
+    private void Start()
+    {
+        currentHealth = maxHealth;
+        onHealthChanged?.Invoke(currentHealth);
+    }
+    
+    public void TakeDamage(float damage)
+    {
+        if (isInvulnerable) return;
+        
+        currentHealth = Mathf.Max(0, currentHealth - damage);
+        onDamageTaken?.Invoke(damage);
+        onHealthChanged?.Invoke(currentHealth);
+        
+        if (currentHealth <= 0)
+        {
+            Die();
+        }
+    }
+    
+    public void Heal(float amount)
+    {
+        currentHealth = Mathf.Min(maxHealth, currentHealth + amount);
+        onHealed?.Invoke(amount);
+        onHealthChanged?.Invoke(currentHealth);
+    }
+    
+    public void SetInvulnerable(bool invulnerable)
+    {
+        isInvulnerable = invulnerable;
+    }
+    
+    private void Die()
+    {
+        onDeath?.Invoke();
+        // Add additional death logic here
+    }
+    
+    public float GetHealthPercentage()
+    {
+        return currentHealth / maxHealth;
+    }
+    
+    public bool IsAlive()
+    {
+        return currentHealth > 0;
+    }
+} 

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Unity Tool Scripts
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.