Geri/SimpleTools
1
0
Fork 0
Code Issues Pull requests Projects Releases 5 Packages Wiki Activity Actions

Compare commits

base: Geri:main
Branches Tags
Geri:main
Geri:1.3.0
Geri:1.2.1
Geri:1.1.2
Geri:1.0.0
Geri:1.0.1
..
compare: Geri:1.0.0
Branches Tags
Geri:main
Geri:1.3.0
Geri:1.2.1
Geri:1.1.2
Geri:1.0.0
Geri:1.0.1

No commits in common. "main" and "1.0.0" have entirely different histories.
main ... 1.0.0

37 changed files with 1407 additions and 2365 deletions
Download patch file Download diff file Expand all files Collapse all files

70
README.md
View file

@ -2,6 +2,8 @@
This package contains simple tools to use in your project. This package contains simple tools to use in your project.
This package will be updated once I find another useful tool or someone suggest me one.
## Features ## Features
- **AudioManager** with Play, Pause and most of the other basic things, as well as some effects like FadeIn or FadeOut. - **AudioManager** with Play, Pause and most of the other basic things, as well as some effects like FadeIn or FadeOut.
@ -10,8 +12,6 @@ This package contains simple tools to use in your project.
- Basic menu with **music and SFX sliders** as well as **resolution and quality dropdowns.** - Basic menu with **music and SFX sliders** as well as **resolution and quality dropdowns.**
- An **object pooler** with the ability to create pools with an undetermined size. - An **object pooler** with the ability to create pools with an undetermined size.
- A basic **scene manager** with a loading screen with progress bar. - A basic **scene manager** with a loading screen with progress bar.
- A simple **timer** that allows you to easily create clocks, countdowns and stopwatches with TextMeshPro
- An **auto-save** feature to reduce the chances of loosing data on crashes.
All of that comes with some editor menu items for creating all of that as fast as possible. All of that comes with some editor menu items for creating all of that as fast as possible.
@ -21,11 +21,11 @@ First install the TextMeshPro and Cinemachine into your Unity project
### Git Installation (Best way to get latest version) ### Git Installation (Best way to get latest version)
If you have git in your computer, you can open Package Manager inside Unity, select "Add package from Git url...", and paste link [https://github.com/GerardGascon/SimpleTools.git](https://github.com/GerardGascon/SimpleTools.git) If you have git in your computer, you can open Package Manager inside Unity, select "Add package from Git url...", and paste link [https://github.com/Geri8/SimpleTools.git](https://github.com/Geri8/SimpleTools.git)
or or
Open the manifest.json file of your Unity project. Add "com.geri.simpletools": "[https://github.com/GerardGascon/SimpleTools.git](https://github.com/GerardGascon/SimpleTools.git)" Open the manifest.json file of your Unity project. Add "com.geri.simpletools": "[https://github.com/Geri8/SimpleTools.git](https://github.com/Geri8/SimpleTools.git)"
### Manual Installation ### Manual Installation
@ -33,16 +33,13 @@ Download latest package from the Release section Import SimpleTools.unitypackage
## Usage ## Usage
### **AudioManager** ### AudioManager
```csharp ```csharp
using SimpleTools.AudioManager;
AudioManager.instance.Play("Name"); //Plays the sound with that name AudioManager.instance.Play("Name"); //Plays the sound with that name
AudioManager.instance.Play("Name", 1f); //Starts playing the sound "Name" in 1 second AudioManager.instance.Play("Name", 1f); //Starts playing the sound "Name" in 1 second
AudioManager.instance.PlayOneShot("Name"); //Plays one shot of that sound (Useful for repeated sounds) AudioManager.instance.PlayOneShot("Name"); //Plays one shot of that sound (Useful for repeated sounds)
AudioManager.instance.PlayWithIntro("Intro", "Loop"); //Plays the intro and then the loop AudioManager.instance.PlayWithIntro("Intro", "Loop"); //Plays the intro and then the loop
AudioManager.instance.PlayRandomSound("Name1", "Name2", "Name3"); // Plays one shot of a random sound
AudioManager.instance.Pause("Name"); //Pauses the sound AudioManager.instance.Pause("Name"); //Pauses the sound
AudioManager.instance.UnPause("Name"); //Unpauses the sound AudioManager.instance.UnPause("Name"); //Unpauses the sound
@ -60,13 +57,11 @@ AudioManager.instance.FadeMutedIn("Name", 1f); //Fade In a muted sound with a sp
AudioManager.instance.FadeMutedOut("Name", 1f); //Fade Out a sound without stopping it AudioManager.instance.FadeMutedOut("Name", 1f); //Fade Out a sound without stopping it
``` ```
### **ObjectPooler** ### ObjectPooler
The SpawnFromPool function always return a GameObject The SpawnFromPool function always return a GameObject
```csharp ```csharp
using SimpleTools.ObjectPooler;
Pool pool; //The pool scriptable object goes here Pool pool; //The pool scriptable object goes here
Pooler.CreatePools(pool); //Create the pool, without creating it you cannot spawn it Pooler.CreatePools(pool); //Create the pool, without creating it you cannot spawn it
Pool[] pools; Pool[] pools;
@ -81,72 +76,29 @@ Pooler.SpawnFromPool("Name", Vector3.zero, transform, true); //Spawn into a spec
Pooler.SpawnFromPool("Name", Vector3.zero, Quaternion.identity, transform, true); //Spawn into a specific position, rotation, parent and instantiate in worldSpace or not Pooler.SpawnFromPool("Name", Vector3.zero, Quaternion.identity, transform, true); //Spawn into a specific position, rotation, parent and instantiate in worldSpace or not
``` ```
### **Dialogue System** ### Dialogue System
The Dialogue function returns a bool (true if it's talking, false if it has ended) The Dialogue function returns a bool (true if it's talking, false if it has ended)
```csharp ```csharp
using SimpleTools.DialogueSystem;
Dialogue dialogue; //The dialogue scriptable object goes here Dialogue dialogue; //The dialogue scriptable object goes here
DialogueManager.instance.Dialogue(dialogue); //Start/Continue the dialogue DialogueSystem.instance.Dialogue(dialogue); //Start/Continue the dialogue
DialogueManager.instance.Dialogue(dialogue, "Sound1", "Sound2"); //Start/Continue the dialogue with a random set of sounds for the text reveal
``` ```
Text commands: ### SceneManager
```
<color=color></color> --> Sets font color within tags
<size=percentage></size> --> Sets font size within tags
<sprite=index> --> Draws a sprite from the TextMeshPro
<p:[tiny,short,normal,long,read]> --> Pauses during a period of time
<anim:[wobble,wave,rainbow,shake]></anim> --> Reproduces an animation
<sp:number></sp> --> Changes reveal speed
<snd:name> --> Plays a sound effect
<stopmsc:name,time> --> Fades a music out
<playmsc:name,time> --> Fades a music in
```
### **SceneManager**
```csharp ```csharp
using SimpleTools.SceneManagement;
Loader.Load(0); //Loads a scene with a specific build index Loader.Load(0); //Loads a scene with a specific build index
Loader.Load("Scene"); //Loads a scene with a specific name Loader.Load("Scene"); //Loads a scene with a specific name
``` ```
### **ScreenShake** ### ScreenShake
```csharp ```csharp
using SimpleTools.Cinemachine;
ScreenShake.Shake(1f, .25f); //Shakes the camera with an intensity and duration ScreenShake.Shake(1f, .25f); //Shakes the camera with an intensity and duration
``` ```
### **Timer** ### Editor
```csharp
using SimpleTools.Timer;
//Setup a stopwatch that updates at an unscaled time
Timer timer = textMeshProText.SetupTimer(TimerType.Stopwatch, TimerUpdate.UnscaledTime);
//Setup a clock
Timer timer = textMeshProText.SetupTimer(TimerType.Clock, TimerUpdate.UnscaledTime);
//Setup a countdown with the default time of 60 seconds
Timer timer = textMeshProText.SetupTimer(TimerType.Countdown, TimerUpdate.UnscaledTime, 60f);
timer.Play(); //Play or resume the timer
timer.Stop(); //Pause the timer
timer.ResetTimer(); //Pause and sets the time to the default one
timer.Restart(); //Restarts the timer
```
### **Auto-save**
To enable auto-save you have access the menu from the top bar, *Simple Tools>Auto Save Configuration.* You can auto-save every several minutes or auto-save every time you enter play mode.
### **Editor**
You can easily set up some things by right clicking in your Project Tab and then selecting Tools and clicking on the one you want to create. You can easily set up some things by right clicking in your Project Tab and then selecting Tools and clicking on the one you want to create.

510
Tools/AudioManager/AudioManager.cs
View file

@ -2,291 +2,261 @@
using UnityEngine; using UnityEngine;
using System; using System;
namespace SimpleTools.AudioManager { public class AudioManager : MonoBehaviour{
public class AudioManager : MonoBehaviour {
public static AudioManager instance; public static AudioManager instance;
[SerializeField] Sounds soundList = default; [SerializeField] Sounds soundList = default;
void Awake() { void Awake(){
if (instance == null) { if(instance == null){
instance = this; instance = this;
} else { }else{
Destroy(gameObject); Destroy(gameObject);
return; return;
} }
DontDestroyOnLoad(gameObject); DontDestroyOnLoad(gameObject);
foreach (Sounds.List s in soundList.sounds) { foreach(Sounds.List s in soundList.sounds){
if (string.IsNullOrEmpty(s.name) || string.IsNullOrWhiteSpace(s.name)) { if(string.IsNullOrEmpty(s.name) || string.IsNullOrWhiteSpace(s.name)){
Debug.LogWarning("The name one sound is empty"); Debug.LogWarning("The name one sound is empty");
continue; continue;
} }
GameObject sound = new GameObject(s.name); GameObject sound = new GameObject(s.name);
sound.transform.parent = transform; sound.transform.parent = transform;
s.source = sound.AddComponent<AudioSource>(); s.source = sound.AddComponent<AudioSource>();
if (soundList.mainMixer && soundList.sfxMixer) { if(soundList.mainMixer && soundList.sfxMixer){
if (s.type == Sounds.List.Type.Music) if (s.type == Sounds.List.Type.Music)
s.source.outputAudioMixerGroup = soundList.mainMixer; s.source.outputAudioMixerGroup = soundList.mainMixer;
else else
s.source.outputAudioMixerGroup = soundList.sfxMixer; s.source.outputAudioMixerGroup = soundList.sfxMixer;
} }
s.source.clip = s.clip; s.source.clip = s.clip;
s.source.volume = s.volume; s.source.volume = s.volume;
s.source.pitch = s.pitch; s.source.pitch = s.pitch;
s.source.loop = s.loop; s.source.loop = s.loop;
} }
} }
#region Play #region Play
/// <summary>Use this to play a sound with a specific name /// <summary>Use this to play a sound with a specific name
/// <para>It has to be in the Sound asset referenced in the AudioManager instance</para> /// <para>It has to be in the Sound asset referenced in the AudioManager instance</para>
/// </summary> /// </summary>
/// <param name="name" type="string">The name of the sound</param> public void Play(string name){
public void Play(string name) { Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name);
Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name); if(s == null){
if (s == null) { Debug.LogWarning("Sound: " + name + " not found!");
Debug.LogWarning("Sound: " + name + " not found!"); return;
return; }
} s.source.pitch = s.RandomPitch;
s.source.pitch = s.RandomPitch; s.source.volume = s.RandomVolume;
s.source.volume = s.RandomVolume; s.source.Play();
s.source.Play(); }
} /// <summary>Use this to play a sound with a specific name and with a certain delay
/// <summary>Use this to play a sound with a specific name and with a certain delay /// <para>It has to be in the Sound asset referenced in the AudioManager instance</para>
/// <para>It has to be in the Sound asset referenced in the AudioManager instance</para> /// </summary>
/// </summary> public void Play(string name, float delay){
/// <param name="name" type="string">The name of the sound</param> Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name);
/// <param name="delay" type="float">The delay in seconds</param> if (s == null){
public void Play(string name, float delay) { Debug.LogWarning("Sound: " + name + " not found!");
Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name); return;
if (s == null) { }
Debug.LogWarning("Sound: " + name + " not found!"); s.source.pitch = s.RandomPitch;
return; s.source.volume = s.RandomVolume;
} s.source.PlayDelayed(delay);
s.source.pitch = s.RandomPitch; }
s.source.volume = s.RandomVolume; /// <summary>Use this to play one shot of a sound with a specific name
s.source.PlayDelayed(delay); /// <para>It has to be in the Sound asset referenced in the AudioManager instance</para>
} /// </summary>
/// <summary>Use this to play one shot of a sound with a specific name public void PlayOneShot(string name){
/// <para>It has to be in the Sound asset referenced in the AudioManager instance</para> Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name);
/// </summary> if (s == null){
/// <param name="name" type="string">The name of the sound</param> Debug.LogWarning("Sound: " + name + " not found!");
public void PlayOneShot(string name) { return;
Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name); }
if (s == null) { s.source.pitch = s.RandomPitch;
Debug.LogWarning("Sound: " + name + " not found!"); s.source.volume = s.RandomVolume;
return; s.source.PlayOneShot(s.clip);
} }
s.source.pitch = s.RandomPitch; /// <summary>Use this to play an intro song and then start playing the song loop
s.source.volume = s.RandomVolume; /// <para>It has to be in the Sound asset referenced in the AudioManager instance</para>
s.source.PlayOneShot(s.clip); /// </summary>
} public void PlayWithIntro(string intro, string song){
/// <summary>Use this to play an intro song and then start playing the song loop Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == intro);
/// <para>It has to be in the Sound asset referenced in the AudioManager instance</para> if (s == null){
/// </summary> Debug.LogWarning("Sound: " + intro + " not found!");
/// <param name="intro" type="string">The name of the intro song</param> return;
/// <param name="song" type="string">The name of the song loop</param> }
public void PlayWithIntro(string intro, string song) { s.source.pitch = s.RandomPitch;
Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == intro); s.source.volume = s.RandomVolume;
if (s == null) { s.source.Play();
Debug.LogWarning("Sound: " + intro + " not found!");
return;
}
s.source.pitch = s.RandomPitch;
s.source.volume = s.RandomVolume;
s.source.Play();
float introDuration = s.clip.length; float introDuration = s.clip.length;
Play(song, introDuration); Play(song, introDuration);
} }
/// <summary>Use this to play one shot of a random sound within a list #endregion
/// <para>They have to be in the Sound asset referenced in the AudioManager instance</para> #region Pause
/// </summary> /// <summary>Use this to pause a sound with a specific name
/// <param name="names" type="string[]">The names of the sounds</param> /// <para>It has to be in the Sound asset referenced in the AudioManager instance</para>
public void PlayRandomSound(params string[] names) { /// </summary>
int random = UnityEngine.Random.Range(0, names.Length); public void Pause(string name){
PlayOneShot(names[random]); Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name);
} if (s == null){
#endregion Debug.LogWarning("Sound: " + name + " not found!");
#region Pause return;
/// <summary>Use this to pause a sound with a specific name }
/// <para>It has to be in the Sound asset referenced in the AudioManager instance</para> s.source.pitch = s.RandomPitch;
/// </summary> s.source.volume = s.RandomVolume;
/// <param name="name" type="string">The name of the sound</param> s.source.Pause();
public void Pause(string name) { }
Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name); /// <summary>Use this to unpause a sound with a specific name
if (s == null) { /// <para>It has to be in the Sound asset referenced in the AudioManager instance</para>
Debug.LogWarning("Sound: " + name + " not found!"); /// </summary>
return; public void UnPause(string name){
} Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name);
s.source.pitch = s.RandomPitch; if (s == null){
s.source.volume = s.RandomVolume; Debug.LogWarning("Sound: " + name + " not found!");
s.source.Pause(); return;
} }
/// <summary>Use this to unpause a sound with a specific name s.source.pitch = s.RandomPitch;
/// <para>It has to be in the Sound asset referenced in the AudioManager instance</para> s.source.volume = s.RandomVolume;
/// </summary> s.source.UnPause();
/// <param name="name" type="string">The name of the sound</param> }
public void UnPause(string name) { #endregion
Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name); #region Stop
if (s == null) { /// <summary>Use this to stop a sound with a specific name
Debug.LogWarning("Sound: " + name + " not found!"); /// <para>It has to be in the Sound asset referenced in the AudioManager instance</para>
return; /// </summary>
} public void Stop(string name){
s.source.pitch = s.RandomPitch; Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name);
s.source.volume = s.RandomVolume; if (s == null){
s.source.UnPause(); Debug.LogWarning("Sound: " + name + " not found!");
} return;
#endregion }
#region Stop s.source.pitch = s.RandomPitch;
/// <summary>Use this to stop a sound with a specific name s.source.volume = s.RandomVolume;
/// <para>It has to be in the Sound asset referenced in the AudioManager instance</para> s.source.Stop();
/// </summary> }
/// <param name="name" type="string">The name of the sound</param> /// <summary>Use this to stop all the sounds
public void Stop(string name) { /// <para>It has to be in the Sound asset referenced in the AudioManager instance</para>
Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name); /// </summary>
if (s == null) { public void StopAll(){
Debug.LogWarning("Sound: " + name + " not found!"); foreach (Sounds.List s in soundList.sounds){
return; if (s.source){
} s.source.Stop();
s.source.pitch = s.RandomPitch; }
s.source.volume = s.RandomVolume; }
s.source.Stop(); }
} #endregion
/// <summary>Use this to stop all the sounds /// <summary>This function returns the AudioSource that contains a specific sound
/// <para>It has to be in the Sound asset referenced in the AudioManager instance</para> /// <para>It has to be in the Sound asset referenced in the AudioManager instance</para>
/// </summary> /// </summary>
public void StopAll() { public AudioSource GetSource(string name){
foreach (Sounds.List s in soundList.sounds) { Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name);
if (s.source) { if (s == null){
s.source.Stop(); Debug.LogWarning("Sound: " + name + " not found!");
} return null;
} }
} return s.source;
#endregion }
/// <summary>This function returns the AudioSource that contains a specific sound #region Fades
/// <para>It has to be in the Sound asset referenced in the AudioManager instance</para> /// <summary>Use this to start playing a sound with a fade in
/// </summary> /// <para>It has to be in the Sound asset referenced in the AudioManager instance</para>
/// <param name="name">The name of the sound</param> /// </summary>
/// <returns>The AudioSource in the scene</returns> public void FadeIn(string name, float duration){
public AudioSource GetSource(string name) { StartCoroutine(FadeInCoroutine(name, duration));
Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name); }
if (s == null) { IEnumerator FadeInCoroutine(string name, float fadeTime){
Debug.LogWarning("Sound: " + name + " not found!"); AudioSource audioSource = GetSource(name);
return null; if (audioSource != null && !audioSource.isPlaying){
} float volume = audioSource.volume;
return s.source; audioSource.volume = 0;
} audioSource.Play();
#region Fades while (audioSource.volume < volume){
/// <summary>Use this to start playing a sound with a fade in audioSource.volume += Time.deltaTime / fadeTime;
/// <para>It has to be in the Sound asset referenced in the AudioManager instance</para> yield return null;
/// </summary> }
/// <param name="name" type="string">The name of the sound</param>
/// <param name="duration" type="float">The duration of the fade in</param>
public void FadeIn(string name, float duration) {
StartCoroutine(FadeInCoroutine(name, duration));
}
IEnumerator FadeInCoroutine(string name, float fadeTime) {
AudioSource audioSource = GetSource(name);
if (audioSource != null && !audioSource.isPlaying) {
float volume = audioSource.volume;
audioSource.volume = 0;
audioSource.Play();
while (audioSource.volume < volume) {
audioSource.volume += Time.deltaTime / fadeTime;
yield return null;
}
audioSource.volume = volume; audioSource.volume = volume;
} }
} }
/// <summary>Use this to stop playing a sound with a fade out /// <summary>Use this to stop playing a sound with a fade out
/// <para>It has to be in the Sound asset referenced in the AudioManager instance</para> /// <para>It has to be in the Sound asset referenced in the AudioManager instance</para>
/// </summary> /// </summary>
/// <param name="name" type="string">The name of the sound</param> public void FadeOut(string name, float duration){
/// <param name="duration" type="float">The duration of the fade out</param> StartCoroutine(FadeOutCoroutine(name, duration));
public void FadeOut(string name, float duration) { }
StartCoroutine(FadeOutCoroutine(name, duration)); IEnumerator FadeOutCoroutine(string name, float fadeTime){
} AudioSource audioSource = GetSource(name);
IEnumerator FadeOutCoroutine(string name, float fadeTime) {
AudioSource audioSource = GetSource(name);
if (audioSource && audioSource.isPlaying) { if (audioSource && audioSource.isPlaying){
float startVolume = audioSource.volume; float startVolume = audioSource.volume;
while (audioSource.volume > 0) { while (audioSource.volume > 0){
audioSource.volume -= startVolume * Time.deltaTime / fadeTime; audioSource.volume -= startVolume * Time.deltaTime / fadeTime;
yield return null; yield return null;
} }
audioSource.Stop(); audioSource.Stop();
audioSource.volume = startVolume; audioSource.volume = startVolume;
} }
} }
/// <summary>Use this to start playing a sound muted /// <summary>Use this to start playing a sound muted
/// <para>It has to be in the Sound asset referenced in the AudioManager instance</para> /// <para>It has to be in the Sound asset referenced in the AudioManager instance</para>
/// </summary> /// </summary>
/// <param name="name" type="string">The name of the sound</param> public void PlayMuted(string name){
public void PlayMuted(string name) { Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name);
Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name); if (s == null){
if (s == null) { Debug.LogWarning("Sound: " + name + " not found!");
Debug.LogWarning("Sound: " + name + " not found!"); return;
return; }
} s.source.pitch = s.RandomPitch;
s.source.pitch = s.RandomPitch; s.source.volume = 0f;
s.source.volume = 0f; s.source.Play();
s.source.Play(); }
} /// <summary>Use this to fade in a sound that is currently muted
/// <summary>Use this to fade in a sound that is currently muted /// <para>It has to be in the Sound asset referenced in the AudioManager instance</para>
/// <para>It has to be in the Sound asset referenced in the AudioManager instance</para> /// <para>WARNING: If the PlayMuted hasn't been called before, this function won't work</para>
/// <para>WARNING: If the PlayMuted hasn't been called before, this function won't work</para> /// </summary>
/// </summary> public void FadeMutedIn(string name, float duration){
/// <param name="name" type="string">The name of the sound</param> StartCoroutine(FadeMutedInCoroutine(name, duration));
/// <param name="duration">The duration of the fade in</param> }
public void FadeMutedIn(string name, float duration) { IEnumerator FadeMutedInCoroutine(string name, float fadeTime){
StartCoroutine(FadeMutedInCoroutine(name, duration)); Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name);
} if (s == null){
IEnumerator FadeMutedInCoroutine(string name, float fadeTime) { Debug.LogWarning("Sound: " + name + " not found!");
Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name); yield break;
if (s == null) { }
Debug.LogWarning("Sound: " + name + " not found!");
yield break;
}
while (s.source.volume < s.volume) { while (s.source.volume < s.volume){
s.source.volume += Time.deltaTime / fadeTime; s.source.volume += Time.deltaTime / fadeTime;
yield return null; yield return null;
} }
s.source.volume = s.volume; s.source.volume = s.volume;
} }
/// <summary>Use this to fade out a sound and keep playing that muted /// <summary>Use this to fade out a sound and keep playing that muted
/// <para>It has to be in the Sound asset referenced in the AudioManager instance</para> /// <para>It has to be in the Sound asset referenced in the AudioManager instance</para>
/// </summary> /// </summary>
/// <param name="name" type="string">The name of the sound</param> public void FadeMutedOut(string name, float duration){
/// <param name="duration">The duration of the fade out</param> StartCoroutine(FadeMutedOutCoroutine(name, duration));
public void FadeMutedOut(string name, float duration) { }
StartCoroutine(FadeMutedOutCoroutine(name, duration)); IEnumerator FadeMutedOutCoroutine(string name, float fadeTime){
} Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name);
IEnumerator FadeMutedOutCoroutine(string name, float fadeTime) { if (s == null){
Sounds.List s = Array.Find(soundList.sounds, sound => sound.name == name); Debug.LogWarning("Sound: " + name + " not found!");
if (s == null) { yield break;
Debug.LogWarning("Sound: " + name + " not found!"); }
yield break;
}
while (s.source.volume > 0) { while (s.source.volume > 0){
s.source.volume -= Time.deltaTime / fadeTime; s.source.volume -= Time.deltaTime / fadeTime;
yield return null; yield return null;
} }
s.source.volume = 0; s.source.volume = 0;
} }
#endregion #endregion
}
} }

