984 lines
32 KiB
C#
984 lines
32 KiB
C#
using System.Linq;
|
|
using UnityEngine;
|
|
|
|
namespace Crosstales.Common.Util
|
|
{
|
|
/// <summary>Base for various helper functions.</summary>
|
|
#if UNITY_EDITOR
|
|
[UnityEditor.InitializeOnLoad]
|
|
#endif
|
|
public abstract class BaseHelper
|
|
{
|
|
#region Variables
|
|
|
|
public static bool ApplicationIsPlaying = Application.isPlaying;
|
|
|
|
protected static readonly System.Random _rnd = new System.Random();
|
|
|
|
private static string[] _args = null;
|
|
|
|
private static int _androidAPILevel = 0;
|
|
|
|
#endregion
|
|
|
|
|
|
#region Properties
|
|
|
|
/// <summary>The current culture of the application.</summary>
|
|
/// <returns>Culture of the application.</returns>
|
|
public static System.Globalization.CultureInfo BaseCulture
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
return new System.Globalization.CultureInfo(LanguageToISO639(Application.systemLanguage));
|
|
}
|
|
catch
|
|
{
|
|
return System.Globalization.CultureInfo.CurrentCulture;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>Checks if we are in Editor mode.</summary>
|
|
/// <returns>True if in Editor mode.</returns>
|
|
public static bool isEditorMode => isEditor && !ApplicationIsPlaying;
|
|
|
|
/// <summary>Checks if the current build target uses IL2CPP.</summary>
|
|
/// <returns>True if the current build target uses IL2CPP.</returns>
|
|
public static bool isIL2CPP
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_EDITOR
|
|
UnityEditor.BuildTarget target = UnityEditor.EditorUserBuildSettings.activeBuildTarget;
|
|
UnityEditor.BuildTargetGroup group = UnityEditor.BuildPipeline.GetBuildTargetGroup(target);
|
|
#if UNITY_2023_1_OR_NEWER
|
|
UnityEditor.Build.NamedBuildTarget nbt = UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(group);
|
|
return UnityEditor.PlayerSettings.GetScriptingBackend(nbt) == UnityEditor.ScriptingImplementation.IL2CPP;
|
|
#else
|
|
return UnityEditor.PlayerSettings.GetScriptingBackend(group) == UnityEditor.ScriptingImplementation.IL2CPP;
|
|
#endif
|
|
#else
|
|
#if ENABLE_IL2CPP
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// <summary>Returns the current platform.</summary>
|
|
/// <returns>The current platform.</returns>
|
|
public static Crosstales.Common.Model.Enum.Platform CurrentPlatform
|
|
{
|
|
get
|
|
{
|
|
if (isWindowsPlatform)
|
|
return Crosstales.Common.Model.Enum.Platform.Windows;
|
|
|
|
if (isMacOSPlatform)
|
|
return Crosstales.Common.Model.Enum.Platform.OSX;
|
|
|
|
if (isLinuxPlatform)
|
|
return Crosstales.Common.Model.Enum.Platform.Linux;
|
|
|
|
if (isAndroidPlatform)
|
|
return Crosstales.Common.Model.Enum.Platform.Android;
|
|
|
|
if (isIOSBasedPlatform)
|
|
return Crosstales.Common.Model.Enum.Platform.IOS;
|
|
|
|
if (isWSABasedPlatform)
|
|
return Crosstales.Common.Model.Enum.Platform.WSA;
|
|
|
|
return isWebPlatform
|
|
? Crosstales.Common.Model.Enum.Platform.Web
|
|
: Crosstales.Common.Model.Enum.Platform.Unsupported;
|
|
}
|
|
}
|
|
|
|
/// <summary>Returns the Android API level of the current device (Android only)".</summary>
|
|
/// <returns>The Android API level of the current device.</returns>
|
|
public static int AndroidAPILevel
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_ANDROID
|
|
if (_androidAPILevel == 0)
|
|
_androidAPILevel = int.Parse(SystemInfo.operatingSystem.Substring(SystemInfo.operatingSystem.IndexOf("-") + 1, 3));
|
|
#endif
|
|
return _androidAPILevel;
|
|
}
|
|
}
|
|
|
|
#region Platforms
|
|
|
|
/// <summary>Checks if the current platform is Windows.</summary>
|
|
/// <returns>True if the current platform is Windows.</returns>
|
|
public static bool isWindowsPlatform
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_STANDALONE_WIN
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// <summary>Checks if the current platform is OSX.</summary>
|
|
/// <returns>True if the current platform is OSX.</returns>
|
|
public static bool isMacOSPlatform
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_STANDALONE_OSX
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// <summary>Checks if the current platform is Linux.</summary>
|
|
/// <returns>True if the current platform is Linux.</returns>
|
|
public static bool isLinuxPlatform
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_STANDALONE_LINUX
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// <summary>Checks if the current platform is standalone (Windows, macOS or Linux).</summary>
|
|
/// <returns>True if the current platform is standalone (Windows, macOS or Linux).</returns>
|
|
public static bool isStandalonePlatform => isWindowsPlatform || isMacOSPlatform || isLinuxPlatform;
|
|
|
|
/// <summary>Checks if the current platform is Android.</summary>
|
|
/// <returns>True if the current platform is Android.</returns>
|
|
public static bool isAndroidPlatform
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_ANDROID
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// <summary>Checks if the current platform is iOS.</summary>
|
|
/// <returns>True if the current platform is iOS.</returns>
|
|
public static bool isIOSPlatform
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_IOS
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// <summary>Checks if the current platform is tvOS.</summary>
|
|
/// <returns>True if the current platform is tvOS.</returns>
|
|
public static bool isTvOSPlatform
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_TVOS
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// <summary>Checks if the current platform is WSA.</summary>
|
|
/// <returns>True if the current platform is WSA.</returns>
|
|
public static bool isWSAPlatform
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_WSA || UNITY_XBOXONE
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// <summary>Checks if the current platform is XboxOne.</summary>
|
|
/// <returns>True if the current platform is XboxOne.</returns>
|
|
public static bool isXboxOnePlatform
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_XBOXONE
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// <summary>Checks if the current platform is PS4.</summary>
|
|
/// <returns>True if the current platform is PS4.</returns>
|
|
public static bool isPS4Platform
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_PS4
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/*
|
|
/// <summary>Checks if the current platform is PS5.</summary>
|
|
/// <returns>True if the current platform is PS5.</returns>
|
|
public static bool isPS5Platform
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_PS5 //TODO does that define exists?
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
}
|
|
*/
|
|
/// <summary>Checks if the current platform is WebGL.</summary>
|
|
/// <returns>True if the current platform is WebGL.</returns>
|
|
public static bool isWebGLPlatform
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_WEBGL
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// <summary>Checks if the current platform is Web (WebPlayer or WebGL).</summary>
|
|
/// <returns>True if the current platform is Web (WebPlayer or WebGL).</returns>
|
|
public static bool isWebPlatform => isWebGLPlatform;
|
|
|
|
/// <summary>Checks if the current platform is Windows-based (Windows standalone, WSA or XboxOne).</summary>
|
|
/// <returns>True if the current platform is Windows-based (Windows standalone, WSA or XboxOne).</returns>
|
|
public static bool isWindowsBasedPlatform => isWindowsPlatform || isWSAPlatform || isXboxOnePlatform;
|
|
|
|
/// <summary>Checks if the current platform is WSA-based (WSA or XboxOne).</summary>
|
|
/// <returns>True if the current platform is WSA-based (WSA or XboxOne).</returns>
|
|
public static bool isWSABasedPlatform => isWSAPlatform || isXboxOnePlatform;
|
|
|
|
/// <summary>Checks if the current platform is Apple-based (macOS standalone, iOS or tvOS).</summary>
|
|
/// <returns>True if the current platform is Apple-based (macOS standalone, iOS or tvOS).</returns>
|
|
public static bool isAppleBasedPlatform => isMacOSPlatform || isIOSPlatform || isTvOSPlatform;
|
|
|
|
/// <summary>Checks if the current platform is iOS-based (iOS or tvOS).</summary>
|
|
/// <returns>True if the current platform is iOS-based (iOS or tvOS).</returns>
|
|
public static bool isIOSBasedPlatform => isIOSPlatform || isTvOSPlatform;
|
|
|
|
/// <summary>Checks if the current platform is mobile (Android and iOS).</summary>
|
|
/// <returns>True if the current platform is mobile (Android and iOS).</returns>
|
|
public static bool isMobilePlatform => isAndroidPlatform || isIOSBasedPlatform;
|
|
|
|
/// <summary>Checks if we are inside the Editor.</summary>
|
|
/// <returns>True if we are inside the Editor.</returns>
|
|
public static bool isEditor => isWindowsEditor || isMacOSEditor || isLinuxEditor;
|
|
|
|
/// <summary>Checks if we are inside the Windows Editor.</summary>
|
|
/// <returns>True if we are inside the Windows Editor.</returns>
|
|
public static bool isWindowsEditor
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_EDITOR_WIN
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// <summary>Checks if we are inside the macOS Editor.</summary>
|
|
/// <returns>True if we are inside the macOS Editor.</returns>
|
|
public static bool isMacOSEditor
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_EDITOR_OSX
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// <summary>Checks if we are inside the Linux Editor.</summary>
|
|
/// <returns>True if we are inside the Linux Editor.</returns>
|
|
public static bool isLinuxEditor
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_EDITOR_LINUX
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
|
|
#region Static block
|
|
|
|
#if UNITY_EDITOR
|
|
static BaseHelper()
|
|
{
|
|
//Debug.Log("Static block");
|
|
initialize();
|
|
}
|
|
#endif
|
|
[RuntimeInitializeOnLoadMethod]
|
|
private static void initialize()
|
|
{
|
|
//Debug.Log("initialize");
|
|
ApplicationIsPlaying = Application.isPlaying;
|
|
/*
|
|
if (!isEditorMode)
|
|
{
|
|
GameObject go = new GameObject("_HelperCT");
|
|
go.AddComponent<HelperCT>();
|
|
GameObject.DontDestroyOnLoad(go);
|
|
}
|
|
*/
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region Public methods
|
|
|
|
/// <summary>Creates a string of characters with a given length.</summary>
|
|
/// <param name="generateChars">Characters to generate the string (if more than one character is used, the generated string will be a randomized result of all characters)</param>
|
|
/// <param name="stringLength">Length of the generated string</param>
|
|
/// <returns>Generated string</returns>
|
|
public static string CreateString(string generateChars, int stringLength)
|
|
{
|
|
if (generateChars != null)
|
|
{
|
|
if (generateChars.Length > 1)
|
|
{
|
|
char[] chars = new char[stringLength];
|
|
|
|
for (int ii = 0; ii < stringLength; ii++)
|
|
{
|
|
chars[ii] = generateChars[_rnd.Next(0, generateChars.Length)];
|
|
}
|
|
|
|
return new string(chars);
|
|
}
|
|
|
|
return generateChars.Length == 1 ? new string(generateChars[0], stringLength) : string.Empty;
|
|
}
|
|
|
|
return string.Empty;
|
|
}
|
|
|
|
/// <summary>Split the given text to lines and return it as list.</summary>
|
|
/// <param name="text">Complete text fragment</param>
|
|
/// <param name="ignoreCommentedLines">Ignore commente lines (optional, default: true)</param>
|
|
/// <param name="skipHeaderLines">Number of skipped header lines (optional, default: 0)</param>
|
|
/// <param name="skipFooterLines">Number of skipped footer lines (optional, default: 0)</param>
|
|
/// <returns>Splitted lines as array</returns>
|
|
public static System.Collections.Generic.List<string> SplitStringToLines(string text,
|
|
bool ignoreCommentedLines = true, int skipHeaderLines = 0, int skipFooterLines = 0)
|
|
{
|
|
System.Collections.Generic.List<string> result = new System.Collections.Generic.List<string>(100);
|
|
|
|
if (string.IsNullOrEmpty(text))
|
|
{
|
|
Debug.LogWarning(
|
|
"Parameter 'text' is null or empty => 'SplitStringToLines()' will return an empty string list.");
|
|
}
|
|
else
|
|
{
|
|
string[] lines = Crosstales.Common.Util.BaseConstants.REGEX_LINEENDINGS.Split(text);
|
|
|
|
for (int ii = 0; ii < lines.Length; ii++)
|
|
{
|
|
if (ii + 1 > skipHeaderLines && ii < lines.Length - skipFooterLines)
|
|
{
|
|
if (!string.IsNullOrEmpty(lines[ii]))
|
|
{
|
|
if (ignoreCommentedLines)
|
|
{
|
|
if (!lines[ii].CTStartsWith("#")) //valid and not disabled line?
|
|
result.Add(lines[ii]);
|
|
}
|
|
else
|
|
{
|
|
result.Add(lines[ii]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>Format byte-value to Human-Readable-Form.</summary>
|
|
/// <param name="bytes">Value in bytes</param>
|
|
/// <param name="useSI">Use SI-system (optional, default: false)</param>
|
|
/// <returns>Formatted byte-value in Human-Readable-Form.</returns>
|
|
public static string FormatBytesToHRF(long bytes, bool useSI = false)
|
|
{
|
|
const string ci = "kMGTPE";
|
|
int index = 0;
|
|
|
|
if (useSI)
|
|
{
|
|
if (-1000 < bytes && bytes < 1000)
|
|
return bytes + " B";
|
|
|
|
while (bytes <= -999_950 || bytes >= 999_950)
|
|
{
|
|
bytes /= 1000;
|
|
index++;
|
|
}
|
|
|
|
return $"{(bytes / 1000f):N2} {ci[index]}B";
|
|
}
|
|
|
|
long absB = bytes == long.MinValue ? long.MaxValue : System.Math.Abs(bytes);
|
|
if (absB < 1024)
|
|
return bytes + " B";
|
|
|
|
long value = absB;
|
|
|
|
for (int i = 40; i >= 0 && absB > 0xfffccccccccccccL >> i; i -= 10)
|
|
{
|
|
value >>= 10;
|
|
index++;
|
|
}
|
|
|
|
value *= System.Math.Sign(bytes);
|
|
|
|
return $"{(value / 1024f):N2} {ci[index]}iB";
|
|
}
|
|
|
|
/// <summary>Format seconds to Human-Readable-Form.</summary>
|
|
/// <param name="seconds">Value in seconds</param>
|
|
/// <returns>Formatted seconds in Human-Readable-Form.</returns>
|
|
public static string FormatSecondsToHRF(double seconds)
|
|
{
|
|
bool wasMinus = seconds < 0;
|
|
|
|
int totalSeconds = Mathf.Abs((int)seconds);
|
|
int calcSeconds = totalSeconds % 60;
|
|
|
|
if (seconds >= 86400)
|
|
{
|
|
int calcDays = totalSeconds / 86400;
|
|
int calcHours = (totalSeconds -= calcDays * 86400) / 3600;
|
|
int calcMinutes = (totalSeconds - calcHours * 3600) / 60;
|
|
|
|
return $"{(wasMinus ? "-" : "")}{calcDays}d {calcHours}:{addLeadingZero(calcMinutes)}:{addLeadingZero(calcSeconds)}";
|
|
}
|
|
|
|
if (seconds >= 3600)
|
|
{
|
|
int calcHours = totalSeconds / 3600;
|
|
int calcMinutes = (totalSeconds - calcHours * 3600) / 60;
|
|
|
|
return $"{(wasMinus ? "-" : "")}{calcHours}:{addLeadingZero(calcMinutes)}:{addLeadingZero(calcSeconds)}";
|
|
}
|
|
else
|
|
{
|
|
int calcMinutes = totalSeconds / 60;
|
|
|
|
return $"{(wasMinus ? "-" : "")}{calcMinutes}:{addLeadingZero(calcSeconds)}";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generate nice HSV colors.
|
|
/// Based on https://gist.github.com/rje/6206099
|
|
/// </summary>
|
|
/// <param name="h">Hue</param>
|
|
/// <param name="s">Saturation</param>
|
|
/// <param name="v">Value</param>
|
|
/// <param name="a">Alpha (optional)</param>
|
|
/// <returns>True if the current platform is supported.</returns>
|
|
public static Color HSVToRGB(float h, float s, float v, float a = 1f)
|
|
{
|
|
if (s < Crosstales.Common.Util.BaseConstants.FLOAT_TOLERANCE)
|
|
return new Color(v, v, v, a);
|
|
|
|
float _h = h / 60f;
|
|
int sector = Mathf.FloorToInt(_h);
|
|
float fact = _h - sector;
|
|
float p = v * (1f - s);
|
|
float q = v * (1f - s * fact);
|
|
float t = v * (1f - s * (1f - fact));
|
|
|
|
switch (sector)
|
|
{
|
|
case 0:
|
|
return new Color(v, t, p, a);
|
|
case 1:
|
|
return new Color(q, v, p, a);
|
|
case 2:
|
|
return new Color(p, v, t, a);
|
|
case 3:
|
|
return new Color(p, q, v, a);
|
|
case 4:
|
|
return new Color(t, p, v, a);
|
|
default:
|
|
return new Color(v, p, q, a);
|
|
}
|
|
}
|
|
|
|
/// <summary>Generates a "Lorem Ipsum" based on various parameters.</summary>
|
|
/// <param name="length">Length of the text</param>
|
|
/// <param name="minSentences">Minimum number of sentences for the text (optional, default: 1)</param>
|
|
/// <param name="maxSentences">Maximal number of sentences for the text (optional, default: int.MaxValue)</param>
|
|
/// <param name="minWords">Minimum number of words per sentence (optional, default: 1)</param>
|
|
/// <param name="maxWords">Maximal number of words per sentence (optional, default: 15)</param>
|
|
/// <returns>"Lorem Ipsum" based on the given parameters.</returns>
|
|
public static string GenerateLoremIpsum(int length, int minSentences = 1, int maxSentences = int.MaxValue, int minWords = 1, int maxWords = 15)
|
|
{
|
|
string[] words =
|
|
{
|
|
"lorem", "ipsum", "dolor", "sit", "amet", "consectetuer", "adipiscing", "elit", "sed", "diam",
|
|
"nonummy", "nibh", "euismod", "tincidunt", "ut", "laoreet", "dolore", "magna", "aliquam", "erat"
|
|
};
|
|
|
|
int numSentences = _rnd.Next(maxSentences - minSentences) + minSentences + 1;
|
|
|
|
System.Text.StringBuilder result = new System.Text.StringBuilder();
|
|
|
|
for (int s = 0; s < numSentences && result.Length <= length; s++)
|
|
{
|
|
int numWords = _rnd.Next(maxWords - minWords) + minWords + 1;
|
|
for (int w = 0; w < numWords && result.Length <= length; w++)
|
|
{
|
|
if (w > 0)
|
|
result.Append(" ");
|
|
|
|
result.Append(
|
|
w == 0 ? words[_rnd.Next(words.Length)].CTToTitleCase() : words[_rnd.Next(words.Length)]);
|
|
}
|
|
|
|
result.Append(". ");
|
|
}
|
|
|
|
string text = result.ToString();
|
|
|
|
if (length > 0 && text.Length > length)
|
|
text = text.Substring(0, length - 1) + ".";
|
|
|
|
return text;
|
|
}
|
|
|
|
/// <summary>Converts a SystemLanguage to an ISO639-1 code. Returns "en" if the SystemLanguage could not be converted.</summary>
|
|
/// <param name="language">SystemLanguage to convert.</param>
|
|
/// <returns>"ISO639-1 code for the given SystemLanguage.</returns>
|
|
public static string LanguageToISO639(SystemLanguage language)
|
|
{
|
|
switch (language)
|
|
{
|
|
case SystemLanguage.Afrikaans:
|
|
return "af";
|
|
case SystemLanguage.Arabic:
|
|
return "ar";
|
|
case SystemLanguage.Basque:
|
|
return "eu";
|
|
case SystemLanguage.Belarusian:
|
|
return "be";
|
|
case SystemLanguage.Bulgarian:
|
|
return "bg";
|
|
case SystemLanguage.Catalan:
|
|
return "ca";
|
|
case SystemLanguage.ChineseSimplified:
|
|
case SystemLanguage.ChineseTraditional:
|
|
case SystemLanguage.Chinese:
|
|
return "zh";
|
|
case SystemLanguage.Czech:
|
|
return "cs";
|
|
case SystemLanguage.Danish:
|
|
return "da";
|
|
case SystemLanguage.Dutch:
|
|
return "nl";
|
|
case SystemLanguage.English:
|
|
return "en";
|
|
case SystemLanguage.Estonian:
|
|
return "et";
|
|
case SystemLanguage.Faroese:
|
|
return "fo";
|
|
case SystemLanguage.Finnish:
|
|
return "fi";
|
|
case SystemLanguage.French:
|
|
return "fr";
|
|
case SystemLanguage.German:
|
|
return "de";
|
|
case SystemLanguage.Greek:
|
|
return "el";
|
|
case SystemLanguage.Hebrew:
|
|
return "he";
|
|
case SystemLanguage.Hungarian:
|
|
return "hu";
|
|
case SystemLanguage.Icelandic:
|
|
return "is";
|
|
case SystemLanguage.Indonesian:
|
|
return "id";
|
|
case SystemLanguage.Italian:
|
|
return "it";
|
|
case SystemLanguage.Japanese:
|
|
return "ja";
|
|
case SystemLanguage.Korean:
|
|
return "ko";
|
|
case SystemLanguage.Latvian:
|
|
return "lv";
|
|
case SystemLanguage.Lithuanian:
|
|
return "lt";
|
|
case SystemLanguage.Norwegian:
|
|
return "nb";
|
|
//return "no";
|
|
case SystemLanguage.Polish:
|
|
return "pl";
|
|
case SystemLanguage.Portuguese:
|
|
return "pt";
|
|
case SystemLanguage.Romanian:
|
|
return "ro";
|
|
case SystemLanguage.Russian:
|
|
return "ru";
|
|
//case SystemLanguage.SerboCroatian:
|
|
// return "sh";
|
|
case SystemLanguage.Slovak:
|
|
return "sk";
|
|
case SystemLanguage.Slovenian:
|
|
return "sl";
|
|
case SystemLanguage.Spanish:
|
|
return "es";
|
|
case SystemLanguage.Swedish:
|
|
return "sv";
|
|
case SystemLanguage.Thai:
|
|
return "th";
|
|
case SystemLanguage.Turkish:
|
|
return "tr";
|
|
case SystemLanguage.Ukrainian:
|
|
return "uk";
|
|
case SystemLanguage.Vietnamese:
|
|
return "vi";
|
|
default:
|
|
return "en";
|
|
}
|
|
}
|
|
|
|
/// <summary>Converts an ISO639-1 code to a SystemLanguage. Returns SystemLanguage.English if the code could not be converted.</summary>
|
|
/// <param name="isoCode">ISO639-1 code to convert.</param>
|
|
/// <returns>"SystemLanguage for the given ISO639-1 code.</returns>
|
|
public static SystemLanguage ISO639ToLanguage(string isoCode)
|
|
{
|
|
if (!string.IsNullOrEmpty(isoCode) && isoCode.Length >= 2)
|
|
{
|
|
string code = isoCode.Substring(0, 2).ToLower();
|
|
|
|
switch (code)
|
|
{
|
|
case "af":
|
|
return SystemLanguage.Afrikaans;
|
|
case "ar":
|
|
return SystemLanguage.Arabic;
|
|
case "eu":
|
|
return SystemLanguage.Basque;
|
|
case "be":
|
|
return SystemLanguage.Belarusian;
|
|
case "bg":
|
|
return SystemLanguage.Bulgarian;
|
|
case "ca":
|
|
return SystemLanguage.Catalan;
|
|
case "zh":
|
|
return SystemLanguage.Chinese;
|
|
case "cs":
|
|
return SystemLanguage.Czech;
|
|
case "da":
|
|
return SystemLanguage.Danish;
|
|
case "nl":
|
|
return SystemLanguage.Dutch;
|
|
case "en":
|
|
return SystemLanguage.English;
|
|
case "et":
|
|
return SystemLanguage.Estonian;
|
|
case "fo":
|
|
return SystemLanguage.Faroese;
|
|
case "fi":
|
|
return SystemLanguage.Finnish;
|
|
case "fr":
|
|
return SystemLanguage.French;
|
|
case "de":
|
|
return SystemLanguage.German;
|
|
case "el":
|
|
return SystemLanguage.Greek;
|
|
case "he":
|
|
return SystemLanguage.Hebrew;
|
|
case "hu":
|
|
return SystemLanguage.Hungarian;
|
|
case "is":
|
|
return SystemLanguage.Icelandic;
|
|
case "id":
|
|
return SystemLanguage.Indonesian;
|
|
case "it":
|
|
return SystemLanguage.Italian;
|
|
case "ja":
|
|
return SystemLanguage.Japanese;
|
|
case "ko":
|
|
return SystemLanguage.Korean;
|
|
case "lv":
|
|
return SystemLanguage.Latvian;
|
|
case "lt":
|
|
return SystemLanguage.Lithuanian;
|
|
case "no":
|
|
case "nb":
|
|
return SystemLanguage.Norwegian;
|
|
case "pl":
|
|
return SystemLanguage.Polish;
|
|
case "pt":
|
|
return SystemLanguage.Portuguese;
|
|
case "ro":
|
|
return SystemLanguage.Romanian;
|
|
case "ru":
|
|
return SystemLanguage.Russian;
|
|
//case "sh":
|
|
// return SystemLanguage.SerboCroatian;
|
|
case "sk":
|
|
return SystemLanguage.Slovak;
|
|
case "sl":
|
|
return SystemLanguage.Slovenian;
|
|
case "es":
|
|
return SystemLanguage.Spanish;
|
|
case "sv":
|
|
return SystemLanguage.Swedish;
|
|
case "th":
|
|
return SystemLanguage.Thai;
|
|
case "tr":
|
|
return SystemLanguage.Turkish;
|
|
case "uk":
|
|
return SystemLanguage.Ukrainian;
|
|
case "vi":
|
|
return SystemLanguage.Vietnamese;
|
|
default:
|
|
return SystemLanguage.English;
|
|
}
|
|
}
|
|
|
|
return SystemLanguage.English;
|
|
}
|
|
|
|
/// <summary>Invokes a public static method on a full qualified class.</summary>
|
|
/// <param name="className">Full qualified name of the class</param>
|
|
/// <param name="methodName">Public static method of the class to execute</param>
|
|
/// <param name="parameters">Parameters for the method (optional)</param>
|
|
public static object InvokeMethod(string className, string methodName, params object[] parameters)
|
|
{
|
|
#if UNITY_WSA
|
|
return null;
|
|
#else
|
|
if (string.IsNullOrEmpty(className))
|
|
{
|
|
Debug.LogWarning("'className' is null or empty; can not execute.");
|
|
return null;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(methodName))
|
|
{
|
|
Debug.LogWarning("'methodName' is null or empty; can not execute.");
|
|
return null;
|
|
}
|
|
|
|
foreach (System.Type type in System.AppDomain.CurrentDomain.GetAssemblies()
|
|
.SelectMany(assembly => assembly.GetTypes()))
|
|
{
|
|
try
|
|
{
|
|
if (type.FullName?.Equals(className) == true)
|
|
if (type.IsClass)
|
|
return type.GetMethod(methodName, System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public)?.Invoke(null, parameters);
|
|
}
|
|
catch (System.Exception ex)
|
|
{
|
|
Debug.LogWarning($"Could not execute method call: {ex}");
|
|
}
|
|
}
|
|
|
|
return null;
|
|
#endif
|
|
}
|
|
|
|
/// <summary>Returns an argument for a name from the url or command line.</summary>
|
|
/// <param name="name">Name for the argument</param>
|
|
/// <returns>Argument for a name from the url or command line.</returns>
|
|
public static string GetArgument(string name)
|
|
{
|
|
if (!string.IsNullOrEmpty(name))
|
|
{
|
|
string[] args = GetArguments();
|
|
|
|
for (int ii = 0; ii < args.Length; ii++)
|
|
{
|
|
if (name.CTEquals(args[ii]) && args.Length > ii + 1)
|
|
return args[ii + 1];
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Returns all arguments from the url or command line.</summary>
|
|
/// <returns>Arguments from the url or command line.</returns>
|
|
public static string[] GetArguments()
|
|
{
|
|
if (_args == null)
|
|
{
|
|
#if UNITY_WEBGL && !UNITY_EDITOR
|
|
//#if (UNITY_WEBGL || UNITY_ANDROID) && !UNITY_EDITOR
|
|
// url with parameters syntax : http://example.com?arg1=value1&arg2=value2
|
|
string parameters = Application.absoluteURL.Substring(Application.absoluteURL.IndexOf("?") + 1);
|
|
|
|
//Debug.Log("URL parameters: " + parameters);
|
|
_args = parameters.Split(new char[] { '&', '=' });
|
|
#else
|
|
#if !UNITY_WSA
|
|
_args = System.Environment.GetCommandLineArgs();
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
return _args;
|
|
}
|
|
|
|
/*
|
|
/// <summary>Generates a string of all latin latin characters (ABC...xyz).</summary>
|
|
/// <returns>"String of all latin latin characters.</returns>
|
|
public static string GenerateLatinABC()
|
|
{
|
|
return GenerateLatinUppercaseABC() + GenerateLatinLowercaseABC();
|
|
}
|
|
|
|
/// <summary>Generates a string of all latin latin characters in uppercase (ABC...XYZ).</summary>
|
|
/// <returns>"String of all latin latin characters in uppercase.</returns>
|
|
public static string GenerateLatinUppercaseABC()
|
|
{
|
|
System.Text.StringBuilder result = new System.Text.StringBuilder();
|
|
|
|
for (int ii = 65; ii <= 90; ii++)
|
|
{
|
|
result.Append((char)ii);
|
|
}
|
|
|
|
return result.ToString();
|
|
}
|
|
|
|
/// <summary>Generates a string of all latin latin characters in lowercase (abc...xyz).</summary>
|
|
/// <returns>"String of all latin latin characters in lowercase.</returns>
|
|
public static string GenerateLatinLowercaseABC()
|
|
{
|
|
System.Text.StringBuilder result = new System.Text.StringBuilder();
|
|
|
|
for (int ii = 97; ii <= 122; ii++)
|
|
{
|
|
result.Append((char)ii);
|
|
}
|
|
|
|
return result.ToString();
|
|
}
|
|
*/
|
|
|
|
#endregion
|
|
|
|
|
|
#region Private methods
|
|
|
|
private static string addLeadingZero(int value)
|
|
{
|
|
return value < 10 ? "0" + value : value.ToString();
|
|
}
|
|
|
|
#endregion
|
|
|
|
// StringHelper
|
|
/*
|
|
public static byte[] GetBytesFromText(string text) {
|
|
return new UnicodeEncoding().GetBytes(text);
|
|
}
|
|
|
|
public static string GetTextFromBytes(byte[] bytes) {
|
|
return new UnicodeEncoding().GetString(bytes, 0, bytes.Length);
|
|
}
|
|
|
|
public static byte[] GetBytesFromBase64(string text) {
|
|
return Convert.FromBase64String(text);
|
|
}
|
|
|
|
public static string GetBase64FromBytes(byte[] bytes) {
|
|
return Convert.ToBase64String(bytes);
|
|
}
|
|
*/
|
|
|
|
|
|
// MathHelper
|
|
/*
|
|
public static bool IsInRange(float actValue, float refValue, float range) {
|
|
|
|
return (actValue >= refValue-range) && (actValue <= refValue+range);
|
|
}
|
|
|
|
|
|
public static bool IsInRange(int actValue, int refValue, int range) {
|
|
|
|
return (actValue >= refValue-range) && (actValue <= refValue+range);
|
|
}
|
|
*/
|
|
|
|
|
|
// Add Math3dHelper?
|
|
|
|
|
|
// Color Helper
|
|
/*
|
|
public static Color HexToColor(string hex)
|
|
{
|
|
if (string.IsNullOrEmpty(hex))
|
|
throw new ArgumentNullException("hex");
|
|
|
|
byte r = byte.Parse(hex.Substring(0, 2), System.Globalization.NumberStyles.HexNumber);
|
|
byte g = byte.Parse(hex.Substring(2, 2), System.Globalization.NumberStyles.HexNumber);
|
|
byte b = byte.Parse(hex.Substring(4, 2), System.Globalization.NumberStyles.HexNumber);
|
|
return new Color32(r, g, b, 255);
|
|
}
|
|
*/
|
|
}
|
|
}
|
|
// © 2015-2023 crosstales LLC (https://www.crosstales.com) |