You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
514 lines
21 KiB
514 lines
21 KiB
/*
|
|
------------------- Code Monkey -------------------
|
|
|
|
Thank you for downloading the Code Monkey Utilities
|
|
I hope you find them useful in your projects
|
|
If you have any questions use the contact form
|
|
Cheers!
|
|
|
|
unitycodemonkey.com
|
|
--------------------------------------------------
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
using UnityEngine.EventSystems;
|
|
|
|
namespace CodeMonkey.Utils {
|
|
|
|
/*
|
|
* Various assorted utilities functions
|
|
* */
|
|
public static class UtilsClass {
|
|
|
|
private static readonly Vector3 Vector3zero = Vector3.zero;
|
|
private static readonly Vector3 Vector3one = Vector3.one;
|
|
private static readonly Vector3 Vector3yDown = new Vector3(0,-1);
|
|
|
|
public const int sortingOrderDefault = 5000;
|
|
|
|
// Get Sorting order to set SpriteRenderer sortingOrder, higher position = lower sortingOrder
|
|
public static int GetSortingOrder(Vector3 position, int offset, int baseSortingOrder = sortingOrderDefault) {
|
|
return (int)(baseSortingOrder - position.y) + offset;
|
|
}
|
|
|
|
|
|
// Get Main Canvas Transform
|
|
private static Transform cachedCanvasTransform;
|
|
public static Transform GetCanvasTransform() {
|
|
if (cachedCanvasTransform == null) {
|
|
Canvas canvas = MonoBehaviour.FindObjectOfType<Canvas>();
|
|
if (canvas != null) {
|
|
cachedCanvasTransform = canvas.transform;
|
|
}
|
|
}
|
|
return cachedCanvasTransform;
|
|
}
|
|
|
|
// Get Default Unity Font, used in text objects if no font given
|
|
public static Font GetDefaultFont() {
|
|
return Resources.GetBuiltinResource<Font>("Arial.ttf");
|
|
}
|
|
|
|
|
|
// Create a Sprite in the World, no parent
|
|
public static GameObject CreateWorldSprite(string name, Sprite sprite, Vector3 position, Vector3 localScale, int sortingOrder, Color color) {
|
|
return CreateWorldSprite(null, name, sprite, position, localScale, sortingOrder, color);
|
|
}
|
|
|
|
// Create a Sprite in the World
|
|
public static GameObject CreateWorldSprite(Transform parent, string name, Sprite sprite, Vector3 localPosition, Vector3 localScale, int sortingOrder, Color color) {
|
|
GameObject gameObject = new GameObject(name, typeof(SpriteRenderer));
|
|
Transform transform = gameObject.transform;
|
|
transform.SetParent(parent, false);
|
|
transform.localPosition = localPosition;
|
|
transform.localScale = localScale;
|
|
SpriteRenderer spriteRenderer = gameObject.GetComponent<SpriteRenderer>();
|
|
spriteRenderer.sprite = sprite;
|
|
spriteRenderer.sortingOrder = sortingOrder;
|
|
spriteRenderer.color = color;
|
|
return gameObject;
|
|
}
|
|
|
|
// Create a Sprite in the World with Button_Sprite, no parent
|
|
public static Button_Sprite CreateWorldSpriteButton(string name, Sprite sprite, Vector3 localPosition, Vector3 localScale, int sortingOrder, Color color) {
|
|
return CreateWorldSpriteButton(null, name, sprite, localPosition, localScale, sortingOrder, color);
|
|
}
|
|
|
|
// Create a Sprite in the World with Button_Sprite
|
|
public static Button_Sprite CreateWorldSpriteButton(Transform parent, string name, Sprite sprite, Vector3 localPosition, Vector3 localScale, int sortingOrder, Color color) {
|
|
GameObject gameObject = CreateWorldSprite(parent, name, sprite, localPosition, localScale, sortingOrder, color);
|
|
gameObject.AddComponent<BoxCollider2D>();
|
|
Button_Sprite buttonSprite = gameObject.AddComponent<Button_Sprite>();
|
|
return buttonSprite;
|
|
}
|
|
|
|
// Creates a Text Mesh in the World and constantly updates it
|
|
public static FunctionUpdater CreateWorldTextUpdater(Func<string> GetTextFunc, Vector3 localPosition, Transform parent = null) {
|
|
TextMesh textMesh = CreateWorldText(GetTextFunc(), parent, localPosition);
|
|
return FunctionUpdater.Create(() => {
|
|
textMesh.text = GetTextFunc();
|
|
return false;
|
|
}, "WorldTextUpdater");
|
|
}
|
|
|
|
// Create Text in the World
|
|
public static TextMesh CreateWorldText(string text, Transform parent = null, Vector3 localPosition = default(Vector3), int fontSize = 40, Color? color = null, TextAnchor textAnchor = TextAnchor.UpperLeft, TextAlignment textAlignment = TextAlignment.Left, int sortingOrder = sortingOrderDefault) {
|
|
if (color == null) color = Color.white;
|
|
return CreateWorldText(parent, text, localPosition, fontSize, (Color)color, textAnchor, textAlignment, sortingOrder);
|
|
}
|
|
|
|
// Create Text in the World
|
|
public static TextMesh CreateWorldText(Transform parent, string text, Vector3 localPosition, int fontSize, Color color, TextAnchor textAnchor, TextAlignment textAlignment, int sortingOrder) {
|
|
GameObject gameObject = new GameObject("World_Text", typeof(TextMesh));
|
|
Transform transform = gameObject.transform;
|
|
transform.SetParent(parent, false);
|
|
transform.localPosition = localPosition;
|
|
TextMesh textMesh = gameObject.GetComponent<TextMesh>();
|
|
textMesh.anchor = textAnchor;
|
|
textMesh.alignment = textAlignment;
|
|
textMesh.text = text;
|
|
textMesh.fontSize = fontSize;
|
|
textMesh.color = color;
|
|
textMesh.GetComponent<MeshRenderer>().sortingOrder = sortingOrder;
|
|
return textMesh;
|
|
}
|
|
|
|
|
|
// Create a Text Popup in the World, no parent
|
|
public static void CreateWorldTextPopup(string text, Vector3 localPosition) {
|
|
CreateWorldTextPopup(null, text, localPosition, 40, Color.white, localPosition + new Vector3(0, 20), 1f);
|
|
}
|
|
|
|
// Create a Text Popup in the World
|
|
public static void CreateWorldTextPopup(Transform parent, string text, Vector3 localPosition, int fontSize, Color color, Vector3 finalPopupPosition, float popupTime) {
|
|
TextMesh textMesh = CreateWorldText(parent, text, localPosition, fontSize, color, TextAnchor.LowerLeft, TextAlignment.Left, sortingOrderDefault);
|
|
Transform transform = textMesh.transform;
|
|
Vector3 moveAmount = (finalPopupPosition - localPosition) / popupTime;
|
|
FunctionUpdater.Create(delegate () {
|
|
transform.position += moveAmount * Time.deltaTime;
|
|
popupTime -= Time.deltaTime;
|
|
if (popupTime <= 0f) {
|
|
UnityEngine.Object.Destroy(transform.gameObject);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}, "WorldTextPopup");
|
|
}
|
|
|
|
// Create Text Updater in UI
|
|
public static FunctionUpdater CreateUITextUpdater(Func<string> GetTextFunc, Vector2 anchoredPosition) {
|
|
Text text = DrawTextUI(GetTextFunc(), anchoredPosition, 20, GetDefaultFont());
|
|
return FunctionUpdater.Create(() => {
|
|
text.text = GetTextFunc();
|
|
return false;
|
|
}, "UITextUpdater");
|
|
}
|
|
|
|
|
|
// Draw a UI Sprite
|
|
public static RectTransform DrawSprite(Color color, Transform parent, Vector2 pos, Vector2 size, string name = null) {
|
|
RectTransform rectTransform = DrawSprite(null, color, parent, pos, size, name);
|
|
return rectTransform;
|
|
}
|
|
|
|
// Draw a UI Sprite
|
|
public static RectTransform DrawSprite(Sprite sprite, Transform parent, Vector2 pos, Vector2 size, string name = null) {
|
|
RectTransform rectTransform = DrawSprite(sprite, Color.white, parent, pos, size, name);
|
|
return rectTransform;
|
|
}
|
|
|
|
// Draw a UI Sprite
|
|
public static RectTransform DrawSprite(Sprite sprite, Color color, Transform parent, Vector2 pos, Vector2 size, string name = null) {
|
|
// Setup icon
|
|
if (name == null || name == "") name = "Sprite";
|
|
GameObject go = new GameObject(name, typeof(RectTransform), typeof(Image));
|
|
RectTransform goRectTransform = go.GetComponent<RectTransform>();
|
|
goRectTransform.SetParent(parent, false);
|
|
goRectTransform.sizeDelta = size;
|
|
goRectTransform.anchoredPosition = pos;
|
|
|
|
Image image = go.GetComponent<Image>();
|
|
image.sprite = sprite;
|
|
image.color = color;
|
|
|
|
return goRectTransform;
|
|
}
|
|
|
|
public static Text DrawTextUI(string textString, Vector2 anchoredPosition, int fontSize, Font font) {
|
|
return DrawTextUI(textString, GetCanvasTransform(), anchoredPosition, fontSize, font);
|
|
}
|
|
|
|
public static Text DrawTextUI(string textString, Transform parent, Vector2 anchoredPosition, int fontSize, Font font) {
|
|
GameObject textGo = new GameObject("Text", typeof(RectTransform), typeof(Text));
|
|
textGo.transform.SetParent(parent, false);
|
|
Transform textGoTrans = textGo.transform;
|
|
textGoTrans.SetParent(parent, false);
|
|
textGoTrans.localPosition = Vector3zero;
|
|
textGoTrans.localScale = Vector3one;
|
|
|
|
RectTransform textGoRectTransform = textGo.GetComponent<RectTransform>();
|
|
textGoRectTransform.sizeDelta = new Vector2(0,0);
|
|
textGoRectTransform.anchoredPosition = anchoredPosition;
|
|
|
|
Text text = textGo.GetComponent<Text>();
|
|
text.text = textString;
|
|
text.verticalOverflow = VerticalWrapMode.Overflow;
|
|
text.horizontalOverflow = HorizontalWrapMode.Overflow;
|
|
text.alignment = TextAnchor.MiddleLeft;
|
|
if (font == null) font = GetDefaultFont();
|
|
text.font = font;
|
|
text.fontSize = fontSize;
|
|
|
|
return text;
|
|
}
|
|
|
|
|
|
// Parse a float, return default if failed
|
|
public static float Parse_Float(string txt, float _default) {
|
|
float f;
|
|
if (!float.TryParse(txt, out f)) {
|
|
f = _default;
|
|
}
|
|
return f;
|
|
}
|
|
|
|
// Parse a int, return default if failed
|
|
public static int Parse_Int(string txt, int _default) {
|
|
int i;
|
|
if (!int.TryParse(txt, out i)) {
|
|
i = _default;
|
|
}
|
|
return i;
|
|
}
|
|
public static int Parse_Int(string txt) {
|
|
return Parse_Int(txt, -1);
|
|
}
|
|
|
|
|
|
|
|
// Get Mouse Position in World with Z = 0f
|
|
public static Vector3 GetMouseWorldPosition() {
|
|
Vector3 vec = GetMouseWorldPositionWithZ(Input.mousePosition, Camera.main);
|
|
vec.z = 0f;
|
|
return vec;
|
|
}
|
|
public static Vector3 GetMouseWorldPositionWithZ() {
|
|
return GetMouseWorldPositionWithZ(Input.mousePosition, Camera.main);
|
|
}
|
|
public static Vector3 GetMouseWorldPositionWithZ(Camera worldCamera) {
|
|
return GetMouseWorldPositionWithZ(Input.mousePosition, worldCamera);
|
|
}
|
|
public static Vector3 GetMouseWorldPositionWithZ(Vector3 screenPosition, Camera worldCamera) {
|
|
Vector3 worldPosition = worldCamera.ScreenToWorldPoint(screenPosition);
|
|
return worldPosition;
|
|
}
|
|
|
|
|
|
// Is Mouse over a UI Element? Used for ignoring World clicks through UI
|
|
public static bool IsPointerOverUI() {
|
|
if (EventSystem.current.IsPointerOverGameObject()) {
|
|
return true;
|
|
} else {
|
|
PointerEventData pe = new PointerEventData(EventSystem.current);
|
|
pe.position = Input.mousePosition;
|
|
List<RaycastResult> hits = new List<RaycastResult>();
|
|
EventSystem.current.RaycastAll( pe, hits );
|
|
return hits.Count > 0;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Returns 00-FF, value 0->255
|
|
public static string Dec_to_Hex(int value) {
|
|
return value.ToString("X2");
|
|
}
|
|
|
|
// Returns 0-255
|
|
public static int Hex_to_Dec(string hex) {
|
|
return Convert.ToInt32(hex, 16);
|
|
}
|
|
|
|
// Returns a hex string based on a number between 0->1
|
|
public static string Dec01_to_Hex(float value) {
|
|
return Dec_to_Hex((int)Mathf.Round(value*255f));
|
|
}
|
|
|
|
// Returns a float between 0->1
|
|
public static float Hex_to_Dec01(string hex) {
|
|
return Hex_to_Dec(hex)/255f;
|
|
}
|
|
|
|
// Get Hex Color FF00FF
|
|
public static string GetStringFromColor(Color color) {
|
|
string red = Dec01_to_Hex(color.r);
|
|
string green = Dec01_to_Hex(color.g);
|
|
string blue = Dec01_to_Hex(color.b);
|
|
return red+green+blue;
|
|
}
|
|
|
|
// Get Hex Color FF00FFAA
|
|
public static string GetStringFromColorWithAlpha(Color color) {
|
|
string alpha = Dec01_to_Hex(color.a);
|
|
return GetStringFromColor(color)+alpha;
|
|
}
|
|
|
|
// Sets out values to Hex String 'FF'
|
|
public static void GetStringFromColor(Color color, out string red, out string green, out string blue, out string alpha) {
|
|
red = Dec01_to_Hex(color.r);
|
|
green = Dec01_to_Hex(color.g);
|
|
blue = Dec01_to_Hex(color.b);
|
|
alpha = Dec01_to_Hex(color.a);
|
|
}
|
|
|
|
// Get Hex Color FF00FF
|
|
public static string GetStringFromColor(float r, float g, float b) {
|
|
string red = Dec01_to_Hex(r);
|
|
string green = Dec01_to_Hex(g);
|
|
string blue = Dec01_to_Hex(b);
|
|
return red+green+blue;
|
|
}
|
|
|
|
// Get Hex Color FF00FFAA
|
|
public static string GetStringFromColor(float r, float g, float b, float a) {
|
|
string alpha = Dec01_to_Hex(a);
|
|
return GetStringFromColor(r,g,b)+alpha;
|
|
}
|
|
|
|
// Get Color from Hex string FF00FFAA
|
|
public static Color GetColorFromString(string color) {
|
|
float red = Hex_to_Dec01(color.Substring(0,2));
|
|
float green = Hex_to_Dec01(color.Substring(2,2));
|
|
float blue = Hex_to_Dec01(color.Substring(4,2));
|
|
float alpha = 1f;
|
|
if (color.Length >= 8) {
|
|
// Color string contains alpha
|
|
alpha = Hex_to_Dec01(color.Substring(6,2));
|
|
}
|
|
return new Color(red, green, blue, alpha);
|
|
}
|
|
|
|
|
|
// Generate random normalized direction
|
|
public static Vector3 GetRandomDir() {
|
|
return new Vector3(UnityEngine.Random.Range(-1f,1f), UnityEngine.Random.Range(-1f,1f)).normalized;
|
|
}
|
|
|
|
|
|
public static Vector3 GetVectorFromAngle(int angle) {
|
|
// angle = 0 -> 360
|
|
float angleRad = angle * (Mathf.PI/180f);
|
|
return new Vector3(Mathf.Cos(angleRad), Mathf.Sin(angleRad));
|
|
}
|
|
|
|
public static float GetAngleFromVectorFloat(Vector3 dir) {
|
|
dir = dir.normalized;
|
|
float n = Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg;
|
|
if (n < 0) n += 360;
|
|
|
|
return n;
|
|
}
|
|
|
|
public static int GetAngleFromVector(Vector3 dir) {
|
|
dir = dir.normalized;
|
|
float n = Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg;
|
|
if (n < 0) n += 360;
|
|
int angle = Mathf.RoundToInt(n);
|
|
|
|
return angle;
|
|
}
|
|
|
|
public static int GetAngleFromVector180(Vector3 dir) {
|
|
dir = dir.normalized;
|
|
float n = Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg;
|
|
int angle = Mathf.RoundToInt(n);
|
|
|
|
return angle;
|
|
}
|
|
|
|
public static Vector3 ApplyRotationToVector(Vector3 vec, Vector3 vecRotation) {
|
|
return ApplyRotationToVector(vec, GetAngleFromVectorFloat(vecRotation));
|
|
}
|
|
|
|
public static Vector3 ApplyRotationToVector(Vector3 vec, float angle) {
|
|
return Quaternion.Euler(0,0,angle) * vec;
|
|
}
|
|
|
|
|
|
|
|
public static FunctionUpdater CreateMouseDraggingAction(Action<Vector3> onMouseDragging) {
|
|
return CreateMouseDraggingAction(0, onMouseDragging);
|
|
}
|
|
|
|
public static FunctionUpdater CreateMouseDraggingAction(int mouseButton, Action<Vector3> onMouseDragging) {
|
|
bool dragging = false;
|
|
return FunctionUpdater.Create(() => {
|
|
if (Input.GetMouseButtonDown(mouseButton)) {
|
|
dragging = true;
|
|
}
|
|
if (Input.GetMouseButtonUp(mouseButton)) {
|
|
dragging = false;
|
|
}
|
|
if (dragging) {
|
|
onMouseDragging(UtilsClass.GetMouseWorldPosition());
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
|
|
public static FunctionUpdater CreateMouseClickFromToAction(Action<Vector3, Vector3> onMouseClickFromTo, Action<Vector3, Vector3> onWaitingForToPosition) {
|
|
return CreateMouseClickFromToAction(0, 1, onMouseClickFromTo, onWaitingForToPosition);
|
|
}
|
|
|
|
public static FunctionUpdater CreateMouseClickFromToAction(int mouseButton, int cancelMouseButton, Action<Vector3, Vector3> onMouseClickFromTo, Action<Vector3, Vector3> onWaitingForToPosition) {
|
|
int state = 0;
|
|
Vector3 from = Vector3.zero;
|
|
return FunctionUpdater.Create(() => {
|
|
if (state == 1) {
|
|
if (onWaitingForToPosition != null) onWaitingForToPosition(from, UtilsClass.GetMouseWorldPosition());
|
|
}
|
|
if (state == 1 && Input.GetMouseButtonDown(cancelMouseButton)) {
|
|
// Cancel
|
|
state = 0;
|
|
}
|
|
if (Input.GetMouseButtonDown(mouseButton) && !UtilsClass.IsPointerOverUI()) {
|
|
if (state == 0) {
|
|
state = 1;
|
|
from = UtilsClass.GetMouseWorldPosition();
|
|
} else {
|
|
state = 0;
|
|
onMouseClickFromTo(from, UtilsClass.GetMouseWorldPosition());
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
|
|
public static FunctionUpdater CreateMouseClickAction(Action<Vector3> onMouseClick) {
|
|
return CreateMouseClickAction(0, onMouseClick);
|
|
}
|
|
|
|
public static FunctionUpdater CreateMouseClickAction(int mouseButton, Action<Vector3> onMouseClick) {
|
|
return FunctionUpdater.Create(() => {
|
|
if (Input.GetMouseButtonDown(mouseButton)) {
|
|
onMouseClick(GetWorldPositionFromUI());
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
|
|
public static FunctionUpdater CreateKeyCodeAction(KeyCode keyCode, Action onKeyDown) {
|
|
return FunctionUpdater.Create(() => {
|
|
if (Input.GetKeyDown(keyCode)) {
|
|
onKeyDown();
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
|
|
|
|
|
|
// Get UI Position from World Position
|
|
public static Vector2 GetWorldUIPosition(Vector3 worldPosition, Transform parent, Camera uiCamera, Camera worldCamera) {
|
|
Vector3 screenPosition = worldCamera.WorldToScreenPoint(worldPosition);
|
|
Vector3 uiCameraWorldPosition = uiCamera.ScreenToWorldPoint(screenPosition);
|
|
Vector3 localPos = parent.InverseTransformPoint(uiCameraWorldPosition);
|
|
return new Vector2(localPos.x, localPos.y);
|
|
}
|
|
|
|
public static Vector3 GetWorldPositionFromUIZeroZ() {
|
|
Vector3 vec = GetWorldPositionFromUI(Input.mousePosition, Camera.main);
|
|
vec.z = 0f;
|
|
return vec;
|
|
}
|
|
|
|
// Get World Position from UI Position
|
|
public static Vector3 GetWorldPositionFromUI() {
|
|
return GetWorldPositionFromUI(Input.mousePosition, Camera.main);
|
|
}
|
|
|
|
public static Vector3 GetWorldPositionFromUI(Camera worldCamera) {
|
|
return GetWorldPositionFromUI(Input.mousePosition, worldCamera);
|
|
}
|
|
|
|
public static Vector3 GetWorldPositionFromUI(Vector3 screenPosition, Camera worldCamera) {
|
|
Vector3 worldPosition = worldCamera.ScreenToWorldPoint(screenPosition);
|
|
return worldPosition;
|
|
}
|
|
|
|
public static Vector3 GetWorldPositionFromUI_Perspective() {
|
|
return GetWorldPositionFromUI_Perspective(Input.mousePosition, Camera.main);
|
|
}
|
|
|
|
public static Vector3 GetWorldPositionFromUI_Perspective(Camera worldCamera) {
|
|
return GetWorldPositionFromUI_Perspective(Input.mousePosition, worldCamera);
|
|
}
|
|
|
|
public static Vector3 GetWorldPositionFromUI_Perspective(Vector3 screenPosition, Camera worldCamera) {
|
|
Ray ray = worldCamera.ScreenPointToRay(screenPosition);
|
|
Plane xy = new Plane(Vector3.forward, new Vector3(0, 0, 0f));
|
|
float distance;
|
|
xy.Raycast(ray, out distance);
|
|
return ray.GetPoint(distance);
|
|
}
|
|
|
|
|
|
// Screen Shake
|
|
public static void ShakeCamera(float intensity, float timer) {
|
|
Vector3 lastCameraMovement = Vector3.zero;
|
|
FunctionUpdater.Create(delegate () {
|
|
timer -= Time.unscaledDeltaTime;
|
|
Vector3 randomMovement = new Vector3(UnityEngine.Random.Range(-1f, 1f), UnityEngine.Random.Range(-1f, 1f)).normalized * intensity;
|
|
Camera.main.transform.position = Camera.main.transform.position - lastCameraMovement + randomMovement;
|
|
lastCameraMovement = randomMovement;
|
|
return timer <= 0f;
|
|
}, "CAMERA_SHAKE");
|
|
}
|
|
|
|
}
|
|
|
|
}
|