75
Tools/AudioManager/Sounds.cs
View file

@ -1,53 +1,50 @@
using UnityEngine; using UnityEngine;
using UnityEngine.Audio; using UnityEngine.Audio;
namespace SimpleTools.AudioManager { [CreateAssetMenu(fileName = "Sounds", menuName = "Tools/Sounds", order = 0)]
[CreateAssetMenu(fileName = "Sounds", menuName = "Simple Tools/Sounds", order = 11)] public class Sounds : ScriptableObject{
public class Sounds : ScriptableObject {
[Tooltip("The music mixer.")] [Tooltip("The music mixer.")]
public AudioMixerGroup mainMixer = default; public AudioMixerGroup mainMixer = default;
[Tooltip("The SFX mixer.")] [Tooltip("The SFX mixer.")]
public AudioMixerGroup sfxMixer = default; public AudioMixerGroup sfxMixer = default;
public List[] sounds; public List[] sounds;
[System.Serializable] [System.Serializable] public class List{
public class List { [Tooltip("Name of the sound. Each name has to be different between each other.")]
[Tooltip("Name of the sound. Each name has to be different between each other.")] public string name;
public string name;
public AudioClip clip; public AudioClip clip;
[System.Serializable] public enum Type { Music, SFX } [System.Serializable] public enum Type { Music, SFX }
[Space] [Space]
[Tooltip("Is it part of the music or the SFX?")] public Type type; [Tooltip("Is it part of the music or the SFX?")] public Type type;
[Space] [Space]
[Tooltip("Default volume of the sound."), Range(0f, 1f)] public float volume; [Tooltip("Default volume of the sound."), Range(0f, 1f)] public float volume;
[Tooltip("Variance percentage of the volume"), Range(0f, 1f)] public float volumeVariance; [Tooltip("Variance percentage of the volume"), Range(0f, 1f)] public float volumeVariance;
[Tooltip("Default pitch of the sound."), Range(.1f, 3f)] public float pitch; [Tooltip("Default pitch of the sound."), Range(.1f, 3f)] public float pitch;
[Tooltip("Variance percentage of the pitch"), Range(0f, 1f)] public float pitchVariance; [Tooltip("Variance percentage of the pitch"), Range(0f, 1f)] public float pitchVariance;
public bool loop; public bool loop;
[HideInInspector] public AudioSource source; [HideInInspector] public AudioSource source;
float randomVolume; float randomVolume;
public float RandomVolume { public float RandomVolume{
get { get{
randomVolume = volume * (1f + Random.Range(-volumeVariance / 2f, volumeVariance / 2f)); randomVolume = volume * (1f + Random.Range(-volumeVariance / 2f, volumeVariance / 2f));
return randomVolume; return randomVolume;
} }
} }
float randomPitch; float randomPitch;
public float RandomPitch { public float RandomPitch{
get { get{
randomPitch = pitch * (1f + Random.Range(-pitchVariance / 2f, pitchVariance / 2f)); randomPitch = pitch * (1f + Random.Range(-pitchVariance / 2f, pitchVariance / 2f));
return randomPitch; return randomPitch;
} }
} }
} }
}
} }

8
Tools/AutoSave.meta
View file

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

124
Tools/AutoSave/AutoSaveConfig.cs
View file

@ -1,124 +0,0 @@
#if UNITY_EDITOR
using UnityEngine;
using UnityEditor;
using System;
using System.Threading;
using UnityEditor.SceneManagement;
using System.Threading.Tasks;
namespace SimpleTools.AutoSave {
public class AutoSaveConfig : EditorWindow {
[MenuItem("Simple Tools/Auto Save Configuration")]
public static void ShowWindow(){
EditorWindow w = GetWindow<AutoSaveConfig>("Auto-save Configuration");
w.position = new Rect(w.position.position, new Vector2(400, 150));
var data = EditorPrefs.GetString("AutoSave", JsonUtility.ToJson(w, false));
JsonUtility.FromJsonOverwrite(data, w);
}
[InitializeOnLoadMethod]
static void OnInitialize(){
int _index = EditorPrefs.GetInt("Index", 0);
bool _logging = EditorPrefs.GetBool("Logging", false);
ChangeAutoSaveMode(_index, _logging);
}
protected void OnEnable() {
OnInitialize();
}
protected void OnDisable() {
var data = JsonUtility.ToJson(this, false);
EditorPrefs.SetString("AutoSave", data);
EditorPrefs.SetInt("Index", index);
EditorPrefs.SetBool("Logging", logging);
}
readonly static string[] options = new string[] { "Disabled", "On Play", "1 Minute", "10 Minutes", "1 Hour" };
public static int index;
public static bool enabled;
public static bool logging;
void OnGUI() {
GUILayout.Label("Select auto-save mode:", EditorStyles.boldLabel);
int i = EditorGUILayout.Popup(index, options);
if (i != index) ChangeAutoSaveMode(i, logging);
GUILayout.Label("Log a message every time a the scene gets saved.");
if (logging) {
if (GUILayout.Button("Disable Logging")){
logging ^= true;
ChangeAutoSaveMode(i, logging);
}
} else {
if (GUILayout.Button("Enable Logging")) {
logging ^= true;
ChangeAutoSaveMode(i, logging);
}
}
}
static CancellationTokenSource _tokenSource;
static Task _task;
static int frequency;
static void ChangeAutoSaveMode(int mode, bool log){
index = mode;
logging = log;
CancelTask();
enabled = true;
EditorApplication.playModeStateChanged -= AutoSaveWhenPlayModeStarts;
switch(index){
case 0:
enabled = false;
return;
case 1:
EditorApplication.playModeStateChanged += AutoSaveWhenPlayModeStarts;
return;
case 2:
frequency = 1 * 60 * 1000;
break;
case 3:
frequency = 10 * 60 * 1000;
break;
case 4:
frequency = 60 * 60 * 1000;
break;
}
_tokenSource = new CancellationTokenSource();
_task = SaveInterval(_tokenSource.Token);
}
static void AutoSaveWhenPlayModeStarts(PlayModeStateChange state){
if(state == PlayModeStateChange.ExitingEditMode){
EditorSceneManager.SaveOpenScenes();
AssetDatabase.SaveAssets();
if (logging) Debug.Log($"Auto-saved at {DateTime.Now:h:mm:ss tt}");
}
}
static void CancelTask() {
if (_task == null) return;
_tokenSource.Cancel();
}
static async Task SaveInterval(CancellationToken token) {
while (!token.IsCancellationRequested) {
await Task.Delay(frequency, token);
if (token.IsCancellationRequested) break;
if (!enabled || Application.isPlaying || BuildPipeline.isBuildingPlayer || EditorApplication.isCompiling) return;
if (!UnityEditorInternal.InternalEditorUtility.isApplicationActive) return;
EditorSceneManager.SaveOpenScenes();
AssetDatabase.SaveAssets();
if (logging) Debug.Log($"Auto-saved at {DateTime.Now:h:mm:ss tt}");
}
}
}
}
#endif

11
Tools/AutoSave/AutoSaveConfig.cs.meta
View file

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

63
Tools/Cinemachine/CMCameraTrigger.cs
View file

@ -1,41 +1,38 @@
using UnityEngine; using UnityEngine;
using Cinemachine; using Cinemachine;
namespace SimpleTools.Cinemachine { public class CMCameraTrigger : MonoBehaviour{
public class CMCameraTrigger : MonoBehaviour {
CinemachineVirtualCamera vcam; CinemachineVirtualCamera vcam;
[SerializeField, Tooltip("Name of the collider's tag that will trigger the camera.")] string triggerTagName;
void Awake() { void Awake(){
vcam = GetComponentInChildren<CinemachineVirtualCamera>(true); vcam = GetComponentInChildren<CinemachineVirtualCamera>(true);
vcam.gameObject.SetActive(false); vcam.gameObject.SetActive(false);
} }
#region 3D #region 3D
void OnTriggerEnter(Collider col) { void OnTriggerEnter(Collider col){
if (col.CompareTag(triggerTagName)) { if (col.CompareTag("Player")){
vcam.gameObject.SetActive(true); vcam.gameObject.SetActive(true);
} }
} }
void OnTriggerExit(Collider col) { void OnTriggerExit(Collider col){
if (col.CompareTag(triggerTagName)) { if (col.CompareTag("Player")){
vcam.gameObject.SetActive(true); vcam.gameObject.SetActive(true);
} }
} }
#endregion #endregion
#region 2D #region 2D
void OnTriggerEnter2D(Collider2D col) { void OnTriggerEnter2D(Collider2D col){
if (col.CompareTag(triggerTagName)) { if (col.CompareTag("Player")){
vcam.gameObject.SetActive(true); vcam.gameObject.SetActive(true);
} }
} }
void OnTriggerExit2D(Collider2D col) { void OnTriggerExit2D(Collider2D col){
if (col.CompareTag(triggerTagName)) { if (col.CompareTag("Player")){
vcam.gameObject.SetActive(false); vcam.gameObject.SetActive(false);
} }
} }
#endregion #endregion
}
} }

58
Tools/Cinemachine/ScreenShake.cs
View file

@ -1,38 +1,36 @@
using Cinemachine; using Cinemachine;
using UnityEngine; using UnityEngine;
namespace SimpleTools.Cinemachine { public static class ScreenShake{
public static class ScreenShake {
static CinemachineVirtualCamera vCam; static CinemachineVirtualCamera vCam;
static ScreenShakeUpdate shakeUpdate; static ScreenShakeUpdate shakeUpdate;
class ScreenShakeUpdate : MonoBehaviour { class ScreenShakeUpdate : MonoBehaviour {
[HideInInspector] public float shakeTimer; [HideInInspector] public float shakeTimer;
[HideInInspector] public float shakeTimerTotal; [HideInInspector] public float shakeTimerTotal;
[HideInInspector] public float startingIntensity; [HideInInspector] public float startingIntensity;
void Update() { void Update(){
if (shakeTimer > 0) { if (shakeTimer > 0){
shakeTimer -= Time.deltaTime; shakeTimer -= Time.deltaTime;
CinemachineBasicMultiChannelPerlin multiChannelPerlin = vCam.GetCinemachineComponent<CinemachineBasicMultiChannelPerlin>(); CinemachineBasicMultiChannelPerlin multiChannelPerlin = vCam.GetCinemachineComponent<CinemachineBasicMultiChannelPerlin>();
multiChannelPerlin.m_AmplitudeGain = Mathf.Lerp(startingIntensity, 0f, 1 - (shakeTimer / shakeTimerTotal)); multiChannelPerlin.m_AmplitudeGain = Mathf.Lerp(startingIntensity, 0f, 1 - (shakeTimer / shakeTimerTotal));
} }
} }
} }
/// <summary>Shake the camera /// <summary>Shake the camera
/// <para>It needs a cinemachine camera with a noise profile in it.</para> /// <para>It needs a cinemachine camera with a noise profile in it.</para>
/// </summary> /// </summary>
public static void Shake(float intensity, float time) { public static void Shake(float intensity, float time){
if (vCam == null) { if(vCam == null){
vCam = Camera.main.GetComponent<CinemachineBrain>().ActiveVirtualCamera.VirtualCameraGameObject.GetComponent<CinemachineVirtualCamera>(); vCam = Camera.main.GetComponent<CinemachineBrain>().ActiveVirtualCamera.VirtualCameraGameObject.GetComponent<CinemachineVirtualCamera>();
} }
if (shakeUpdate == null) { if(shakeUpdate == null){
shakeUpdate = new GameObject("ShakeUpdate").AddComponent<ScreenShakeUpdate>(); shakeUpdate = new GameObject("ShakeUpdate").AddComponent<ScreenShakeUpdate>();
} }
shakeUpdate.startingIntensity = intensity; shakeUpdate.startingIntensity = intensity;
shakeUpdate.shakeTimer = shakeUpdate.shakeTimerTotal = time; shakeUpdate.shakeTimer = shakeUpdate.shakeTimerTotal = time;
} }
}
} }

20
Tools/DialogueSystem/Dialogue.cs
View file

@ -1,16 +1,12 @@
using UnityEngine; using UnityEngine;
namespace SimpleTools.DialogueSystem { [CreateAssetMenu(fileName = "New Character", menuName = "Tools/Character", order = 0)]
[CreateAssetMenu(fileName = "New Dialogue", menuName = "Simple Tools/Dialogue", order = 11)] public class Dialogue : ScriptableObject{
public class Dialogue : ScriptableObject {
public DialogueBox[] sentences;
}
[System.Serializable] public bool displayName;
public class DialogueBox { public string characterName;
public bool displayName;
public string characterName; [Space]
public Sprite characterImage; public Sprite characterImage;
[TextArea(5, 10)] public string sentence; [TextArea] public string[] sentences;
}
} }

126
Tools/DialogueSystem/DialogueManager.cs
View file

@ -1,126 +0,0 @@
using System.Collections.Generic;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
namespace SimpleTools.DialogueSystem {
public class DialogueManager : MonoBehaviour {
DialogueVertexAnimator dialogueVertexAnimator;
Queue<string> sentences;
Queue<bool> displayNames;
Queue<string> characterNames;
Queue<Sprite> characterImages;
bool talking;
public DialogueManagerItems dialogueItems;
public static DialogueManager instance;
void Awake() {
instance = this;
sentences = new Queue<string>();
displayNames = new Queue<bool>();
characterNames = new Queue<string>();
characterImages = new Queue<Sprite>();
dialogueVertexAnimator = new DialogueVertexAnimator(dialogueItems.textBox);
}
/// <summary>
/// This is the main function to call to start a dialogue.
/// </summary>
/// <param name="dialogue">The dialogue to start.</param>
/// <returns>A bool that is false if the dialogue has finished and true if it hasn't.</returns>
public bool Dialogue(Dialogue dialogue) {
return Dialogue(dialogue, string.Empty);
}
/// <summary>
/// This is the main function to call to start a dialogue.
/// </summary>
/// <param name="dialogue">The dialogue to start.</param>
/// <param name="sounds">The sounds from the AudioManager that will be played on character reveal.</param>
/// <returns>A bool that is false if the dialogue has finished and true if it hasn't.</returns>
public bool Dialogue(Dialogue dialogue, params string[] sounds) {
dialogueVertexAnimator.SetAudioSourceGroup(sounds);
if (!talking) {
sentences.Clear();
if (dialogue.sentences.Length != 0) {
foreach (DialogueBox sentence in dialogue.sentences) {
sentences.Enqueue(sentence.sentence);
displayNames.Enqueue(sentence.displayName);
characterNames.Enqueue(sentence.characterName);
characterImages.Enqueue(sentence.characterImage);
}
} else {
sentences.Enqueue("I am error. No text has been added");
}
talking = true;
if (sentences.Count == 0) {
if (dialogueVertexAnimator.IsMessageAnimating())
return true;
talking = false;
return false;
}
string sentenceToShow = sentences.Peek();
bool displayName = displayNames.Peek();
string characterName = characterNames.Peek();
Sprite characterImage = characterImages.Peek();
if (PlayDialogue(sentenceToShow, displayName, characterName, characterImage)) {
sentences.Dequeue();
displayNames.Dequeue();
characterNames.Dequeue();
characterImages.Dequeue();
}
return true;
} else {
if (sentences.Count == 0) {
if (dialogueVertexAnimator.IsMessageAnimating())
return true;
talking = false;
return false;
}
string sentenceToShow = sentences.Peek();
bool displayName = displayNames.Peek();
string characterName = characterNames.Peek();
Sprite characterImage = characterImages.Peek();
if (PlayDialogue(sentenceToShow, displayName, characterName, characterImage)) {
sentences.Dequeue();
displayNames.Dequeue();
characterNames.Dequeue();
characterImages.Dequeue();
}
return true;
}
}
private Coroutine typeRoutine = null;
bool PlayDialogue(string message, bool displayName = false, string characterName = "", Sprite characterImage = null) {
if (dialogueVertexAnimator.IsMessageAnimating()) {
dialogueVertexAnimator.SkipToEndOfCurrentMessage();
return false; //Next message hasn't been shown because the current one is still animating.
}
this.EnsureCoroutineStopped(ref typeRoutine);
dialogueVertexAnimator.textAnimating = false;
List<DialogueCommand> commands = DialogueUtility.ProcessInputString(message, out string totalTextMessage);
typeRoutine = StartCoroutine(dialogueVertexAnimator.AnimateTextIn(commands, totalTextMessage, null));
dialogueItems.characterImage.sprite = characterImage;
dialogueItems.characterName.text = displayName ? characterName : "???";
return true; //Next message shown successfully
}
}
[System.Serializable]
public struct DialogueManagerItems {
public Image characterImage;
public TMP_Text characterName;
public TMP_Text textBox;
public Canvas canvas;
}
}

75
Tools/DialogueSystem/DialogueSystem.cs Normal file
View file

@ -0,0 +1,75 @@
using System.Collections.Generic;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
public class DialogueSystem : MonoBehaviour{
public static DialogueSystem instance;
public GameObject nameField = default;
public TextMeshProUGUI nameText = default;
public TMP_Animated dialogue = default;
public Image faceImage = default;
Queue<string> sentences;
bool talking;
Animator anim;
void Awake(){
instance = this;
sentences = new Queue<string>();
anim = GetComponent<Animator>();
}
/// <summary>Start or continue the dialogue
/// <para>This function returns false if the dialogue has ended.</para>
/// </summary>
public bool Dialogue(Dialogue dialogue){
if(!talking){
if (dialogue.displayName){
nameText.text = dialogue.characterName;
nameField.SetActive(true);
nameText.gameObject.SetActive(true);
}else{
nameField.SetActive(false);
nameText.gameObject.SetActive(false);
}
if (dialogue.characterImage)
faceImage.sprite = dialogue.characterImage;
else
faceImage.sprite = null;
sentences.Clear();
if(dialogue.sentences.Length != 0){
foreach (string sentence in dialogue.sentences){
sentences.Enqueue(sentence);
}
}else{
sentences.Enqueue("I am error. No text has been added");
}
talking = true;
if(sentences.Count == 0){
talking = false;
return false;
}
string sentenceToShow = sentences.Dequeue();
this.dialogue.ReadText(sentenceToShow);
anim.SetBool("Talking", true);
return true;
}else{
if (sentences.Count == 0){
talking = false;
anim.SetBool("Talking", false);
return false;
}
string sentenceToShow = sentences.Dequeue();
this.dialogue.ReadText(sentenceToShow);
return true;
}
}
}

2
Tools/DialogueSystem/DialogueVertexAnimator.cs.meta → Tools/DialogueSystem/DialogueSystem.cs.meta
View file

@ -1,5 +1,5 @@
fileFormatVersion: 2 fileFormatVersion: 2
guid: dcef7fafd8716284392e9621424bfa6a guid: caad12703fd5c3349acc637253734ac9
MonoImporter: MonoImporter:
externalObjects: {} externalObjects: {}
serializedVersion: 2 serializedVersion: 2

206
Tools/DialogueSystem/DialogueUtility.cs
View file

@ -1,206 +0,0 @@
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System;
namespace SimpleTools.DialogueSystem {
public class DialogueUtility : MonoBehaviour {
// grab the remainder of the text until ">" or end of string
const string REMAINDER_REGEX = "(.*?((?=>)|(/|$)))";
const string PAUSE_REGEX_STRING = "<p:(?<pause>" + REMAINDER_REGEX + ")>";
static readonly Regex pauseRegex = new Regex(PAUSE_REGEX_STRING);
const string SOUND_REGEX_STRING = "<snd:(?<sound>" + REMAINDER_REGEX + ")>";
static readonly Regex soundRegex = new Regex(SOUND_REGEX_STRING);
const string PLAYMUSIC_REGEX_STRING = "<playmsc:(?<playmusic>" + REMAINDER_REGEX + ")>";
static readonly Regex playMusicRegex = new Regex(PLAYMUSIC_REGEX_STRING);
const string STOPMUSIC_REGEX_STRING = "<stopmsc:(?<stopmusic>" + REMAINDER_REGEX + ")>";
static readonly Regex stopMusicRegex = new Regex(STOPMUSIC_REGEX_STRING);
const string SPEED_REGEX_STRING = "<sp:(?<speed>" + REMAINDER_REGEX + ")>";
static readonly Regex speedRegex = new Regex(SPEED_REGEX_STRING);
const string ANIM_START_REGEX_STRING = "<anim:(?<anim>" + REMAINDER_REGEX + ")>";
static readonly Regex animStartRegex = new Regex(ANIM_START_REGEX_STRING);
const string ANIM_END_REGEX_STRING = "</anim>";
static readonly Regex animEndRegex = new Regex(ANIM_END_REGEX_STRING);
static readonly Dictionary<string, float> pauseDictionary = new Dictionary<string, float>{
{ "tiny", .1f },
{ "short", .25f },
{ "normal", 0.666f },
{ "long", 1f },
{ "read", 2f },
};
public static List<DialogueCommand> ProcessInputString(string message, out string processedMessage) {
List<DialogueCommand> result = new List<DialogueCommand>();
processedMessage = message;
processedMessage = HandlePauseTags(processedMessage, result);
processedMessage = HandleSoundTags(processedMessage, result);
processedMessage = HandlePlayMusicTags(processedMessage, result);
processedMessage = HandleStopMusicTags(processedMessage, result);
processedMessage = HandleSpeedTags(processedMessage, result);
processedMessage = HandleAnimStartTags(processedMessage, result);
processedMessage = HandleAnimEndTags(processedMessage, result);
return result;
}
static string HandleAnimEndTags(string processedMessage, List<DialogueCommand> result) {
MatchCollection animEndMatches = animEndRegex.Matches(processedMessage);
foreach (Match match in animEndMatches) {
result.Add(new DialogueCommand {
position = VisibleCharactersUpToIndex(processedMessage, match.Index),
type = DialogueCommandType.AnimEnd,
});
}
processedMessage = Regex.Replace(processedMessage, ANIM_END_REGEX_STRING, "");
return processedMessage;
}
static string HandleAnimStartTags(string processedMessage, List<DialogueCommand> result) {
MatchCollection animStartMatches = animStartRegex.Matches(processedMessage);
foreach (Match match in animStartMatches) {
string stringVal = match.Groups["anim"].Value;
result.Add(new DialogueCommand {
position = VisibleCharactersUpToIndex(processedMessage, match.Index),
type = DialogueCommandType.AnimStart,
textAnimValue = GetTextAnimationType(stringVal)
});
}
processedMessage = Regex.Replace(processedMessage, ANIM_START_REGEX_STRING, "");
return processedMessage;
}
static string HandleSpeedTags(string processedMessage, List<DialogueCommand> result) {
MatchCollection speedMatches = speedRegex.Matches(processedMessage);
foreach (Match match in speedMatches) {
string stringVal = match.Groups["speed"].Value;
if (!float.TryParse(stringVal, out float val)) {
val = 150f;
}
result.Add(new DialogueCommand {
position = VisibleCharactersUpToIndex(processedMessage, match.Index),
type = DialogueCommandType.TextSpeedChange,
floatValue = val
});
}
processedMessage = Regex.Replace(processedMessage, SPEED_REGEX_STRING, "");
return processedMessage;
}
static string HandlePauseTags(string processedMessage, List<DialogueCommand> result) {
MatchCollection pauseMatches = pauseRegex.Matches(processedMessage);
foreach (Match match in pauseMatches) {
string val = match.Groups["pause"].Value;
string pauseName = val;
Debug.Assert(pauseDictionary.ContainsKey(pauseName), "no pause registered for '" + pauseName + "'");
result.Add(new DialogueCommand {
position = VisibleCharactersUpToIndex(processedMessage, match.Index),
type = DialogueCommandType.Pause,
floatValue = pauseDictionary[pauseName]
});
}
processedMessage = Regex.Replace(processedMessage, PAUSE_REGEX_STRING, "");
return processedMessage;
}
static string HandleSoundTags(string processedMessage, List<DialogueCommand> result) {
MatchCollection soundMatches = soundRegex.Matches(processedMessage);
foreach (Match match in soundMatches) {
string val = match.Groups["sound"].Value;
string soundName = val;
result.Add(new DialogueCommand {
position = VisibleCharactersUpToIndex(processedMessage, match.Index),
type = DialogueCommandType.Sound,
stringValue = soundName
});
}
processedMessage = Regex.Replace(processedMessage, SOUND_REGEX_STRING, "");
return processedMessage;
}
static string HandlePlayMusicTags(string processedMessage, List<DialogueCommand> result) {
MatchCollection playMatches = playMusicRegex.Matches(processedMessage);
foreach (Match match in playMatches) {
string val = match.Groups["playmusic"].Value;
string functionName = val;
result.Add(new DialogueCommand {
position = VisibleCharactersUpToIndex(processedMessage, match.Index),
type = DialogueCommandType.PlayMusic,
stringValue = functionName
});
}
processedMessage = Regex.Replace(processedMessage, PLAYMUSIC_REGEX_STRING, "");
return processedMessage;
}
static string HandleStopMusicTags(string processedMessage, List<DialogueCommand> result) {
MatchCollection stopMatches = stopMusicRegex.Matches(processedMessage);
foreach (Match match in stopMatches) {
string val = match.Groups["stopmusic"].Value;
string functionName = val;
result.Add(new DialogueCommand {
position = VisibleCharactersUpToIndex(processedMessage, match.Index),
type = DialogueCommandType.StopMusic,
stringValue = functionName
});
}
processedMessage = Regex.Replace(processedMessage, STOPMUSIC_REGEX_STRING, "");
return processedMessage;
}
static TextAnimationType GetTextAnimationType(string stringVal) {
TextAnimationType result;
try {
result = (TextAnimationType)Enum.Parse(typeof(TextAnimationType), stringVal, true);
} catch (ArgumentException) {
Debug.LogError("Invalid Text Animation Type: " + stringVal);
result = TextAnimationType.none;
}
return result;
}
static int VisibleCharactersUpToIndex(string message, int index) {
int result = 0;
bool insideBrackets = false;
for (int i = 0; i < index; i++) {
if (message[i] == '<') {
insideBrackets = true;
} else if (message[i] == '>') {
insideBrackets = false;
result--;
}
if (!insideBrackets) {
result++;
} else if (i + 6 < index && message.Substring(i, 6) == "sprite") {
result++;
}
}
return result;
}
}
public struct DialogueCommand {
public int position;
public DialogueCommandType type;
public float floatValue;
public string stringValue;
public TextAnimationType textAnimValue;
}
public enum DialogueCommandType {
Pause,
TextSpeedChange,
AnimStart,
AnimEnd,
Sound,
PlayMusic,
StopMusic
}
public enum TextAnimationType {
none,
shake,
wave,
wobble,
rainbow,
}
}

11
Tools/DialogueSystem/DialogueUtility.cs.meta
View file

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

277
Tools/DialogueSystem/DialogueVertexAnimator.cs
View file

@ -1,277 +0,0 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using TMPro;
using UnityEngine;
namespace SimpleTools.DialogueSystem {
public class DialogueVertexAnimator {
public bool textAnimating = false;
bool stopAnimating = false;
readonly TMP_Text textBox;
string[] audioSourceGroup;
public void SetAudioSourceGroup(params string[] _audioSourceGroup) {
audioSourceGroup = _audioSourceGroup;
}
public DialogueVertexAnimator(TMP_Text _textBox) {
textBox = _textBox;
}
static readonly Color32 clear = new Color32(0, 0, 0, 0);
const float CHAR_ANIM_TIME = 0.07f;
static readonly Vector3 vecZero = Vector3.zero;
public IEnumerator AnimateTextIn(List<DialogueCommand> commands, string processedMessage, Action onFinish) {
textAnimating = true;
float secondsPerCharacter = 1f / 150f;
float timeOfLastCharacter = 0;
TextAnimInfo[] textAnimInfo = SeparateOutTextAnimInfo(commands);
TMP_TextInfo textInfo = textBox.textInfo;
for (int i = 0; i < textInfo.meshInfo.Length; i++) {
TMP_MeshInfo meshInfer = textInfo.meshInfo[i];
if (meshInfer.vertices != null) {
for (int j = 0; j < meshInfer.vertices.Length; j++) {
meshInfer.vertices[j] = vecZero;
}
}
}
textBox.text = processedMessage;
textBox.ForceMeshUpdate();
TMP_MeshInfo[] cachedMeshInfo = textInfo.CopyMeshInfoVertexData();
Color32[][] originalColors = new Color32[textInfo.meshInfo.Length][];
for (int i = 0; i < originalColors.Length; i++) {
Color32[] theColors = textInfo.meshInfo[i].colors32;
originalColors[i] = new Color32[theColors.Length];
Array.Copy(theColors, originalColors[i], theColors.Length);
}
int charCount = textInfo.characterCount;
float[] charAnimStartTimes = new float[charCount];
for (int i = 0; i < charCount; i++) {
charAnimStartTimes[i] = -1;
}
int visableCharacterIndex = 0;
while (true) {
if (stopAnimating) {
for (int i = visableCharacterIndex; i < charCount; i++) {
charAnimStartTimes[i] = Time.unscaledTime;
}
visableCharacterIndex = charCount;
FinishAnimating(onFinish);
}
if (ShouldShowNextCharacter(secondsPerCharacter, timeOfLastCharacter)) {
if (visableCharacterIndex <= charCount) {
ExecuteCommandsForCurrentIndex(commands, visableCharacterIndex, ref secondsPerCharacter, ref timeOfLastCharacter);
if (visableCharacterIndex < charCount && ShouldShowNextCharacter(secondsPerCharacter, timeOfLastCharacter)) {
charAnimStartTimes[visableCharacterIndex] = Time.unscaledTime;
PlayDialogueSound();
visableCharacterIndex++;
timeOfLastCharacter = Time.unscaledTime;
if (visableCharacterIndex == charCount) {
FinishAnimating(onFinish);
}
}
}
}
for (int j = 0; j < charCount; j++) {
TMP_CharacterInfo charInfo = textInfo.characterInfo[j];
if (charInfo.isVisible) {
int vertexIndex = charInfo.vertexIndex;
int materialIndex = charInfo.materialReferenceIndex;
Color32[] destinationColors = textInfo.meshInfo[materialIndex].colors32;
Color32 theColor = j < visableCharacterIndex ? originalColors[materialIndex][vertexIndex] : clear;
destinationColors[vertexIndex + 0] = theColor;
destinationColors[vertexIndex + 1] = theColor;
destinationColors[vertexIndex + 2] = theColor;
destinationColors[vertexIndex + 3] = theColor;
Vector3[] sourceVertices = cachedMeshInfo[materialIndex].vertices;
Vector3[] destinationVertices = textInfo.meshInfo[materialIndex].vertices;
float charSize = 0;
float charAnimStartTime = charAnimStartTimes[j];
if (charAnimStartTime >= 0) {
float timeSinceAnimStart = Time.unscaledTime - charAnimStartTime;
charSize = Mathf.Min(1, timeSinceAnimStart / CHAR_ANIM_TIME);
}
Vector3 animPosAdjustment = GetAnimPosAdjustment(textAnimInfo, j, textBox.fontSize, Time.unscaledTime);
Vector3 offset = (sourceVertices[vertexIndex + 0] + sourceVertices[vertexIndex + 2]) / 2;
destinationVertices[vertexIndex + 0] = ((sourceVertices[vertexIndex + 0] - offset) * charSize) + offset + animPosAdjustment;
destinationVertices[vertexIndex + 1] = ((sourceVertices[vertexIndex + 1] - offset) * charSize) + offset + animPosAdjustment;
destinationVertices[vertexIndex + 2] = ((sourceVertices[vertexIndex + 2] - offset) * charSize) + offset + animPosAdjustment;
destinationVertices[vertexIndex + 3] = ((sourceVertices[vertexIndex + 3] - offset) * charSize) + offset + animPosAdjustment;
for (int i = 0; i < 4; i++) {
Vector3 animVertexAdjustment = GetAnimVertexAdjustment(textAnimInfo, j, textBox.fontSize, Time.unscaledTime + i);
destinationVertices[vertexIndex + i] += animVertexAdjustment;
Color animColorAdjustment = GetAnimColorAdjustment(textAnimInfo, j, Time.unscaledTime + i, destinationVertices[vertexIndex + i]);
if (animColorAdjustment == Color.white)
continue;
destinationColors[vertexIndex + i] += animColorAdjustment;
}
}
}
textBox.UpdateVertexData(TMP_VertexDataUpdateFlags.Colors32);
for (int i = 0; i < textInfo.meshInfo.Length; i++) {
TMP_MeshInfo theInfo = textInfo.meshInfo[i];
theInfo.mesh.vertices = theInfo.vertices;
textBox.UpdateGeometry(theInfo.mesh, i);
}
yield return null;
}
}
void ExecuteCommandsForCurrentIndex(List<DialogueCommand> commands, int visableCharacterIndex, ref float secondsPerCharacter, ref float timeOfLastCharacter) {
for (int i = 0; i < commands.Count; i++) {
DialogueCommand command = commands[i];
if (command.position == visableCharacterIndex) {
switch (command.type) {
case DialogueCommandType.Pause:
timeOfLastCharacter = Time.unscaledTime + command.floatValue;
break;
case DialogueCommandType.TextSpeedChange:
secondsPerCharacter = 1f / command.floatValue;
break;
case DialogueCommandType.Sound:
AudioManager.AudioManager.instance.PlayOneShot(command.stringValue);
break;
case DialogueCommandType.PlayMusic:
string[] split0 = command.stringValue.Split(',');
AudioManager.AudioManager.instance.FadeIn(split0[0], float.Parse(split0[1], CultureInfo.InvariantCulture));
break;
case DialogueCommandType.StopMusic:
string[] split1 = command.stringValue.Split(',');
for (int j = 0; j < split1.Length; j++) {
Debug.Log(split1[j]);
}
AudioManager.AudioManager.instance.FadeOut(split1[0], float.Parse(split1[1], CultureInfo.InvariantCulture));
break;
}
commands.RemoveAt(i);
i--;
}
}
}
void FinishAnimating(Action onFinish) {
textAnimating = false;
stopAnimating = false;
onFinish?.Invoke();
}
const float NOISE_MAGNITUDE_ADJUSTMENT = 0.06f;
const float NOISE_FREQUENCY_ADJUSTMENT = 15f;
const float WAVE_MAGNITUDE_ADJUSTMENT = 0.06f;
const float WOBBLE_MAGNITUDE_ADJUSTMENT = 0.5f;
const float RAINBOW_LENGTH_ADJUSTMENT = .001f;
Vector3 GetAnimPosAdjustment(TextAnimInfo[] textAnimInfo, int charIndex, float fontSize, float time) {
float x = 0;
float y = 0;
for (int i = 0; i < textAnimInfo.Length; i++) {
TextAnimInfo info = textAnimInfo[i];
if (charIndex >= info.startIndex && charIndex < info.endIndex) {
if (info.type == TextAnimationType.shake) {
float scaleAdjust = fontSize * NOISE_MAGNITUDE_ADJUSTMENT;
x += (Mathf.PerlinNoise((charIndex + time) * NOISE_FREQUENCY_ADJUSTMENT, 0) - 0.5f) * scaleAdjust;
y += (Mathf.PerlinNoise((charIndex + time) * NOISE_FREQUENCY_ADJUSTMENT, 1000) - 0.5f) * scaleAdjust;
} else if (info.type == TextAnimationType.wave) {
y += Mathf.Sin((charIndex * 1.5f) + (time * 6)) * fontSize * WAVE_MAGNITUDE_ADJUSTMENT;
}
}
}
return new Vector3(x, y, 0);
}
Vector3 GetAnimVertexAdjustment(TextAnimInfo[] textAnimInfo, int charIndex, float fontSize, float time) {
float x = 0;
float y = 0;
for (int i = 0; i < textAnimInfo.Length; i++) {
TextAnimInfo info = textAnimInfo[i];
if (charIndex >= info.startIndex && charIndex < info.endIndex) {
if (info.type == TextAnimationType.wobble) {
float scaleAdjust = fontSize * NOISE_MAGNITUDE_ADJUSTMENT;
x = Mathf.Sin(time * 3.3f) * scaleAdjust * WOBBLE_MAGNITUDE_ADJUSTMENT;
y = Mathf.Cos(time * 2.5f) * scaleAdjust * WOBBLE_MAGNITUDE_ADJUSTMENT;
}
}
}
return new Vector3(x, y, 0);
}
Color GetAnimColorAdjustment(TextAnimInfo[] textAnimInfo, int charIndex, float time, Vector3 destinationVertice) {
Color color = Color.white;
for (int i = 0; i < textAnimInfo.Length; i++) {
TextAnimInfo info = textAnimInfo[i];
if (charIndex >= info.startIndex && charIndex < info.endIndex) {
if (info.type == TextAnimationType.rainbow) {
color = Color.HSVToRGB(Mathf.Repeat((time + destinationVertice.x * RAINBOW_LENGTH_ADJUSTMENT), 1f), .75f, 1);
}
}
}
return color;
}
static bool ShouldShowNextCharacter(float secondsPerCharacter, float timeOfLastCharacter) {
return (Time.unscaledTime - timeOfLastCharacter) > secondsPerCharacter;
}
public void SkipToEndOfCurrentMessage() {
if (textAnimating) {
stopAnimating = true;
}
}
public bool IsMessageAnimating() {
return textAnimating;
}
float timeUntilNextDialogueSound = 0;
float lastDialogueSound = 0;
void PlayDialogueSound() {
if (Time.unscaledTime - lastDialogueSound > timeUntilNextDialogueSound) {
timeUntilNextDialogueSound = UnityEngine.Random.Range(0.02f, 0.08f);
lastDialogueSound = Time.unscaledTime;
if (audioSourceGroup[0] != string.Empty)
AudioManager.AudioManager.instance.PlayRandomSound(audioSourceGroup);
}
}
TextAnimInfo[] SeparateOutTextAnimInfo(List<DialogueCommand> commands) {
List<TextAnimInfo> tempResult = new List<TextAnimInfo>();
List<DialogueCommand> animStartCommands = new List<DialogueCommand>();
List<DialogueCommand> animEndCommands = new List<DialogueCommand>();
for (int i = 0; i < commands.Count; i++) {
DialogueCommand command = commands[i];
if (command.type == DialogueCommandType.AnimStart) {
animStartCommands.Add(command);
commands.RemoveAt(i);
i--;
} else if (command.type == DialogueCommandType.AnimEnd) {
animEndCommands.Add(command);
commands.RemoveAt(i);
i--;
}
}
if (animStartCommands.Count != animEndCommands.Count) {
Debug.LogError("Unequal number of start and end animation commands. Start Commands: " + animStartCommands.Count + " End Commands: " + animEndCommands.Count);
} else {
for (int i = 0; i < animStartCommands.Count; i++) {
DialogueCommand startCommand = animStartCommands[i];
DialogueCommand endCommand = animEndCommands[i];
tempResult.Add(new TextAnimInfo {
startIndex = startCommand.position,
endIndex = endCommand.position,
type = startCommand.textAnimValue
});
}
}
return tempResult.ToArray();
}
}
public struct TextAnimInfo {
public int startIndex;
public int endIndex;
public TextAnimationType type;
}
}

71
Tools/DialogueSystem/TMP_Animated.cs Normal file
View file

@ -0,0 +1,71 @@
using System.Collections;
using UnityEngine;
using UnityEngine.Events;
namespace TMPro{
[System.Serializable] public class TextRevealEvent : UnityEvent<char> { }
[System.Serializable] public class DialogueEvent : UnityEvent { }
public class TMP_Animated : TextMeshProUGUI{
float speed;
public TextRevealEvent onTextReveal;
public DialogueEvent onDialogueFinish;
public void ReadText(string newText){
text = string.Empty;
string[] subTexts = newText.Split('<', '>');
string displayText = "";
for (int i = 0; i < subTexts.Length; i++){
if (i % 2 == 0)
displayText += subTexts[i];
else if (!isCustomTag(subTexts[i].Replace(" ", "")))
displayText += $"<{subTexts[i]}>";
}
bool isCustomTag(string tag){
return tag.StartsWith("speed=") || tag.StartsWith("pause=");
}
text = displayText;
maxVisibleCharacters = 0;
StartCoroutine(Read());
IEnumerator Read(){
int subCounter = 0;
int visibleCounter = 0;
while(subCounter < subTexts.Length){
if(subCounter % 2 == 1){
yield return EvaluateTag(subTexts[subCounter].Replace(" ", ""));
}else{
while(visibleCounter < subTexts[subCounter].Length){
onTextReveal.Invoke(subTexts[subCounter][visibleCounter]);
visibleCounter++;
maxVisibleCharacters++;
yield return new WaitForSeconds(1f / speed);
}
visibleCounter = 0;
}
subCounter++;
}
yield return null;
WaitForSeconds EvaluateTag(string tag){
if (tag.Length > 0){
if (tag.StartsWith("speed=")){
speed = float.Parse(tag.Split('=')[1]);
}else if (tag.StartsWith("pause=")){
return new WaitForSeconds(float.Parse(tag.Split('=')[1]));
}
}
return null;
}
onDialogueFinish.Invoke();
}
}
}
}

4
Tools/DialogueSystem/DialogueManager.cs.meta → Tools/DialogueSystem/TMP_Animated.cs.meta
View file

@ -1,11 +1,11 @@
fileFormatVersion: 2 fileFormatVersion: 2
guid: 23d6a059fd2bc464a9cba3a5ced1724d guid: f713d84a3ae882945800780459e26170
MonoImporter: MonoImporter:
externalObjects: {} externalObjects: {}
serializedVersion: 2 serializedVersion: 2
defaultReferences: [] defaultReferences: []
executionOrder: 0 executionOrder: 0
icon: {instanceID: 0} icon: {fileID: 2800000, guid: 2fd6421f253b4ef1a19526541f9ffc0c, type: 3}
userData: userData:
assetBundleName: assetBundleName:
assetBundleVariant: assetBundleVariant:

867
Tools/Editor/ToolsEditor.cs
View file

@ -1,4 +1,3 @@
#if UNITY_EDITOR
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using UnityEngine; using UnityEngine;
@ -11,538 +10,524 @@ using UnityEditor.SceneManagement;
using UnityEngine.EventSystems; using UnityEngine.EventSystems;
using UnityEditor.Experimental.SceneManagement; using UnityEditor.Experimental.SceneManagement;
using System; using System;
using SimpleTools.AudioManager;
using SimpleTools.DialogueSystem;
using SimpleTools.Cinemachine;
using SimpleTools.SceneManagement;
using SimpleTools.Menu;
public class ToolsEditor{ public class ToolsEditor{
[MenuItem("GameObject/Simple Tools/AudioManager", false, 10)] [MenuItem("GameObject/Tools/AudioManager", false, 10)]
static void CreateAudioManager(){ static void CreateAudioManager(){
GameObject audioManager = new GameObject("AudioManager"); GameObject audioManager = new GameObject("AudioManager");
audioManager.AddComponent<AudioManager>(); audioManager.AddComponent<AudioManager>();
} }
[MenuItem("GameObject/Simple Tools/Dialogue System", false, 10)] [MenuItem("GameObject/Tools/Dialogue System", false, 10)]
static void CreateDialogueSystem(){ static void CreateDialogueSystem(){
GameObject dialogueCanvas = new GameObject("DialogueCanvas"); GameObject dialogueCanvas = new GameObject("DialogueCanvas");
dialogueCanvas.AddComponent<RectTransform>(); dialogueCanvas.AddComponent<RectTransform>();
Canvas canvas = dialogueCanvas.AddComponent<Canvas>(); Canvas canvas = dialogueCanvas.AddComponent<Canvas>();
canvas.renderMode = RenderMode.ScreenSpaceOverlay; canvas.renderMode = RenderMode.ScreenSpaceOverlay;
dialogueCanvas.AddComponent<CanvasScaler>(); dialogueCanvas.AddComponent<CanvasScaler>();
dialogueCanvas.AddComponent<GraphicRaycaster>(); dialogueCanvas.AddComponent<GraphicRaycaster>();
GameObject text = new GameObject("DialogueText"); GameObject text = new GameObject("TMP_Animated");
text.transform.SetParent(dialogueCanvas.transform); text.transform.SetParent(dialogueCanvas.transform);
text.AddComponent<TextMeshProUGUI>().text = "Dialogue"; text.AddComponent<TMP_Animated>().text = "New Text";
text.GetComponent<RectTransform>().anchoredPosition = Vector2.zero; text.GetComponent<RectTransform>().anchoredPosition = Vector2.zero;
GameObject name = new GameObject("NameText"); GameObject name = new GameObject("NameText");
name.transform.SetParent(dialogueCanvas.transform); name.transform.SetParent(dialogueCanvas.transform);
name.AddComponent<TextMeshProUGUI>().text = "Name"; name.AddComponent<TextMeshProUGUI>().text = "Name";
name.GetComponent<RectTransform>().anchoredPosition = Vector2.up * 50f; name.GetComponent<RectTransform>().anchoredPosition = Vector2.up * 50f;
GameObject image = new GameObject("Image"); GameObject image = new GameObject("Image");
image.transform.SetParent(dialogueCanvas.transform); image.transform.SetParent(dialogueCanvas.transform);
image.AddComponent<Image>(); image.AddComponent<Image>();
image.GetComponent<RectTransform>().anchoredPosition = new Vector2(-150f, 25f); image.GetComponent<RectTransform>().anchoredPosition = new Vector2(-150f, 25f);
DialogueManager dialogueManager = dialogueCanvas.AddComponent<DialogueManager>(); DialogueSystem dialogueSystem = dialogueCanvas.AddComponent<DialogueSystem>();
Debug.Log(dialogueManager.dialogueItems); dialogueSystem.nameText = name.GetComponent<TextMeshProUGUI>();
dialogueManager.dialogueItems.textBox = text.GetComponent<TextMeshProUGUI>(); dialogueSystem.dialogue = text.GetComponent<TMP_Animated>();
dialogueManager.dialogueItems.characterName = name.GetComponent<TextMeshProUGUI>(); dialogueSystem.faceImage = image.GetComponent<Image>();
dialogueManager.dialogueItems.characterImage = image.GetComponent<Image>(); dialogueSystem.nameField = name;
dialogueManager.dialogueItems.canvas = canvas; }
//DialogueSystem dialogueSystem = dialogueCanvas.AddComponent<DialogueSystem>();
//dialogueSystem.nameText = name.GetComponent<TextMeshProUGUI>();
//dialogueSystem.dialogue = text.GetComponent<TMP_Animated>();
//dialogueSystem.faceImage = image.GetComponent<Image>();
//dialogueSystem.nameField = name;
}
[MenuItem("GameObject/Simple Tools/Camera Trigger/2D", false, 10)] [MenuItem("GameObject/Tools/Camera Trigger/2D", false, 10)]
static void CreateCameraTrigger2D(){ static void CreateCameraTrigger2D(){
GameObject cameraTrigger = new GameObject("CameraTrigger2D"); GameObject cameraTrigger = new GameObject("CameraTrigger2D");
cameraTrigger.AddComponent<BoxCollider2D>(); cameraTrigger.AddComponent<BoxCollider2D>();
cameraTrigger.AddComponent<CMCameraTrigger>(); cameraTrigger.AddComponent<CMCameraTrigger>();
GameObject vCam = new GameObject("CM vcam1"); GameObject vCam = new GameObject("CM vcam1");
vCam.transform.SetParent(cameraTrigger.transform); vCam.transform.SetParent(cameraTrigger.transform);
vCam.SetActive(false); vCam.SetActive(false);
CinemachineVirtualCamera cam = vCam.AddComponent<CinemachineVirtualCamera>(); CinemachineVirtualCamera cam = vCam.AddComponent<CinemachineVirtualCamera>();
cam.m_Lens.Orthographic = true; cam.m_Lens.Orthographic = true;
} }
[MenuItem("GameObject/Simple Tools/Camera Trigger/3D", false, 10)] [MenuItem("GameObject/Tools/Camera Trigger/3D", false, 10)]
static void CreateCameraTrigger3D(){ static void CreateCameraTrigger3D(){
GameObject cameraTrigger = new GameObject("CameraTrigger3D"); GameObject cameraTrigger = new GameObject("CameraTrigger3D");
cameraTrigger.AddComponent<BoxCollider>(); cameraTrigger.AddComponent<BoxCollider>();
cameraTrigger.AddComponent<CMCameraTrigger>(); cameraTrigger.AddComponent<CMCameraTrigger>();
GameObject vCam = new GameObject("CM vcam1"); GameObject vCam = new GameObject("CM vcam1");
vCam.transform.SetParent(cameraTrigger.transform); vCam.transform.SetParent(cameraTrigger.transform);
vCam.SetActive(false); vCam.SetActive(false);
CinemachineVirtualCamera cam = vCam.AddComponent<CinemachineVirtualCamera>(); CinemachineVirtualCamera cam = vCam.AddComponent<CinemachineVirtualCamera>();
cam.m_Lens.FieldOfView = 60f; cam.m_Lens.FieldOfView = 60f;
} }
#if CINEMACHINE_271_OR_NEWER #if CINEMACHINE_271_OR_NEWER
[MenuItem("GameObject/Simple Tools/ScreenShake Camera/2D", false, 10)] [MenuItem("GameObject/Tools/ScreenShake Camera/2D", false, 10)]
static void CreateScreenShakeCamera2d(){ static void CreateScreenShakeCamera2d(){
GameObject screenShakeCamera = new GameObject("ScreenShakeCamera"); GameObject screenShakeCamera = new GameObject("ScreenShakeCamera");
CinemachineVirtualCamera vCam = screenShakeCamera.AddComponent<CinemachineVirtualCamera>(); CinemachineVirtualCamera vCam = screenShakeCamera.AddComponent<CinemachineVirtualCamera>();
vCam.m_Lens.ModeOverride = LensSettings.OverrideModes.Orthographic; vCam.m_Lens.ModeOverride = LensSettings.OverrideModes.Orthographic;
CinemachineBasicMultiChannelPerlin shake = vCam.AddCinemachineComponent<CinemachineBasicMultiChannelPerlin>(); CinemachineBasicMultiChannelPerlin shake = vCam.AddCinemachineComponent<CinemachineBasicMultiChannelPerlin>();
NoiseSettings noise = (NoiseSettings)AssetDatabase.LoadAssetAtPath("Packages/com.unity.cinemachine/Presets/Noise/6D Shake.asset", typeof(NoiseSettings)); NoiseSettings noise = (NoiseSettings)AssetDatabase.LoadAssetAtPath("Packages/com.unity.cinemachine/Presets/Noise/6D Shake.asset", typeof(NoiseSettings));
shake.m_NoiseProfile = noise; shake.m_NoiseProfile = noise;
shake.m_AmplitudeGain = 0f; shake.m_AmplitudeGain = 0f;
shake.m_FrequencyGain = 1f; shake.m_FrequencyGain = 1f;
} }
[MenuItem("GameObject/Simple Tools/ScreenShake Camera/3D", false, 10)] [MenuItem("GameObject/Tools/ScreenShake Camera/3D", false, 10)]
static void CreateScreenShakeCamera3d(){ static void CreateScreenShakeCamera3d(){
GameObject screenShakeCamera = new GameObject("ScreenShakeCamera"); GameObject screenShakeCamera = new GameObject("ScreenShakeCamera");
CinemachineVirtualCamera vCam = screenShakeCamera.AddComponent<CinemachineVirtualCamera>(); CinemachineVirtualCamera vCam = screenShakeCamera.AddComponent<CinemachineVirtualCamera>();
vCam.m_Lens.ModeOverride = LensSettings.OverrideModes.Perspective; vCam.m_Lens.ModeOverride = LensSettings.OverrideModes.Perspective;
CinemachineBasicMultiChannelPerlin shake = vCam.AddCinemachineComponent<CinemachineBasicMultiChannelPerlin>(); CinemachineBasicMultiChannelPerlin shake = vCam.AddCinemachineComponent<CinemachineBasicMultiChannelPerlin>();
NoiseSettings noise = (NoiseSettings)AssetDatabase.LoadAssetAtPath("Packages/com.unity.cinemachine/Presets/Noise/6D Shake.asset", typeof(NoiseSettings)); NoiseSettings noise = (NoiseSettings)AssetDatabase.LoadAssetAtPath("Packages/com.unity.cinemachine/Presets/Noise/6D Shake.asset", typeof(NoiseSettings));
shake.m_NoiseProfile = noise; shake.m_NoiseProfile = noise;
shake.m_AmplitudeGain = 0f; shake.m_AmplitudeGain = 0f;
shake.m_FrequencyGain = 1f; shake.m_FrequencyGain = 1f;
} }
#else #else
[MenuItem("GameObject/Simple Tools/ScreenShake Camera", false, 10)] [MenuItem("GameObject/Tools/ScreenShake Camera", false, 10)]
static void CreateScreenShakeCamera2d(){ static void CreateScreenShakeCamera2d(){
GameObject screenShakeCamera = new GameObject("ScreenShakeCamera"); GameObject screenShakeCamera = new GameObject("ScreenShakeCamera");
CinemachineVirtualCamera vCam = screenShakeCamera.AddComponent<CinemachineVirtualCamera>(); CinemachineVirtualCamera vCam = screenShakeCamera.AddComponent<CinemachineVirtualCamera>();
CinemachineBasicMultiChannelPerlin shake = vCam.AddCinemachineComponent<CinemachineBasicMultiChannelPerlin>(); CinemachineBasicMultiChannelPerlin shake = vCam.AddCinemachineComponent<CinemachineBasicMultiChannelPerlin>();
NoiseSettings noise = (NoiseSettings)AssetDatabase.LoadAssetAtPath("Packages/com.unity.cinemachine/Presets/Noise/6D Shake.asset", typeof(NoiseSettings)); NoiseSettings noise = (NoiseSettings)AssetDatabase.LoadAssetAtPath("Packages/com.unity.cinemachine/Presets/Noise/6D Shake.asset", typeof(NoiseSettings));
shake.m_NoiseProfile = noise; shake.m_NoiseProfile = noise;
shake.m_AmplitudeGain = 0f; shake.m_AmplitudeGain = 0f;
shake.m_FrequencyGain = 1f; shake.m_FrequencyGain = 1f;
} }
#endif #endif
[MenuItem("Assets/Create/Simple Tools/Create Loading Scene")] [MenuItem("Assets/Create/Tools/Create Loading Scene")]
[MenuItem("Simple Tools/Create Loading Scene")] static void CreateLoadingScene(){
static void CreateLoadingScene(){ EditorSceneManager.SaveOpenScenes();
EditorSceneManager.SaveOpenScenes();
Scene loadingScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects); Scene loadingScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects);
loadingScene.name = "Loading"; loadingScene.name = "Loading";
GameObject loaderCallback = new GameObject("LoaderCallback"); GameObject loaderCallback = new GameObject("LoaderCallback");
loaderCallback.AddComponent<LoaderCallback>(); loaderCallback.AddComponent<LoaderCallback>();
GameObject canvasObj = new GameObject("Canvas"); GameObject canvasObj = new GameObject("Canvas");
Canvas canvas = canvasObj.AddComponent<Canvas>(); Canvas canvas = canvasObj.AddComponent<Canvas>();
canvas.renderMode = RenderMode.ScreenSpaceOverlay; canvas.renderMode = RenderMode.ScreenSpaceOverlay;
CanvasScaler canvasScaler = canvasObj.AddComponent<CanvasScaler>(); CanvasScaler canvasScaler = canvasObj.AddComponent<CanvasScaler>();
canvasScaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize; canvasScaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
canvasScaler.referenceResolution = new Vector2Int(951, 535); canvasScaler.referenceResolution = new Vector2Int(951, 535);
canvasScaler.matchWidthOrHeight = 1f; canvasScaler.matchWidthOrHeight = 1f;
canvasObj.AddComponent<GraphicRaycaster>(); canvasObj.AddComponent<GraphicRaycaster>();
TextMeshProUGUI loadingText = new GameObject("LoadingText").AddComponent<TextMeshProUGUI>(); TextMeshProUGUI loadingText = new GameObject("LoadingText").AddComponent<TextMeshProUGUI>();
loadingText.transform.SetParent(canvasObj.transform); loadingText.transform.SetParent(canvasObj.transform);
RectTransform loadingTextTransform = loadingText.GetComponent<RectTransform>(); RectTransform loadingTextTransform = loadingText.GetComponent<RectTransform>();
loadingTextTransform.anchoredPosition = new Vector2Int(-333, -212); loadingTextTransform.anchoredPosition = new Vector2Int(-333, -212);
loadingTextTransform.sizeDelta = new Vector2Int(237, 52); loadingTextTransform.sizeDelta = new Vector2Int(237, 52);
loadingText.text = "LOADING..."; loadingText.text = "LOADING...";
Image bg = new GameObject("bg").AddComponent<Image>(); Image bg = new GameObject("bg").AddComponent<Image>();
bg.transform.SetParent(canvasObj.transform); bg.transform.SetParent(canvasObj.transform);
RectTransform bgTransform = bg.GetComponent<RectTransform>(); RectTransform bgTransform = bg.GetComponent<RectTransform>();
bgTransform.anchoredPosition = new Vector2Int(0, -235); bgTransform.anchoredPosition = new Vector2Int(0, -235);
bgTransform.sizeDelta = new Vector2Int(900, 20); bgTransform.sizeDelta = new Vector2Int(900, 20);
bg.color = new Color(36f / 255f, 36f / 255f, 36f / 255f); bg.color = new Color(36f / 255f, 36f / 255f, 36f / 255f);
Image progressBar = new GameObject("ProgressBar").AddComponent<Image>(); Image progressBar = new GameObject("ProgressBar").AddComponent<Image>();
progressBar.transform.SetParent(bg.transform); progressBar.transform.SetParent(bg.transform);
RectTransform progressBarTransform = progressBar.GetComponent<RectTransform>(); RectTransform progressBarTransform = progressBar.GetComponent<RectTransform>();
progressBarTransform.anchoredPosition = Vector2.zero; progressBarTransform.anchoredPosition = Vector2.zero;
progressBarTransform.sizeDelta = new Vector2Int(900, 20); progressBarTransform.sizeDelta = new Vector2Int(900, 20);
progressBar.sprite = (Sprite)AssetDatabase.LoadAssetAtPath("Packages/com.geri.simpletools/Simple Tools/Editor/Square.png", typeof(Sprite)); progressBar.sprite = (Sprite)AssetDatabase.LoadAssetAtPath("Packages/com.geri.simpletools/Tools/Editor/Square.png", typeof(Sprite));
progressBar.type = Image.Type.Filled; progressBar.type = Image.Type.Filled;
progressBar.fillMethod = Image.FillMethod.Horizontal; progressBar.fillMethod = Image.FillMethod.Horizontal;
progressBar.fillOrigin = (int)Image.OriginHorizontal.Left; progressBar.fillOrigin = (int)Image.OriginHorizontal.Left;
progressBar.fillAmount = 1f; progressBar.fillAmount = 1f;
progressBar.gameObject.AddComponent<LoadingProgressBar>(); progressBar.gameObject.AddComponent<LoadingProgressBar>();
} }
#if UNITY_2019_3_OR_NEWER #if UNITY_2019_3_OR_NEWER
[MenuItem("Assets/Create/Simple Tools/Create Menu Scene")] [MenuItem("Assets/Create/Tools/Create Menu Scene")]
[MenuItem("Simple Tools/Create Menu Scene")] static void CreateMenuScene(){
static void CreateMenuScene(){ EditorSceneManager.SaveOpenScenes();
EditorSceneManager.SaveOpenScenes();
Scene menuScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects); Scene menuScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects);
menuScene.name = "Menu"; menuScene.name = "Menu";
GameObject canvasObj = new GameObject("Canvas"); GameObject canvasObj = new GameObject("Canvas");
Canvas canvas = canvasObj.AddComponent<Canvas>(); Canvas canvas = canvasObj.AddComponent<Canvas>();
canvas.renderMode = RenderMode.ScreenSpaceOverlay; canvas.renderMode = RenderMode.ScreenSpaceOverlay;
CreateEventSystem(false, null); CreateEventSystem(false, null);
CanvasScaler canvasScaler = canvasObj.AddComponent<CanvasScaler>(); CanvasScaler canvasScaler = canvasObj.AddComponent<CanvasScaler>();
canvasScaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize; canvasScaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
canvasScaler.referenceResolution = new Vector2Int(951, 535); canvasScaler.referenceResolution = new Vector2Int(951, 535);
canvasScaler.matchWidthOrHeight = 1f; canvasScaler.matchWidthOrHeight = 1f;
canvasObj.AddComponent<GraphicRaycaster>(); canvasObj.AddComponent<GraphicRaycaster>();
GameObject qualityDropdown = TMP_DefaultControls.CreateDropdown(GetStandardResources()); GameObject qualityDropdown = TMP_DefaultControls.CreateDropdown(GetStandardResources());
qualityDropdown.transform.SetParent(canvasObj.transform); qualityDropdown.transform.SetParent(canvasObj.transform);
RectTransform qualityRectTransform = qualityDropdown.GetComponent<RectTransform>(); RectTransform qualityRectTransform = qualityDropdown.GetComponent<RectTransform>();
qualityRectTransform.anchoredPosition = Vector2.up * 15f; qualityRectTransform.anchoredPosition = Vector2.up * 15f;
qualityDropdown.name = "QualityDropdown"; qualityDropdown.name = "QualityDropdown";
GameObject resolutionDropdown = TMP_DefaultControls.CreateDropdown(GetStandardResources()); GameObject resolutionDropdown = TMP_DefaultControls.CreateDropdown(GetStandardResources());
resolutionDropdown.transform.SetParent(canvasObj.transform); resolutionDropdown.transform.SetParent(canvasObj.transform);
RectTransform resolutionRectTransform = resolutionDropdown.GetComponent<RectTransform>(); RectTransform resolutionRectTransform = resolutionDropdown.GetComponent<RectTransform>();
resolutionRectTransform.anchoredPosition = Vector2.down * 15f; resolutionRectTransform.anchoredPosition = Vector2.down * 15f;
resolutionDropdown.name = "ResolutionDropdown"; resolutionDropdown.name = "ResolutionDropdown";
GameObject musicSlider; GameObject musicSlider;
using (new FactorySwapToEditor()) using (new FactorySwapToEditor())
musicSlider = DefaultControls.CreateSlider(GetStandardUIResources()); musicSlider = DefaultControls.CreateSlider(GetStandardUIResources());
musicSlider.transform.SetParent(canvasObj.transform); musicSlider.transform.SetParent(canvasObj.transform);
RectTransform musicRectTransform = musicSlider.GetComponent<RectTransform>(); RectTransform musicRectTransform = musicSlider.GetComponent<RectTransform>();
musicRectTransform.anchoredPosition = Vector2.down * 40f; musicRectTransform.anchoredPosition = Vector2.down * 40f;
musicSlider.name = "MusicSlider"; musicSlider.name = "MusicSlider";
GameObject sfxSlider; GameObject sfxSlider;
using (new FactorySwapToEditor()) using (new FactorySwapToEditor())
sfxSlider = DefaultControls.CreateSlider(GetStandardUIResources()); sfxSlider = DefaultControls.CreateSlider(GetStandardUIResources());
sfxSlider.transform.SetParent(canvasObj.transform); sfxSlider.transform.SetParent(canvasObj.transform);
RectTransform sfxRectTransform = sfxSlider.GetComponent<RectTransform>(); RectTransform sfxRectTransform = sfxSlider.GetComponent<RectTransform>();
sfxRectTransform.anchoredPosition = Vector2.down * 60; sfxRectTransform.anchoredPosition = Vector2.down * 60;
sfxSlider.name = "MusicSlider"; sfxSlider.name = "MusicSlider";
GameObject playButton = TMP_DefaultControls.CreateButton(GetStandardResources()); GameObject playButton = TMP_DefaultControls.CreateButton(GetStandardResources());
playButton.transform.SetParent(canvasObj.transform); playButton.transform.SetParent(canvasObj.transform);
TMP_Text playTextComponent = playButton.GetComponentInChildren<TMP_Text>(); TMP_Text playTextComponent = playButton.GetComponentInChildren<TMP_Text>();
playTextComponent.fontSize = 24; playTextComponent.fontSize = 24;
playTextComponent.text = "PLAY"; playTextComponent.text = "PLAY";
RectTransform playRectTransform = playButton.GetComponent<RectTransform>(); RectTransform playRectTransform = playButton.GetComponent<RectTransform>();
playRectTransform.anchoredPosition = Vector2.up * 45f; playRectTransform.anchoredPosition = Vector2.up * 45f;
playButton.name = "PlayButton"; playButton.name = "PlayButton";
GameObject quitButton = TMP_DefaultControls.CreateButton(GetStandardResources()); GameObject quitButton = TMP_DefaultControls.CreateButton(GetStandardResources());
quitButton.transform.SetParent(canvasObj.transform); quitButton.transform.SetParent(canvasObj.transform);
TMP_Text quitTextComponent = quitButton.GetComponentInChildren<TMP_Text>(); TMP_Text quitTextComponent = quitButton.GetComponentInChildren<TMP_Text>();
quitTextComponent.fontSize = 24; quitTextComponent.fontSize = 24;
quitTextComponent.text = "QUIT"; quitTextComponent.text = "QUIT";
RectTransform quitRectTransform = quitButton.GetComponent<RectTransform>(); RectTransform quitRectTransform = quitButton.GetComponent<RectTransform>();
quitRectTransform.anchoredPosition = Vector2.down * 85f; quitRectTransform.anchoredPosition = Vector2.down * 85f;
quitButton.name = "QuitButton"; quitButton.name = "QuitButton";
MenuController menuController = canvasObj.AddComponent<MenuController>(); MenuController menuController = canvasObj.AddComponent<MenuController>();
Slider sliderMusic = menuController.musicSlider = musicSlider.GetComponent<Slider>(); Slider sliderMusic = menuController.musicSlider = musicSlider.GetComponent<Slider>();
Slider sliderSfx = menuController.sfxSlider = sfxSlider.GetComponent<Slider>(); Slider sliderSfx = menuController.sfxSlider = sfxSlider.GetComponent<Slider>();
TMP_Dropdown dropdownQuality = menuController.qualityDropdown = qualityDropdown.GetComponent<TMP_Dropdown>(); TMP_Dropdown dropdownQuality = menuController.qualityDropdown = qualityDropdown.GetComponent<TMP_Dropdown>();
TMP_Dropdown dropdownResolution = menuController.resolutionDropdown = resolutionDropdown.GetComponent<TMP_Dropdown>(); TMP_Dropdown dropdownResolution = menuController.resolutionDropdown = resolutionDropdown.GetComponent<TMP_Dropdown>();
sliderMusic.onValueChanged.AddListener(menuController.SetMusicVolume); sliderMusic.onValueChanged.AddListener(menuController.SetMusicVolume);
sliderSfx.onValueChanged.AddListener(menuController.SetSfxVolume); sliderSfx.onValueChanged.AddListener(menuController.SetSfxVolume);
dropdownQuality.onValueChanged.AddListener(menuController.SetQuality); dropdownQuality.onValueChanged.AddListener(menuController.SetQuality);
dropdownResolution.onValueChanged.AddListener(menuController.SetResolution); dropdownResolution.onValueChanged.AddListener(menuController.SetResolution);
playButton.GetComponent<Button>().onClick.AddListener(menuController.Play); playButton.GetComponent<Button>().onClick.AddListener(menuController.Play);
quitButton.GetComponent<Button>().onClick.AddListener(menuController.Quit); quitButton.GetComponent<Button>().onClick.AddListener(menuController.Quit);
} }
#region CreateUISettings #region CreateUISettings
const string kUILayerName = "UI"; const string kUILayerName = "UI";
const string kStandardSpritePath = "UI/Skin/UISprite.psd"; const string kStandardSpritePath = "UI/Skin/UISprite.psd";
const string kBackgroundSpritePath = "UI/Skin/Background.psd"; const string kBackgroundSpritePath = "UI/Skin/Background.psd";
const string kInputFieldBackgroundPath = "UI/Skin/InputFieldBackground.psd"; const string kInputFieldBackgroundPath = "UI/Skin/InputFieldBackground.psd";
const string kKnobPath = "UI/Skin/Knob.psd"; const string kKnobPath = "UI/Skin/Knob.psd";
const string kCheckmarkPath = "UI/Skin/Checkmark.psd"; const string kCheckmarkPath = "UI/Skin/Checkmark.psd";
const string kDropdownArrowPath = "UI/Skin/DropdownArrow.psd"; const string kDropdownArrowPath = "UI/Skin/DropdownArrow.psd";
const string kMaskPath = "UI/Skin/UIMask.psd"; const string kMaskPath = "UI/Skin/UIMask.psd";
static TMP_DefaultControls.Resources s_StandardResources; static TMP_DefaultControls.Resources s_StandardResources;
static TMP_DefaultControls.Resources GetStandardResources(){ static TMP_DefaultControls.Resources GetStandardResources(){
if (s_StandardResources.standard == null){ if (s_StandardResources.standard == null){
s_StandardResources.standard = AssetDatabase.GetBuiltinExtraResource<Sprite>(kStandardSpritePath); s_StandardResources.standard = AssetDatabase.GetBuiltinExtraResource<Sprite>(kStandardSpritePath);
s_StandardResources.background = AssetDatabase.GetBuiltinExtraResource<Sprite>(kBackgroundSpritePath); s_StandardResources.background = AssetDatabase.GetBuiltinExtraResource<Sprite>(kBackgroundSpritePath);
s_StandardResources.inputField = AssetDatabase.GetBuiltinExtraResource<Sprite>(kInputFieldBackgroundPath); s_StandardResources.inputField = AssetDatabase.GetBuiltinExtraResource<Sprite>(kInputFieldBackgroundPath);
s_StandardResources.knob = AssetDatabase.GetBuiltinExtraResource<Sprite>(kKnobPath); s_StandardResources.knob = AssetDatabase.GetBuiltinExtraResource<Sprite>(kKnobPath);
s_StandardResources.checkmark = AssetDatabase.GetBuiltinExtraResource<Sprite>(kCheckmarkPath); s_StandardResources.checkmark = AssetDatabase.GetBuiltinExtraResource<Sprite>(kCheckmarkPath);
s_StandardResources.dropdown = AssetDatabase.GetBuiltinExtraResource<Sprite>(kDropdownArrowPath); s_StandardResources.dropdown = AssetDatabase.GetBuiltinExtraResource<Sprite>(kDropdownArrowPath);
s_StandardResources.mask = AssetDatabase.GetBuiltinExtraResource<Sprite>(kMaskPath); s_StandardResources.mask = AssetDatabase.GetBuiltinExtraResource<Sprite>(kMaskPath);
} }
return s_StandardResources; return s_StandardResources;
} }
static void SetPositionVisibleinSceneView(RectTransform canvasRTransform, RectTransform itemTransform){ static void SetPositionVisibleinSceneView(RectTransform canvasRTransform, RectTransform itemTransform){
// Find the best scene view // Find the best scene view
SceneView sceneView = SceneView.lastActiveSceneView; SceneView sceneView = SceneView.lastActiveSceneView;
if (sceneView == null && SceneView.sceneViews.Count > 0) if (sceneView == null && SceneView.sceneViews.Count > 0)
sceneView = SceneView.sceneViews[0] as SceneView; sceneView = SceneView.sceneViews[0] as SceneView;
// Couldn't find a SceneView. Don't set position. // Couldn't find a SceneView. Don't set position.
if (sceneView == null || sceneView.camera == null) if (sceneView == null || sceneView.camera == null)
return; return;
// Create world space Plane from canvas position. // Create world space Plane from canvas position.
Camera camera = sceneView.camera; Camera camera = sceneView.camera;
Vector3 position = Vector3.zero; Vector3 position = Vector3.zero;
Vector2 localPlanePosition; Vector2 localPlanePosition;
if (RectTransformUtility.ScreenPointToLocalPointInRectangle(canvasRTransform, new Vector2(camera.pixelWidth / 2, camera.pixelHeight / 2), camera, out localPlanePosition)){ if (RectTransformUtility.ScreenPointToLocalPointInRectangle(canvasRTransform, new Vector2(camera.pixelWidth / 2, camera.pixelHeight / 2), camera, out localPlanePosition)){
// Adjust for canvas pivot // Adjust for canvas pivot
localPlanePosition.x = localPlanePosition.x + canvasRTransform.sizeDelta.x * canvasRTransform.pivot.x; localPlanePosition.x = localPlanePosition.x + canvasRTransform.sizeDelta.x * canvasRTransform.pivot.x;
localPlanePosition.y = localPlanePosition.y + canvasRTransform.sizeDelta.y * canvasRTransform.pivot.y; localPlanePosition.y = localPlanePosition.y + canvasRTransform.sizeDelta.y * canvasRTransform.pivot.y;
localPlanePosition.x = Mathf.Clamp(localPlanePosition.x, 0, canvasRTransform.sizeDelta.x); localPlanePosition.x = Mathf.Clamp(localPlanePosition.x, 0, canvasRTransform.sizeDelta.x);
localPlanePosition.y = Mathf.Clamp(localPlanePosition.y, 0, canvasRTransform.sizeDelta.y); localPlanePosition.y = Mathf.Clamp(localPlanePosition.y, 0, canvasRTransform.sizeDelta.y);
// Adjust for anchoring // Adjust for anchoring
position.x = localPlanePosition.x - canvasRTransform.sizeDelta.x * itemTransform.anchorMin.x; position.x = localPlanePosition.x - canvasRTransform.sizeDelta.x * itemTransform.anchorMin.x;
position.y = localPlanePosition.y - canvasRTransform.sizeDelta.y * itemTransform.anchorMin.y; position.y = localPlanePosition.y - canvasRTransform.sizeDelta.y * itemTransform.anchorMin.y;
Vector3 minLocalPosition; Vector3 minLocalPosition;
minLocalPosition.x = canvasRTransform.sizeDelta.x * (0 - canvasRTransform.pivot.x) + itemTransform.sizeDelta.x * itemTransform.pivot.x; minLocalPosition.x = canvasRTransform.sizeDelta.x * (0 - canvasRTransform.pivot.x) + itemTransform.sizeDelta.x * itemTransform.pivot.x;
minLocalPosition.y = canvasRTransform.sizeDelta.y * (0 - canvasRTransform.pivot.y) + itemTransform.sizeDelta.y * itemTransform.pivot.y; minLocalPosition.y = canvasRTransform.sizeDelta.y * (0 - canvasRTransform.pivot.y) + itemTransform.sizeDelta.y * itemTransform.pivot.y;
Vector3 maxLocalPosition; Vector3 maxLocalPosition;
maxLocalPosition.x = canvasRTransform.sizeDelta.x * (1 - canvasRTransform.pivot.x) - itemTransform.sizeDelta.x * itemTransform.pivot.x; maxLocalPosition.x = canvasRTransform.sizeDelta.x * (1 - canvasRTransform.pivot.x) - itemTransform.sizeDelta.x * itemTransform.pivot.x;
maxLocalPosition.y = canvasRTransform.sizeDelta.y * (1 - canvasRTransform.pivot.y) - itemTransform.sizeDelta.y * itemTransform.pivot.y; maxLocalPosition.y = canvasRTransform.sizeDelta.y * (1 - canvasRTransform.pivot.y) - itemTransform.sizeDelta.y * itemTransform.pivot.y;
position.x = Mathf.Clamp(position.x, minLocalPosition.x, maxLocalPosition.x); position.x = Mathf.Clamp(position.x, minLocalPosition.x, maxLocalPosition.x);
position.y = Mathf.Clamp(position.y, minLocalPosition.y, maxLocalPosition.y); position.y = Mathf.Clamp(position.y, minLocalPosition.y, maxLocalPosition.y);
} }
itemTransform.anchoredPosition = position; itemTransform.anchoredPosition = position;
itemTransform.localRotation = Quaternion.identity; itemTransform.localRotation = Quaternion.identity;
itemTransform.localScale = Vector3.one; itemTransform.localScale = Vector3.one;
} }
static GameObject CreateNewUI(){ static GameObject CreateNewUI(){
// Root for the UI // Root for the UI
var root = new GameObject("Canvas"); var root = new GameObject("Canvas");
root.layer = LayerMask.NameToLayer(kUILayerName); root.layer = LayerMask.NameToLayer(kUILayerName);
Canvas canvas = root.AddComponent<Canvas>(); Canvas canvas = root.AddComponent<Canvas>();
canvas.renderMode = RenderMode.ScreenSpaceOverlay; canvas.renderMode = RenderMode.ScreenSpaceOverlay;
root.AddComponent<CanvasScaler>(); root.AddComponent<CanvasScaler>();
root.AddComponent<GraphicRaycaster>(); root.AddComponent<GraphicRaycaster>();
// Works for all stages. // Works for all stages.
StageUtility.PlaceGameObjectInCurrentStage(root); StageUtility.PlaceGameObjectInCurrentStage(root);
bool customScene = false; bool customScene = false;
PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage(); PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
if (prefabStage != null){ if (prefabStage != null){
root.transform.SetParent(prefabStage.prefabContentsRoot.transform, false); root.transform.SetParent(prefabStage.prefabContentsRoot.transform, false);
customScene = true; customScene = true;
} }
Undo.RegisterCreatedObjectUndo(root, "Create " + root.name); Undo.RegisterCreatedObjectUndo(root, "Create " + root.name);
// If there is no event system add one... // If there is no event system add one...
// No need to place event system in custom scene as these are temporary anyway. // No need to place event system in custom scene as these are temporary anyway.
// It can be argued for or against placing it in the user scenes, // It can be argued for or against placing it in the user scenes,
// but let's not modify scene user is not currently looking at. // but let's not modify scene user is not currently looking at.
if (!customScene) if (!customScene)
CreateEventSystem(false); CreateEventSystem(false);
return root; return root;
} }
static void CreateEventSystem(bool select){ static void CreateEventSystem(bool select){
CreateEventSystem(select, null); CreateEventSystem(select, null);
} }
static void CreateEventSystem(bool select, GameObject parent){ static void CreateEventSystem(bool select, GameObject parent){
var esys = UnityEngine.Object.FindObjectOfType<EventSystem>(); var esys = UnityEngine.Object.FindObjectOfType<EventSystem>();
if (esys == null){ if (esys == null){
var eventSystem = new GameObject("EventSystem"); var eventSystem = new GameObject("EventSystem");
GameObjectUtility.SetParentAndAlign(eventSystem, parent); GameObjectUtility.SetParentAndAlign(eventSystem, parent);
esys = eventSystem.AddComponent<EventSystem>(); esys = eventSystem.AddComponent<EventSystem>();
eventSystem.AddComponent<StandaloneInputModule>(); eventSystem.AddComponent<StandaloneInputModule>();
Undo.RegisterCreatedObjectUndo(eventSystem, "Create " + eventSystem.name); Undo.RegisterCreatedObjectUndo(eventSystem, "Create " + eventSystem.name);
} }
if (select && esys != null){ if (select && esys != null){
Selection.activeGameObject = esys.gameObject; Selection.activeGameObject = esys.gameObject;
} }
} }
// Helper function that returns a Canvas GameObject; preferably a parent of the selection, or other existing Canvas. // Helper function that returns a Canvas GameObject; preferably a parent of the selection, or other existing Canvas.
static GameObject GetOrCreateCanvasGameObject(){ static GameObject GetOrCreateCanvasGameObject(){
GameObject selectedGo = Selection.activeGameObject; GameObject selectedGo = Selection.activeGameObject;
// Try to find a gameobject that is the selected GO or one if its parents. // Try to find a gameobject that is the selected GO or one if its parents.
Canvas canvas = (selectedGo != null) ? selectedGo.GetComponentInParent<Canvas>() : null; Canvas canvas = (selectedGo != null) ? selectedGo.GetComponentInParent<Canvas>() : null;
if (IsValidCanvas(canvas)) if (IsValidCanvas(canvas))
return canvas.gameObject; return canvas.gameObject;
// No canvas in selection or its parents? Then use any valid canvas. // No canvas in selection or its parents? Then use any valid canvas.
// We have to find all loaded Canvases, not just the ones in main scenes. // We have to find all loaded Canvases, not just the ones in main scenes.
Canvas[] canvasArray = StageUtility.GetCurrentStageHandle().FindComponentsOfType<Canvas>(); Canvas[] canvasArray = StageUtility.GetCurrentStageHandle().FindComponentsOfType<Canvas>();
for (int i = 0; i < canvasArray.Length; i++) for (int i = 0; i < canvasArray.Length; i++)
if (IsValidCanvas(canvasArray[i])) if (IsValidCanvas(canvasArray[i]))
return canvasArray[i].gameObject; return canvasArray[i].gameObject;
// No canvas in the scene at all? Then create a new one. // No canvas in the scene at all? Then create a new one.
return CreateNewUI(); return CreateNewUI();
} }
static bool IsValidCanvas(Canvas canvas){ static bool IsValidCanvas(Canvas canvas){
if (canvas == null || !canvas.gameObject.activeInHierarchy) if (canvas == null || !canvas.gameObject.activeInHierarchy)
return false; return false;
// It's important that the non-editable canvas from a prefab scene won't be rejected, // It's important that the non-editable canvas from a prefab scene won't be rejected,
// but canvases not visible in the Hierarchy at all do. Don't check for HideAndDontSave. // but canvases not visible in the Hierarchy at all do. Don't check for HideAndDontSave.
if (EditorUtility.IsPersistent(canvas) || (canvas.hideFlags & HideFlags.HideInHierarchy) != 0) if (EditorUtility.IsPersistent(canvas) || (canvas.hideFlags & HideFlags.HideInHierarchy) != 0)
return false; return false;
if (StageUtility.GetStageHandle(canvas.gameObject) != StageUtility.GetCurrentStageHandle()) if (StageUtility.GetStageHandle(canvas.gameObject) != StageUtility.GetCurrentStageHandle())
return false; return false;
return true; return true;
} }
class FactorySwapToEditor : IDisposable{ class FactorySwapToEditor : IDisposable{
DefaultControls.IFactoryControls factory; DefaultControls.IFactoryControls factory;
public FactorySwapToEditor(){ public FactorySwapToEditor(){
factory = DefaultControls.factory; factory = DefaultControls.factory;
DefaultControls.factory = DefaultEditorFactory.Default; DefaultControls.factory = DefaultEditorFactory.Default;
} }
public void Dispose(){ public void Dispose(){
DefaultControls.factory = factory; DefaultControls.factory = factory;
} }
} }
const string kStandardSpritePathDefault = "UI/Skin/UISprite.psd"; const string kStandardSpritePathDefault = "UI/Skin/UISprite.psd";
const string kBackgroundSpritePathDefault = "UI/Skin/Background.psd"; const string kBackgroundSpritePathDefault = "UI/Skin/Background.psd";
const string kInputFieldBackgroundPathDefault = "UI/Skin/InputFieldBackground.psd"; const string kInputFieldBackgroundPathDefault = "UI/Skin/InputFieldBackground.psd";
const string kKnobPathDefault = "UI/Skin/Knob.psd"; const string kKnobPathDefault = "UI/Skin/Knob.psd";
const string kCheckmarkPathDefault = "UI/Skin/Checkmark.psd"; const string kCheckmarkPathDefault = "UI/Skin/Checkmark.psd";
const string kDropdownArrowPathDefault = "UI/Skin/DropdownArrow.psd"; const string kDropdownArrowPathDefault = "UI/Skin/DropdownArrow.psd";
const string kMaskPathDefault = "UI/Skin/UIMask.psd"; const string kMaskPathDefault = "UI/Skin/UIMask.psd";
static DefaultControls.Resources s_StandardResourcesDefault; static DefaultControls.Resources s_StandardResourcesDefault;
static DefaultControls.Resources GetStandardUIResources(){ static DefaultControls.Resources GetStandardUIResources(){
if (s_StandardResourcesDefault.standard == null){ if (s_StandardResourcesDefault.standard == null){
s_StandardResourcesDefault.standard = AssetDatabase.GetBuiltinExtraResource<Sprite>(kStandardSpritePathDefault); s_StandardResourcesDefault.standard = AssetDatabase.GetBuiltinExtraResource<Sprite>(kStandardSpritePathDefault);
s_StandardResourcesDefault.background = AssetDatabase.GetBuiltinExtraResource<Sprite>(kBackgroundSpritePathDefault); s_StandardResourcesDefault.background = AssetDatabase.GetBuiltinExtraResource<Sprite>(kBackgroundSpritePathDefault);
s_StandardResourcesDefault.inputField = AssetDatabase.GetBuiltinExtraResource<Sprite>(kInputFieldBackgroundPathDefault); s_StandardResourcesDefault.inputField = AssetDatabase.GetBuiltinExtraResource<Sprite>(kInputFieldBackgroundPathDefault);
s_StandardResourcesDefault.knob = AssetDatabase.GetBuiltinExtraResource<Sprite>(kKnobPathDefault); s_StandardResourcesDefault.knob = AssetDatabase.GetBuiltinExtraResource<Sprite>(kKnobPathDefault);
s_StandardResourcesDefault.checkmark = AssetDatabase.GetBuiltinExtraResource<Sprite>(kCheckmarkPathDefault); s_StandardResourcesDefault.checkmark = AssetDatabase.GetBuiltinExtraResource<Sprite>(kCheckmarkPathDefault);
s_StandardResourcesDefault.dropdown = AssetDatabase.GetBuiltinExtraResource<Sprite>(kDropdownArrowPathDefault); s_StandardResourcesDefault.dropdown = AssetDatabase.GetBuiltinExtraResource<Sprite>(kDropdownArrowPathDefault);
s_StandardResourcesDefault.mask = AssetDatabase.GetBuiltinExtraResource<Sprite>(kMaskPathDefault); s_StandardResourcesDefault.mask = AssetDatabase.GetBuiltinExtraResource<Sprite>(kMaskPathDefault);
} }
return s_StandardResourcesDefault; return s_StandardResourcesDefault;
} }
static void PlaceUIElementRoot(GameObject element, MenuCommand menuCommand){ static void PlaceUIElementRoot(GameObject element, MenuCommand menuCommand){
GameObject parent = menuCommand.context as GameObject; GameObject parent = menuCommand.context as GameObject;
bool explicitParentChoice = true; bool explicitParentChoice = true;
if (parent == null){ if (parent == null){
parent = GetOrCreateCanvasGameObject(); parent = GetOrCreateCanvasGameObject();
explicitParentChoice = false; explicitParentChoice = false;
// If in Prefab Mode, Canvas has to be part of Prefab contents, // If in Prefab Mode, Canvas has to be part of Prefab contents,
// otherwise use Prefab root instead. // otherwise use Prefab root instead.
PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage(); PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
if (prefabStage != null && !prefabStage.IsPartOfPrefabContents(parent)) if (prefabStage != null && !prefabStage.IsPartOfPrefabContents(parent))
parent = prefabStage.prefabContentsRoot; parent = prefabStage.prefabContentsRoot;
} }
if (parent.GetComponentsInParent<Canvas>(true).Length == 0){ if (parent.GetComponentsInParent<Canvas>(true).Length == 0){
// Create canvas under context GameObject, // Create canvas under context GameObject,
// and make that be the parent which UI element is added under. // and make that be the parent which UI element is added under.
GameObject canvas = CreateNewUIDefault(); GameObject canvas = CreateNewUIDefault();
Undo.SetTransformParent(canvas.transform, parent.transform, ""); Undo.SetTransformParent(canvas.transform, parent.transform, "");
parent = canvas; parent = canvas;
} }
GameObjectUtility.EnsureUniqueNameForSibling(element); GameObjectUtility.EnsureUniqueNameForSibling(element);
SetParentAndAlign(element, parent); SetParentAndAlign(element, parent);
if (!explicitParentChoice) // not a context click, so center in sceneview if (!explicitParentChoice) // not a context click, so center in sceneview
SetPositionVisibleinSceneView(parent.GetComponent<RectTransform>(), element.GetComponent<RectTransform>()); SetPositionVisibleinSceneView(parent.GetComponent<RectTransform>(), element.GetComponent<RectTransform>());
// This call ensure any change made to created Objects after they where registered will be part of the Undo. // This call ensure any change made to created Objects after they where registered will be part of the Undo.
Undo.RegisterFullObjectHierarchyUndo(parent == null ? element : parent, ""); Undo.RegisterFullObjectHierarchyUndo(parent == null ? element : parent, "");
// We have to fix up the undo name since the name of the object was only known after reparenting it. // We have to fix up the undo name since the name of the object was only known after reparenting it.
Undo.SetCurrentGroupName("Create " + element.name); Undo.SetCurrentGroupName("Create " + element.name);
Selection.activeGameObject = element; Selection.activeGameObject = element;
} }
static GameObject CreateNewUIDefault(){ static GameObject CreateNewUIDefault(){
// Root for the UI // Root for the UI
var root = ObjectFactory.CreateGameObject("Canvas", typeof(Canvas), typeof(CanvasScaler), typeof(GraphicRaycaster)); var root = ObjectFactory.CreateGameObject("Canvas", typeof(Canvas), typeof(CanvasScaler), typeof(GraphicRaycaster));
root.layer = LayerMask.NameToLayer(kUILayerName); root.layer = LayerMask.NameToLayer(kUILayerName);
Canvas canvas = root.GetComponent<Canvas>(); Canvas canvas = root.GetComponent<Canvas>();
canvas.renderMode = RenderMode.ScreenSpaceOverlay; canvas.renderMode = RenderMode.ScreenSpaceOverlay;
// Works for all stages. // Works for all stages.
StageUtility.PlaceGameObjectInCurrentStage(root); StageUtility.PlaceGameObjectInCurrentStage(root);
bool customScene = false; bool customScene = false;
PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage(); PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
if (prefabStage != null){ if (prefabStage != null){
Undo.SetTransformParent(root.transform, prefabStage.prefabContentsRoot.transform, ""); Undo.SetTransformParent(root.transform, prefabStage.prefabContentsRoot.transform, "");
customScene = true; customScene = true;
} }
Undo.SetCurrentGroupName("Create " + root.name); Undo.SetCurrentGroupName("Create " + root.name);
// If there is no event system add one... // If there is no event system add one...
// No need to place event system in custom scene as these are temporary anyway. // No need to place event system in custom scene as these are temporary anyway.
// It can be argued for or against placing it in the user scenes, // It can be argued for or against placing it in the user scenes,
// but let's not modify scene user is not currently looking at. // but let's not modify scene user is not currently looking at.
if (!customScene) if (!customScene)
CreateEventSystem(false); CreateEventSystem(false);
return root; return root;
} }
static void SetParentAndAlign(GameObject child, GameObject parent){ static void SetParentAndAlign(GameObject child, GameObject parent){
if (parent == null) if (parent == null)
return; return;
Undo.SetTransformParent(child.transform, parent.transform, ""); Undo.SetTransformParent(child.transform, parent.transform, "");
RectTransform rectTransform = child.transform as RectTransform; RectTransform rectTransform = child.transform as RectTransform;
if (rectTransform){ if (rectTransform){
rectTransform.anchoredPosition = Vector2.zero; rectTransform.anchoredPosition = Vector2.zero;
Vector3 localPosition = rectTransform.localPosition; Vector3 localPosition = rectTransform.localPosition;
localPosition.z = 0; localPosition.z = 0;
rectTransform.localPosition = localPosition; rectTransform.localPosition = localPosition;
}else{ }else{
child.transform.localPosition = Vector3.zero; child.transform.localPosition = Vector3.zero;
} }
child.transform.localRotation = Quaternion.identity; child.transform.localRotation = Quaternion.identity;
child.transform.localScale = Vector3.one; child.transform.localScale = Vector3.one;
SetLayerRecursively(child, parent.layer); SetLayerRecursively(child, parent.layer);
} }
static void SetLayerRecursively(GameObject go, int layer){ static void SetLayerRecursively(GameObject go, int layer){
go.layer = layer; go.layer = layer;
Transform t = go.transform; Transform t = go.transform;
for (int i = 0; i < t.childCount; i++) for (int i = 0; i < t.childCount; i++)
SetLayerRecursively(t.GetChild(i).gameObject, layer); SetLayerRecursively(t.GetChild(i).gameObject, layer);
} }
class DefaultEditorFactory : DefaultControls.IFactoryControls{ class DefaultEditorFactory : DefaultControls.IFactoryControls{
public static DefaultEditorFactory Default = new DefaultEditorFactory(); public static DefaultEditorFactory Default = new DefaultEditorFactory();
public GameObject CreateGameObject(string name, params Type[] components){ public GameObject CreateGameObject(string name, params Type[] components){
return ObjectFactory.CreateGameObject(name, components); return ObjectFactory.CreateGameObject(name, components);
} }
} }
#endregion #endregion
#endif #endif
} }
#endif

169
Tools/Menu/MenuController.cs
View file

@ -5,106 +5,105 @@ using UnityEngine.UI;
using TMPro; using TMPro;
using UnityEngine.Audio; using UnityEngine.Audio;
namespace SimpleTools.Menu { [System.Serializable] public class OnPlay : UnityEngine.Events.UnityEvent { }
[System.Serializable] public class OnPlay : UnityEngine.Events.UnityEvent { } public class MenuController : MonoBehaviour{
public class MenuController : MonoBehaviour {
[Header("Audio")] [Header("Audio")]
[SerializeField] AudioMixer mainMixer = default; [SerializeField] AudioMixer mainMixer = default;
[Tooltip("The music volume the first time you start the game")][SerializeField, Range(0, 1)] float defaultMusicValue = .75f; [Tooltip("The music volume the first time you start the game")] [SerializeField, Range(0, 1)] float defaultMusicValue = .75f;
[Tooltip("The SFX volume the first time you start the game")][SerializeField, Range(0, 1)] float defaultSfxValue = .75f; [Tooltip("The SFX volume the first time you start the game")] [SerializeField, Range(0, 1)] float defaultSfxValue = .75f;
public Slider musicSlider = default; public Slider musicSlider = default;
public Slider sfxSlider = default; public Slider sfxSlider = default;
[Header("Visual")] [Header("Visual")]
public TMP_Dropdown qualityDropdown = default; public TMP_Dropdown qualityDropdown = default;
int qualitySelected; int qualitySelected;
public TMP_Dropdown resolutionDropdown = default; public TMP_Dropdown resolutionDropdown = default;
Resolution[] resolutions; Resolution[] resolutions;
int currentResolutionIndex; int currentResolutionIndex;
[Space] [Space]
[SerializeField] OnPlay onPlay = default; [SerializeField] OnPlay onPlay = default;
void Awake() { void Awake(){
if (mainMixer) { if (mainMixer){
float musicVolume = PlayerPrefs.GetFloat("MusicVolume", defaultMusicValue); float musicVolume = PlayerPrefs.GetFloat("MusicVolume", defaultMusicValue);
float sfxVolume = PlayerPrefs.GetFloat("SFXVolume", defaultSfxValue); float sfxVolume = PlayerPrefs.GetFloat("SFXVolume", defaultSfxValue);
mainMixer.SetFloat("Master", Mathf.Log10(musicVolume <= .0001f ? .0001f : musicVolume) * 20); mainMixer.SetFloat("Master", Mathf.Log10(musicVolume <= .0001f ? .0001f : musicVolume) * 20);
mainMixer.SetFloat("SFX", Mathf.Log10(sfxVolume <= .0001f ? .0001f : sfxVolume) * 20); mainMixer.SetFloat("SFX", Mathf.Log10(sfxVolume <= .0001f ? .0001f : sfxVolume) * 20);
}
resolutions = Screen.resolutions.Select(resolution => new Resolution { width = resolution.width, height = resolution.height }).Distinct().ToArray();
resolutionDropdown.ClearOptions();
List<string> options = new List<string>();
for (int i = 0; i < resolutions.Length; i++){
string option = resolutions[i].width + "x" + resolutions[i].height;
options.Add(option);
if (resolutions[i].width == Screen.currentResolution.width && resolutions[i].height == Screen.currentResolution.height)
{
currentResolutionIndex = i;
} }
resolutions = Screen.resolutions.Select(resolution => new Resolution { width = resolution.width, height = resolution.height }).Distinct().ToArray();
resolutionDropdown.ClearOptions();
List<string> options = new List<string>();
for (int i = 0; i < resolutions.Length; i++) {
string option = resolutions[i].width + "x" + resolutions[i].height;
options.Add(option);
if (resolutions[i].width == Screen.currentResolution.width && resolutions[i].height == Screen.currentResolution.height) {
currentResolutionIndex = i;
}
}
resolutions.Reverse();
resolutionDropdown.AddOptions(options);
resolutionDropdown.value = currentResolutionIndex;
resolutionDropdown.RefreshShownValue();
qualityDropdown.ClearOptions();
List<string> qualityNames = new List<string>();
for (int i = 0; i < QualitySettings.names.Length; i++) {
qualityNames.Add(QualitySettings.names[i]);
}
qualityDropdown.AddOptions(qualityNames);
qualitySelected = PlayerPrefs.HasKey("QualitySelected") ? PlayerPrefs.GetInt("QualitySelected") : QualitySettings.GetQualityLevel();
qualityDropdown.value = qualitySelected;
QualitySettings.SetQualityLevel(qualitySelected);
qualityDropdown.RefreshShownValue();
} }
void OnValidate() { resolutions.Reverse();
if (musicSlider) musicSlider.minValue = musicSlider.minValue < .0001f ? .0001f : musicSlider.minValue;
if (sfxSlider) sfxSlider.minValue = sfxSlider.minValue < .0001f ? .0001f : sfxSlider.minValue;
}
void Start() { resolutionDropdown.AddOptions(options);
musicSlider.value = PlayerPrefs.GetFloat("MusicVolume", defaultMusicValue); resolutionDropdown.value = currentResolutionIndex;
sfxSlider.value = PlayerPrefs.GetFloat("SFXVolume", defaultSfxValue); resolutionDropdown.RefreshShownValue();
}
//Needs a slider between 0.0001 and 1 qualityDropdown.ClearOptions();
public void SetMusicVolume(float sliderValue) { List<string> qualityNames = new List<string>();
mainMixer.SetFloat("Master", Mathf.Log10(sliderValue) * 20); for (int i = 0; i < QualitySettings.names.Length; i++){
PlayerPrefs.SetFloat("MusicVolume", sliderValue); qualityNames.Add(QualitySettings.names[i]);
} }
qualityDropdown.AddOptions(qualityNames);
//Needs a slider between 0.0001 and 1 qualitySelected = PlayerPrefs.HasKey("QualitySelected") ? PlayerPrefs.GetInt("QualitySelected") : QualitySettings.GetQualityLevel();
public void SetSfxVolume(float sliderValue) { qualityDropdown.value = qualitySelected;
mainMixer.SetFloat("SFX", Mathf.Log10(sliderValue) * 20); QualitySettings.SetQualityLevel(qualitySelected);
PlayerPrefs.SetFloat("SFXVolume", sliderValue); qualityDropdown.RefreshShownValue();
} }
public void SetQuality(int qualityIndex) { void OnValidate(){
QualitySettings.SetQualityLevel(qualityIndex); if (musicSlider) musicSlider.minValue = musicSlider.minValue < .0001f ? .0001f : musicSlider.minValue;
PlayerPrefs.SetInt("QualitySelected", qualityIndex); if (sfxSlider) sfxSlider.minValue = sfxSlider.minValue < .0001f ? .0001f : sfxSlider.minValue;
} }
public void SetResolution(int resolutionIndex) { void Start(){
Resolution resolution = resolutions[resolutionIndex]; musicSlider.value = PlayerPrefs.GetFloat("MusicVolume", defaultMusicValue);
Screen.SetResolution(resolution.width, resolution.height, Screen.fullScreen); sfxSlider.value = PlayerPrefs.GetFloat("SFXVolume", defaultSfxValue);
} }
public void Play() { //Needs a slider between 0.0001 and 1
onPlay.Invoke(); public void SetMusicVolume(float sliderValue){
} mainMixer.SetFloat("Master", Mathf.Log10(sliderValue) * 20);
PlayerPrefs.SetFloat("MusicVolume", sliderValue);
}
public void Quit() { //Needs a slider between 0.0001 and 1
Application.Quit(); public void SetSfxVolume(float sliderValue){
} mainMixer.SetFloat("SFX", Mathf.Log10(sliderValue) * 20);
PlayerPrefs.SetFloat("SFXVolume", sliderValue);
}
public void SetQuality(int qualityIndex){
QualitySettings.SetQualityLevel(qualityIndex);
PlayerPrefs.SetInt("QualitySelected", qualityIndex);
}
public void SetResolution(int resolutionIndex){
Resolution resolution = resolutions[resolutionIndex];
Screen.SetResolution(resolution.width, resolution.height, Screen.fullScreen);
}
public void Play(){
onPlay.Invoke();
}
public void Quit(){
Application.Quit();
} }
} }

12
Tools/MonobehaviourExtensions.cs
View file

@ -1,12 +0,0 @@
using UnityEngine;
namespace SimpleTools {
public static class MonobehaviourExtensions {
public static void EnsureCoroutineStopped(this MonoBehaviour value, ref Coroutine routine) {
if (routine != null) {
value.StopCoroutine(routine);
routine = null;
}
}
}
}

11
Tools/MonobehaviourExtensions.cs.meta
View file

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

6
Tools/ObjectPooler/IPooledObject.cs
View file

@ -1,5 +1,3 @@
namespace SimpleTools.ObjectPooler { public interface IPooledObject{
public interface IPooledObject { void OnObjectSpawn();
void OnObjectSpawn();
}
} }

24
Tools/ObjectPooler/Pool.cs
View file

@ -1,20 +1,18 @@
using System.Collections.Generic; using System.Collections.Generic;
using UnityEngine; using UnityEngine;
namespace SimpleTools.ObjectPooler { [CreateAssetMenu(fileName = "New Pool", menuName = "Tools/Pool", order = 0)]
[CreateAssetMenu(fileName = "New Pool", menuName = "Simple Tools/Pool", order = 11)] public class Pool : ScriptableObject{
public class Pool : ScriptableObject {
public List<PoolPrefab> pools; public List<PoolPrefab> pools;
[System.Serializable] [System.Serializable]
public class PoolPrefab { public class PoolPrefab{
public string tag; public string tag;
public GameObject prefab; public GameObject prefab;
public bool undetermined; public bool undetermined;
public int size; public int size;
[HideInInspector] public Queue<GameObject> determinedPool; [HideInInspector] public Queue<GameObject> determinedPool;
[HideInInspector] public List<GameObject> undeterminedPool; [HideInInspector] public List<GameObject> undeterminedPool;
}
} }
} }

586
Tools/ObjectPooler/Pooler.cs
View file

@ -2,370 +2,368 @@
using UnityEngine; using UnityEngine;
using UnityEngine.SceneManagement; using UnityEngine.SceneManagement;
namespace SimpleTools.ObjectPooler { public static class Pooler{
public static class Pooler {
class PoolChecker : MonoBehaviour { class PoolChecker : MonoBehaviour {
public string poolTag; public string poolTag;
}
static Dictionary<string, Pool.PoolPrefab> poolDictionary;
static Scene poolScene;
/// <summary>Generate a scene with the objects of the pools in it
/// <para>If this isn't called, the pooler won't work</para>
/// </summary>
public static void CreatePools(Pool pool){
if(pool == null){
Debug.LogWarning("You have to provide a pool.");
return;
} }
static Dictionary<string, Pool.PoolPrefab> poolDictionary; poolDictionary = new Dictionary<string, Pool.PoolPrefab>();
static Scene poolScene; if (SceneManager.GetSceneByName("PoolScene").IsValid()){
poolScene = SceneManager.GetSceneByName("PoolScene");
}else{
poolScene = SceneManager.CreateScene("PoolScene");
}
/// <summary>Generate a scene with the objects of the pools in it foreach (Pool.PoolPrefab p in pool.pools){
/// <para>If this isn't called, the pooler won't work</para> if (!p.undetermined){
/// </summary> if(p.determinedPool == null){
public static void CreatePools(Pool pool) { p.determinedPool = new Queue<GameObject>();
if (pool == null) { }
Debug.LogWarning("You have to provide a pool."); for (int i = 0; i < p.size; i++){
return; GameObject obj = Object.Instantiate(p.prefab);
obj.SetActive(false);
obj.AddComponent<PoolChecker>().poolTag = p.tag;
SceneManager.MoveGameObjectToScene(obj, poolScene);
p.determinedPool.Enqueue(obj);
}
}else{
if(p.undeterminedPool == null){
p.undeterminedPool = new List<GameObject>();
}
} }
poolDictionary.Add(p.tag, p);
}
}
/// <summary>Generate a scene with the objects of the pools in it
/// <para>If this isn't called, the pooler won't work</para>
/// </summary>
public static void CreatePools(Pool[] pools){
if (pools == null){
Debug.LogWarning("You have to provide a pool.");
return;
}
poolDictionary = new Dictionary<string, Pool.PoolPrefab>(); poolDictionary = new Dictionary<string, Pool.PoolPrefab>();
if (SceneManager.GetSceneByName("PoolScene").IsValid()) { if (SceneManager.GetSceneByName("PoolScene").IsValid()){
poolScene = SceneManager.GetSceneByName("PoolScene"); poolScene = SceneManager.GetSceneByName("PoolScene");
} else { }else{
poolScene = SceneManager.CreateScene("PoolScene"); poolScene = SceneManager.CreateScene("PoolScene");
} }
foreach (Pool.PoolPrefab p in pool.pools) { for (int i = 0; i < pools.Length; i++){
if (!p.undetermined) { foreach (Pool.PoolPrefab p in pools[i].pools){
if (p.determinedPool == null) { if (!p.undetermined){
if (p.determinedPool == null){
p.determinedPool = new Queue<GameObject>(); p.determinedPool = new Queue<GameObject>();
} }
for (int i = 0; i < p.size; i++) { for (int j = 0; j < p.size; j++){
GameObject obj = Object.Instantiate(p.prefab); GameObject obj = Object.Instantiate(p.prefab);
obj.SetActive(false); obj.SetActive(false);
obj.AddComponent<PoolChecker>().poolTag = p.tag; obj.AddComponent<PoolChecker>().poolTag = p.tag;
SceneManager.MoveGameObjectToScene(obj, poolScene); SceneManager.MoveGameObjectToScene(obj, poolScene);
p.determinedPool.Enqueue(obj); p.determinedPool.Enqueue(obj);
} }
} else { }else{
if (p.undeterminedPool == null) { if (p.undeterminedPool == null){
p.undeterminedPool = new List<GameObject>(); p.undeterminedPool = new List<GameObject>();
} }
} }
poolDictionary.Add(p.tag, p); poolDictionary.Add(p.tag, p);
} }
} }
/// <summary>Generate a scene with the objects of the pools in it }
/// <para>If this isn't called, the pooler won't work</para> /// <summary>Destroy an object and return it to the pool scene
/// </summary> /// </summary>
public static void CreatePools(Pool[] pools) { public static void Destroy(GameObject gameObject){
if (pools == null) { PoolChecker poolChecker = gameObject.GetComponent<PoolChecker>();
Debug.LogWarning("You have to provide a pool."); if (poolChecker == null){
return; Debug.LogWarning("GameObject: " + gameObject + " isn't from a pool", gameObject);
} return;
poolDictionary = new Dictionary<string, Pool.PoolPrefab>();
if (SceneManager.GetSceneByName("PoolScene").IsValid()) {
poolScene = SceneManager.GetSceneByName("PoolScene");
} else {
poolScene = SceneManager.CreateScene("PoolScene");
}
for (int i = 0; i < pools.Length; i++) {
foreach (Pool.PoolPrefab p in pools[i].pools) {
if (!p.undetermined) {
if (p.determinedPool == null) {
p.determinedPool = new Queue<GameObject>();
}
for (int j = 0; j < p.size; j++) {
GameObject obj = Object.Instantiate(p.prefab);
obj.SetActive(false);
obj.AddComponent<PoolChecker>().poolTag = p.tag;
SceneManager.MoveGameObjectToScene(obj, poolScene);
p.determinedPool.Enqueue(obj);
}
} else {
if (p.undeterminedPool == null) {
p.undeterminedPool = new List<GameObject>();
}
}
poolDictionary.Add(p.tag, p);
}
}
}
/// <summary>Destroy an object and return it to the pool scene
/// </summary>
public static void Destroy(GameObject gameObject) {
PoolChecker poolChecker = gameObject.GetComponent<PoolChecker>();
if (poolChecker == null) {
Debug.LogWarning("GameObject: " + gameObject + " isn't from a pool", gameObject);
return;
}
gameObject.transform.SetParent(null);
SceneManager.MoveGameObjectToScene(gameObject, poolScene);
if (poolDictionary.ContainsKey(poolChecker.poolTag)) {
Pool.PoolPrefab pool = poolDictionary[poolChecker.poolTag];
if (pool.undetermined) {
gameObject.SetActive(false);
pool.undeterminedPool.Remove(gameObject);
} else {
gameObject.SetActive(false);
}
}
} }
/// <summary>Spawn an object into a specific position gameObject.transform.SetParent(null);
/// <para>The CreatePools function must have been called before.</para> SceneManager.MoveGameObjectToScene(gameObject, poolScene);
/// </summary>
public static GameObject SpawnFromPool(string tag, Vector3 position) {
if (!poolDictionary.ContainsKey(tag)) {
Debug.Log("Pool with tag " + tag + " doesn't exist.");
return null;
}
Pool.PoolPrefab pool = poolDictionary[tag]; if (poolDictionary.ContainsKey(poolChecker.poolTag)){
GameObject objectToSpawn; Pool.PoolPrefab pool = poolDictionary[poolChecker.poolTag];
if (!pool.undetermined) { if (pool.undetermined){
objectToSpawn = pool.determinedPool.Dequeue(); gameObject.SetActive(false);
pool.undeterminedPool.Remove(gameObject);
}else{
gameObject.SetActive(false);
}
}
}
/// <summary>Spawn an object into a specific position
/// <para>The CreatePools function must have been called before.</para>
/// </summary>
public static GameObject SpawnFromPool(string tag, Vector3 position){
if (!poolDictionary.ContainsKey(tag)){
Debug.Log("Pool with tag " + tag + " doesn't exist.");
return null;
}
Pool.PoolPrefab pool = poolDictionary[tag];
GameObject objectToSpawn;
if (!pool.undetermined){
objectToSpawn = pool.determinedPool.Dequeue();
objectToSpawn.transform.position = position;
objectToSpawn.transform.rotation = Quaternion.identity;
objectToSpawn.SetActive(true);
pool.determinedPool.Enqueue(objectToSpawn);
}else{
if(pool.undeterminedPool.Count != 0){
int lastIndex = pool.undeterminedPool.Count - 1;
objectToSpawn = pool.undeterminedPool[lastIndex];
objectToSpawn.transform.position = position; objectToSpawn.transform.position = position;
objectToSpawn.transform.rotation = Quaternion.identity; objectToSpawn.transform.rotation = Quaternion.identity;
objectToSpawn.SetActive(true); objectToSpawn.SetActive(true);
}else{
pool.determinedPool.Enqueue(objectToSpawn); objectToSpawn = Object.Instantiate(pool.prefab, position, Quaternion.identity);
} else { SceneManager.MoveGameObjectToScene(objectToSpawn, poolScene);
if (pool.undeterminedPool.Count != 0) { objectToSpawn.AddComponent<PoolChecker>().poolTag = tag;
int lastIndex = pool.undeterminedPool.Count - 1;
objectToSpawn = pool.undeterminedPool[lastIndex];
objectToSpawn.transform.position = position;
objectToSpawn.transform.rotation = Quaternion.identity;
objectToSpawn.SetActive(true);
} else {
objectToSpawn = Object.Instantiate(pool.prefab, position, Quaternion.identity);
SceneManager.MoveGameObjectToScene(objectToSpawn, poolScene);
objectToSpawn.AddComponent<PoolChecker>().poolTag = tag;
}
} }
IPooledObject pooledObj = objectToSpawn.GetComponent<IPooledObject>();
if (pooledObj != null) {
pooledObj.OnObjectSpawn();
}
return objectToSpawn;
} }
/// <summary>Spawn an object into a specific position and parent
/// <para>The CreatePools function must have been called before.</para>
/// </summary>
public static GameObject SpawnFromPool(string tag, Vector3 position, Transform parent) {
if (!poolDictionary.ContainsKey(tag)) {
Debug.Log("Pool with tag " + tag + " doesn't exist.");
return null;
}
Pool.PoolPrefab pool = poolDictionary[tag]; IPooledObject pooledObj = objectToSpawn.GetComponent<IPooledObject>();
GameObject objectToSpawn; if(pooledObj != null){
if (!pool.undetermined) { pooledObj.OnObjectSpawn();
objectToSpawn = pool.determinedPool.Dequeue(); }
return objectToSpawn;
}
/// <summary>Spawn an object into a specific position and parent
/// <para>The CreatePools function must have been called before.</para>
/// </summary>
public static GameObject SpawnFromPool(string tag, Vector3 position, Transform parent){
if (!poolDictionary.ContainsKey(tag)){
Debug.Log("Pool with tag " + tag + " doesn't exist.");
return null;
}
Pool.PoolPrefab pool = poolDictionary[tag];
GameObject objectToSpawn;
if (!pool.undetermined){
objectToSpawn = pool.determinedPool.Dequeue();
objectToSpawn.transform.position = position;
objectToSpawn.transform.rotation = Quaternion.identity;
objectToSpawn.transform.SetParent(parent);
objectToSpawn.SetActive(true);
pool.determinedPool.Enqueue(objectToSpawn);
}else{
if (pool.undeterminedPool.Count != 0){
int lastIndex = pool.undeterminedPool.Count - 1;
objectToSpawn = pool.undeterminedPool[lastIndex];
objectToSpawn.transform.position = position; objectToSpawn.transform.position = position;
objectToSpawn.transform.rotation = Quaternion.identity; objectToSpawn.transform.rotation = Quaternion.identity;
objectToSpawn.transform.SetParent(parent); objectToSpawn.transform.SetParent(parent);
objectToSpawn.SetActive(true); objectToSpawn.SetActive(true);
}else{
pool.determinedPool.Enqueue(objectToSpawn); objectToSpawn = Object.Instantiate(pool.prefab, position, Quaternion.identity, parent);
} else { objectToSpawn.AddComponent<PoolChecker>().poolTag = tag;
if (pool.undeterminedPool.Count != 0) {
int lastIndex = pool.undeterminedPool.Count - 1;
objectToSpawn = pool.undeterminedPool[lastIndex];
objectToSpawn.transform.position = position;
objectToSpawn.transform.rotation = Quaternion.identity;
objectToSpawn.transform.SetParent(parent);
objectToSpawn.SetActive(true);
} else {
objectToSpawn = Object.Instantiate(pool.prefab, position, Quaternion.identity, parent);
objectToSpawn.AddComponent<PoolChecker>().poolTag = tag;
}
} }
IPooledObject pooledObj = objectToSpawn.GetComponent<IPooledObject>();
if (pooledObj != null) {
pooledObj.OnObjectSpawn();
}
return objectToSpawn;
} }
/// <summary>Spawn an object into a specific position, parent and set if it's in world space or not
/// <para>The CreatePools function must have been called before.</para>
/// </summary>
public static GameObject SpawnFromPool(string tag, Vector3 position, Transform parent, bool instantiateInWorldSpace) {
if (!poolDictionary.ContainsKey(tag)) {
Debug.Log("Pool with tag " + tag + " doesn't exist.");
return null;
}
if (!instantiateInWorldSpace) { IPooledObject pooledObj = objectToSpawn.GetComponent<IPooledObject>();
SpawnFromPool(tag, position, parent); if (pooledObj != null){
} pooledObj.OnObjectSpawn();
}
return objectToSpawn;
}
/// <summary>Spawn an object into a specific position, parent and set if it's in world space or not
/// <para>The CreatePools function must have been called before.</para>
/// </summary>
public static GameObject SpawnFromPool(string tag, Vector3 position, Transform parent, bool instantiateInWorldSpace){
if (!poolDictionary.ContainsKey(tag)){
Debug.Log("Pool with tag " + tag + " doesn't exist.");
return null;
}
Pool.PoolPrefab pool = poolDictionary[tag]; if (!instantiateInWorldSpace){
GameObject objectToSpawn; SpawnFromPool(tag, position, parent);
if (!pool.undetermined) { }
objectToSpawn = pool.determinedPool.Dequeue();
Pool.PoolPrefab pool = poolDictionary[tag];
GameObject objectToSpawn;
if (!pool.undetermined){
objectToSpawn = pool.determinedPool.Dequeue();
objectToSpawn.transform.localPosition = position;
objectToSpawn.transform.localRotation = Quaternion.identity;
objectToSpawn.transform.SetParent(parent);
objectToSpawn.SetActive(true);
pool.determinedPool.Enqueue(objectToSpawn);
}else{
if (pool.undeterminedPool.Count != 0){
int lastIndex = pool.undeterminedPool.Count - 1;
objectToSpawn = pool.undeterminedPool[lastIndex];
objectToSpawn.transform.localPosition = position; objectToSpawn.transform.localPosition = position;
objectToSpawn.transform.localRotation = Quaternion.identity; objectToSpawn.transform.localRotation = Quaternion.identity;
objectToSpawn.transform.SetParent(parent); objectToSpawn.transform.SetParent(parent);
objectToSpawn.SetActive(true); objectToSpawn.SetActive(true);
}else{
pool.determinedPool.Enqueue(objectToSpawn); objectToSpawn = Object.Instantiate(pool.prefab);
} else { objectToSpawn.transform.localPosition = position;
if (pool.undeterminedPool.Count != 0) { objectToSpawn.transform.localRotation = Quaternion.identity;
int lastIndex = pool.undeterminedPool.Count - 1; objectToSpawn.transform.SetParent(parent);
objectToSpawn = pool.undeterminedPool[lastIndex]; objectToSpawn.AddComponent<PoolChecker>().poolTag = tag;
objectToSpawn.transform.localPosition = position;
objectToSpawn.transform.localRotation = Quaternion.identity;
objectToSpawn.transform.SetParent(parent);
objectToSpawn.SetActive(true);
} else {
objectToSpawn = Object.Instantiate(pool.prefab);
objectToSpawn.transform.localPosition = position;
objectToSpawn.transform.localRotation = Quaternion.identity;
objectToSpawn.transform.SetParent(parent);
objectToSpawn.AddComponent<PoolChecker>().poolTag = tag;
}
} }
IPooledObject pooledObj = objectToSpawn.GetComponent<IPooledObject>();
if (pooledObj != null) {
pooledObj.OnObjectSpawn();
}
return objectToSpawn;
} }
/// <summary>Spawn an object into a specific position and rotation
/// <para>The CreatePools function must have been called before.</para>
/// </summary>
public static GameObject SpawnFromPool(string tag, Vector3 position, Quaternion rotation) {
if (!poolDictionary.ContainsKey(tag)) {
Debug.Log("Pool with tag " + tag + " doesn't exist.");
return null;
}
Pool.PoolPrefab pool = poolDictionary[tag]; IPooledObject pooledObj = objectToSpawn.GetComponent<IPooledObject>();
GameObject objectToSpawn; if (pooledObj != null){
if (!pool.undetermined) { pooledObj.OnObjectSpawn();
objectToSpawn = pool.determinedPool.Dequeue(); }
return objectToSpawn;
}
/// <summary>Spawn an object into a specific position and rotation
/// <para>The CreatePools function must have been called before.</para>
/// </summary>
public static GameObject SpawnFromPool(string tag, Vector3 position, Quaternion rotation){
if (!poolDictionary.ContainsKey(tag)){
Debug.Log("Pool with tag " + tag + " doesn't exist.");
return null;
}
Pool.PoolPrefab pool = poolDictionary[tag];
GameObject objectToSpawn;
if (!pool.undetermined){
objectToSpawn = pool.determinedPool.Dequeue();
objectToSpawn.transform.position = position;
objectToSpawn.transform.rotation = rotation;
objectToSpawn.SetActive(true);
pool.determinedPool.Enqueue(objectToSpawn);
}else{
if (pool.undeterminedPool.Count != 0){
int lastIndex = pool.undeterminedPool.Count - 1;
objectToSpawn = pool.undeterminedPool[lastIndex];
objectToSpawn.transform.position = position; objectToSpawn.transform.position = position;
objectToSpawn.transform.rotation = rotation; objectToSpawn.transform.rotation = rotation;
objectToSpawn.SetActive(true); objectToSpawn.SetActive(true);
}else{
pool.determinedPool.Enqueue(objectToSpawn); objectToSpawn = Object.Instantiate(pool.prefab, position, rotation);
} else { SceneManager.MoveGameObjectToScene(objectToSpawn, poolScene);
if (pool.undeterminedPool.Count != 0) { objectToSpawn.AddComponent<PoolChecker>().poolTag = tag;
int lastIndex = pool.undeterminedPool.Count - 1;
objectToSpawn = pool.undeterminedPool[lastIndex];
objectToSpawn.transform.position = position;
objectToSpawn.transform.rotation = rotation;
objectToSpawn.SetActive(true);
} else {
objectToSpawn = Object.Instantiate(pool.prefab, position, rotation);
SceneManager.MoveGameObjectToScene(objectToSpawn, poolScene);
objectToSpawn.AddComponent<PoolChecker>().poolTag = tag;
}
} }
IPooledObject pooledObj = objectToSpawn.GetComponent<IPooledObject>();
if (pooledObj != null) {
pooledObj.OnObjectSpawn();
}
return objectToSpawn;
} }
/// <summary>Spawn an object into a specific position, rotation and parent
/// <para>The CreatePools function must have been called before.</para>
/// </summary>
public static GameObject SpawnFromPool(string tag, Vector3 position, Quaternion rotation, Transform parent) {
if (!poolDictionary.ContainsKey(tag)) {
Debug.Log("Pool with tag " + tag + " doesn't exist.");
return null;
}
Pool.PoolPrefab pool = poolDictionary[tag]; IPooledObject pooledObj = objectToSpawn.GetComponent<IPooledObject>();
GameObject objectToSpawn; if (pooledObj != null){
if (!pool.undetermined) { pooledObj.OnObjectSpawn();
objectToSpawn = pool.determinedPool.Dequeue(); }
return objectToSpawn;
}
/// <summary>Spawn an object into a specific position, rotation and parent
/// <para>The CreatePools function must have been called before.</para>
/// </summary>
public static GameObject SpawnFromPool(string tag, Vector3 position, Quaternion rotation, Transform parent){
if (!poolDictionary.ContainsKey(tag)){
Debug.Log("Pool with tag " + tag + " doesn't exist.");
return null;
}
Pool.PoolPrefab pool = poolDictionary[tag];
GameObject objectToSpawn;
if (!pool.undetermined){
objectToSpawn = pool.determinedPool.Dequeue();
objectToSpawn.transform.position = position;
objectToSpawn.transform.rotation = rotation;
objectToSpawn.transform.SetParent(parent);
objectToSpawn.SetActive(true);
pool.determinedPool.Enqueue(objectToSpawn);
}else{
if (pool.undeterminedPool.Count != 0){
int lastIndex = pool.undeterminedPool.Count - 1;
objectToSpawn = pool.undeterminedPool[lastIndex];
objectToSpawn.transform.position = position; objectToSpawn.transform.position = position;
objectToSpawn.transform.rotation = rotation; objectToSpawn.transform.rotation = rotation;
objectToSpawn.transform.SetParent(parent); objectToSpawn.transform.SetParent(parent);
objectToSpawn.SetActive(true); objectToSpawn.SetActive(true);
}else{
pool.determinedPool.Enqueue(objectToSpawn); objectToSpawn = Object.Instantiate(pool.prefab, position, rotation, parent);
} else { objectToSpawn.AddComponent<PoolChecker>().poolTag = tag;
if (pool.undeterminedPool.Count != 0) {
int lastIndex = pool.undeterminedPool.Count - 1;
objectToSpawn = pool.undeterminedPool[lastIndex];
objectToSpawn.transform.position = position;
objectToSpawn.transform.rotation = rotation;
objectToSpawn.transform.SetParent(parent);
objectToSpawn.SetActive(true);
} else {
objectToSpawn = Object.Instantiate(pool.prefab, position, rotation, parent);
objectToSpawn.AddComponent<PoolChecker>().poolTag = tag;
}
} }
IPooledObject pooledObj = objectToSpawn.GetComponent<IPooledObject>();
if (pooledObj != null) {
pooledObj.OnObjectSpawn();
}
return objectToSpawn;
} }
/// <summary>Spawn an object into a specific position, rotation, parent and set if it's in world space or not
/// <para>The CreatePools function must have been called before.</para>
/// </summary>
public static GameObject SpawnFromPool(string tag, Vector3 position, Quaternion rotation, Transform parent, bool instantiateInWorldSpace) {
if (!poolDictionary.ContainsKey(tag)) {
Debug.Log("Pool with tag " + tag + " doesn't exist.");
return null;
}
if (!instantiateInWorldSpace) { IPooledObject pooledObj = objectToSpawn.GetComponent<IPooledObject>();
SpawnFromPool(tag, position, rotation, parent); if (pooledObj != null){
} pooledObj.OnObjectSpawn();
}
return objectToSpawn;
}
/// <summary>Spawn an object into a specific position, rotation, parent and set if it's in world space or not
/// <para>The CreatePools function must have been called before.</para>
/// </summary>
public static GameObject SpawnFromPool(string tag, Vector3 position, Quaternion rotation, Transform parent, bool instantiateInWorldSpace){
if (!poolDictionary.ContainsKey(tag)){
Debug.Log("Pool with tag " + tag + " doesn't exist.");
return null;
}
Pool.PoolPrefab pool = poolDictionary[tag]; if (!instantiateInWorldSpace){
GameObject objectToSpawn; SpawnFromPool(tag, position, rotation, parent);
if (!pool.undetermined) { }
objectToSpawn = pool.determinedPool.Dequeue();
Pool.PoolPrefab pool = poolDictionary[tag];
GameObject objectToSpawn;
if (!pool.undetermined){
objectToSpawn = pool.determinedPool.Dequeue();
objectToSpawn.transform.localPosition = position;
objectToSpawn.transform.localRotation = rotation;
objectToSpawn.transform.SetParent(parent);
objectToSpawn.SetActive(true);
pool.determinedPool.Enqueue(objectToSpawn);
}else{
if (pool.undeterminedPool.Count != 0){
int lastIndex = pool.undeterminedPool.Count - 1;
objectToSpawn = pool.undeterminedPool[lastIndex];
objectToSpawn.transform.localPosition = position; objectToSpawn.transform.localPosition = position;
objectToSpawn.transform.localRotation = rotation; objectToSpawn.transform.localRotation = rotation;
objectToSpawn.transform.SetParent(parent); objectToSpawn.transform.SetParent(parent);
objectToSpawn.SetActive(true); objectToSpawn.SetActive(true);
}else{
pool.determinedPool.Enqueue(objectToSpawn); objectToSpawn = Object.Instantiate(pool.prefab);
} else { objectToSpawn.transform.localPosition = position;
if (pool.undeterminedPool.Count != 0) { objectToSpawn.transform.localRotation = rotation;
int lastIndex = pool.undeterminedPool.Count - 1; objectToSpawn.transform.SetParent(parent);
objectToSpawn = pool.undeterminedPool[lastIndex]; objectToSpawn.AddComponent<PoolChecker>().poolTag = tag;
objectToSpawn.transform.localPosition = position;
objectToSpawn.transform.localRotation = rotation;
objectToSpawn.transform.SetParent(parent);
objectToSpawn.SetActive(true);
} else {
objectToSpawn = Object.Instantiate(pool.prefab);
objectToSpawn.transform.localPosition = position;
objectToSpawn.transform.localRotation = rotation;
objectToSpawn.transform.SetParent(parent);
objectToSpawn.AddComponent<PoolChecker>().poolTag = tag;
}
} }
IPooledObject pooledObj = objectToSpawn.GetComponent<IPooledObject>();
if (pooledObj != null) {
pooledObj.OnObjectSpawn();
}
return objectToSpawn;
} }
IPooledObject pooledObj = objectToSpawn.GetComponent<IPooledObject>();
if (pooledObj != null){
pooledObj.OnObjectSpawn();
}
return objectToSpawn;
} }
} }

98
Tools/SceneManager/Loader.cs
View file

@ -3,69 +3,67 @@ using System.Collections;
using UnityEngine; using UnityEngine;
using UnityEngine.SceneManagement; using UnityEngine.SceneManagement;
namespace SimpleTools.SceneManagement { public static class Loader{
public static class Loader {
class LoadingMonoBehaviour : MonoBehaviour { } class LoadingMonoBehaviour : MonoBehaviour { }
static Action onLoaderCallback; static Action onLoaderCallback;
static AsyncOperation loadingAsyncOperation; static AsyncOperation loadingAsyncOperation;
/// <summary>Load a scene with a loading scene /// <summary>Load a scene with a loading scene
/// <para>It requires a scene called "Loading" where the loading screen is located.</para> /// <para>It requires a scene called "Loading" where the loading screen is located.</para>
/// </summary> /// </summary>
public static void Load(int scene) { public static void Load(int scene){
onLoaderCallback = () => { onLoaderCallback = () => {
GameObject loadingGameObject = new GameObject("LoadingGameObject"); GameObject loadingGameObject = new GameObject("LoadingGameObject");
loadingGameObject.AddComponent<LoadingMonoBehaviour>().StartCoroutine(LoadSceneAsync(scene)); loadingGameObject.AddComponent<LoadingMonoBehaviour>().StartCoroutine(LoadSceneAsync(scene));
}; };
SceneManager.LoadScene("Loading"); SceneManager.LoadScene("Loading");
} }
/// <summary>Load a scene with a loading scene /// <summary>Load a scene with a loading scene
/// <para>It requires a scene called "Loading" where the loading screen is located.</para> /// <para>It requires a scene called "Loading" where the loading screen is located.</para>
/// </summary> /// </summary>
public static void Load(string scene) { public static void Load(string scene){
onLoaderCallback = () => { onLoaderCallback = () => {
GameObject loadingGameObject = new GameObject("LoadingGameObject"); GameObject loadingGameObject = new GameObject("LoadingGameObject");
loadingGameObject.AddComponent<LoadingMonoBehaviour>().StartCoroutine(LoadSceneAsync(scene)); loadingGameObject.AddComponent<LoadingMonoBehaviour>().StartCoroutine(LoadSceneAsync(scene));
}; };
SceneManager.LoadScene("Loading"); SceneManager.LoadScene("Loading");
} }
static IEnumerator LoadSceneAsync(int scene) { static IEnumerator LoadSceneAsync(int scene){
yield return null;
loadingAsyncOperation = SceneManager.LoadSceneAsync(scene);
while (!loadingAsyncOperation.isDone){
yield return null; yield return null;
loadingAsyncOperation = SceneManager.LoadSceneAsync(scene);
while (!loadingAsyncOperation.isDone) {
yield return null;
}
} }
static IEnumerator LoadSceneAsync(string scene) { }
static IEnumerator LoadSceneAsync(string scene){
yield return null;
loadingAsyncOperation = SceneManager.LoadSceneAsync(scene);
while (!loadingAsyncOperation.isDone){
yield return null; yield return null;
loadingAsyncOperation = SceneManager.LoadSceneAsync(scene);
while (!loadingAsyncOperation.isDone) {
yield return null;
}
} }
}
/// <summary>Returns the loading progress /// <summary>Returns the loading progress
/// </summary> /// </summary>
public static float GetLoadingProgress() { public static float GetLoadingProgress(){
if (loadingAsyncOperation != null) { if(loadingAsyncOperation != null){
return loadingAsyncOperation.progress; return loadingAsyncOperation.progress;
} else { }else{
return 0f; return 0f;
}
} }
}
public static void LoaderCallback() { public static void LoaderCallback(){
if (onLoaderCallback != null) { if(onLoaderCallback != null){
onLoaderCallback(); onLoaderCallback();
onLoaderCallback = null; onLoaderCallback = null;
}
} }
} }
} }

16
Tools/SceneManager/LoaderCallback.cs
View file

@ -1,16 +1,14 @@
using UnityEngine; using UnityEngine;
namespace SimpleTools.SceneManagement { public class LoaderCallback : MonoBehaviour{
public class LoaderCallback : MonoBehaviour {
bool isFirstUpdate = true; bool isFirstUpdate = true;
// Update is called once per frame // Update is called once per frame
void Update() { void Update(){
if (isFirstUpdate) { if (isFirstUpdate){
isFirstUpdate = false; isFirstUpdate = false;
Loader.LoaderCallback(); Loader.LoaderCallback();
}
} }
} }
} }

20
Tools/SceneManager/LoadingProgressBar.cs
View file

@ -1,19 +1,17 @@
using UnityEngine; using UnityEngine;
using UnityEngine.UI; using UnityEngine.UI;
namespace SimpleTools.SceneManagement { public class LoadingProgressBar : MonoBehaviour{
public class LoadingProgressBar : MonoBehaviour {
Image image; Image image;
// Start is called before the first frame update // Start is called before the first frame update
void Awake() { void Awake(){
image = transform.GetComponent<Image>(); image = transform.GetComponent<Image>();
} }
// Update is called once per frame // Update is called once per frame
void Update() { void Update(){
image.fillAmount = Loader.GetLoadingProgress(); image.fillAmount = Loader.GetLoadingProgress();
}
} }
} }

8
Tools/Timer.meta
View file

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

99
Tools/Timer/Timer.cs
View file

@ -1,99 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using TMPro;
namespace SimpleTools.Timer{
public class Timer : MonoBehaviour{
float elapsedTime;
public float ElapsedTime { get { return elapsedTime; } }
bool isPaused;
public bool IsPaused { get { return isPaused; } }
TimeSpan timePlaying;
public TimeSpan TimePlaying { get { return timePlaying; } }
TMP_Text timer;
public TMP_Text TimerText { get { return timer; } }
TimerType timerType;
public TimerType TimerType { get { return timerType; } }
TimerUpdate timerUpdate;
public TimerUpdate TimerUpdate { get { return timerUpdate; } }
float defaultTime;
/// <summary>
/// Setup the timer
/// </summary>
public void Setup(float elapsedTime, bool isPaused, TimeSpan timePlaying, TMP_Text timer, TimerType timerType, TimerUpdate timerUpdate, string text){
this.elapsedTime = defaultTime = elapsedTime;
this.isPaused = isPaused;
this.timePlaying = timePlaying;
this.timer = timer;
this.timerType = timerType;
this.timerUpdate = timerUpdate;
timer.text = text;
}
IEnumerator UpdateTimer(){
while (!isPaused){
if(timerType == TimerType.Clock){
timer.text = DateTime.Now.ToString("HH:mm:ss");
}else{
switch (timerType){
case TimerType.Countdown:
elapsedTime -= timerUpdate == TimerUpdate.UnscaledTime ? Time.unscaledDeltaTime : Time.deltaTime;
if(elapsedTime < 0f){
elapsedTime = 0f;
isPaused = true;
}
break;
case TimerType.Stopwatch:
elapsedTime += timerUpdate == TimerUpdate.UnscaledTime ? Time.unscaledDeltaTime : Time.deltaTime;
break;
}
timePlaying = TimeSpan.FromSeconds(elapsedTime);
timer.text = timePlaying.ToString("m':'ss'.'ff");
}
yield return null;
}
}
/// <summary>
/// Play or resume the timer
/// </summary>
public void Play(){
isPaused = false;
StartCoroutine(UpdateTimer());
}
/// <summary>
/// Pause the timer
/// </summary>
public void Stop(){
isPaused = true;
}
/// <summary>
/// Pause and sets the time to the defaultOne
/// </summary>
public void ResetTimer(){
isPaused = true;
elapsedTime = defaultTime;
timePlaying = TimeSpan.FromSeconds(elapsedTime);
timer.text = timePlaying.ToString("m':'ss'.'ff");
}
/// <summary>
/// Restarts the timer
/// </summary>
public void Restart(){
isPaused = false;
elapsedTime = defaultTime;
timePlaying = TimeSpan.FromSeconds(elapsedTime);
timer.text = timePlaying.ToString("m':'ss'.'ff");
StopAllCoroutines();
StartCoroutine(UpdateTimer());
}
}
}

11
Tools/Timer/Timer.cs.meta
View file

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

7
Tools/Timer/TimerType.cs
View file

@ -1,7 +0,0 @@
namespace SimpleTools.Timer{
public enum TimerType{
Countdown,
Stopwatch,
Clock
}
}

11
Tools/Timer/TimerType.cs.meta
View file

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

6
Tools/Timer/TimerUpdate.cs
View file

@ -1,6 +0,0 @@
namespace SimpleTools.Timer{
public enum TimerUpdate{
ScaledTime,
UnscaledTime,
}
}

11
Tools/Timer/TimerUpdate.cs.meta
View file

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

36
Tools/Timer/TimerUtility.cs
View file

@ -1,36 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using TMPro;
namespace SimpleTools.Timer{
public static class TimerUtility {
/// <summary>
/// Setup the timer
/// </summary>
/// <param name="container">TMPro object that will contain the timer</param>
/// <param name="timerType">What type of timer will it be (Countdown, Stopwatch, Clock)</param>
/// <param name="countdownTime">The time that will have in case it is a countdown timer</param>
/// <returns></returns>
public static Timer SetupTimer(this TMP_Text container, TimerType timerType, TimerUpdate timerUpdate, float countdownTime = 60f){
Timer t = container.gameObject.AddComponent<Timer>();
float elapsedTime = 0f;
string text = string.Empty;
TimeSpan timePlaying = TimeSpan.Zero;
switch (timerType){
case TimerType.Countdown:
elapsedTime = countdownTime;
timePlaying = TimeSpan.FromSeconds(elapsedTime);
text = timePlaying.ToString("m':'ss'.'ff");
break;
case TimerType.Clock:
text = DateTime.Now.ToString("HH:mm:ss");
break;
}
t.Setup(elapsedTime, true, timePlaying, container, timerType, timerUpdate, text);
return t;
}
}
}

11
Tools/Timer/TimerUtility.cs.meta
View file

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

2
package.json
View file

@ -1,6 +1,6 @@
{ {
"name": "com.geri.simpletools", "name": "com.geri.simpletools",
"version": "1.3.0", "version": "1.0.1",
"displayName": "Simple Tools", "displayName": "Simple Tools",
"description": "This package contains simple tools to use in your project.", "description": "This package contains simple tools to use in your project.",
"unity": "2018.4", "unity": "2018.4",