diff --git a/_DOTween.Assembly/DOTween/DOTween.cs b/_DOTween.Assembly/DOTween/DOTween.cs index 73b5320..792803f 100644 --- a/_DOTween.Assembly/DOTween/DOTween.cs +++ b/_DOTween.Assembly/DOTween/DOTween.cs @@ -21,7 +21,7 @@ namespace DG.Tweening public class DOTween { /// DOTween's version - public static readonly string Version = "1.0.405"; + public static readonly string Version = "1.0.410"; /////////////////////////////////////////////// // Options //////////////////////////////////// @@ -129,34 +129,31 @@ namespace DG.Tweening if (initialized) return instance; if (!Application.isPlaying || isQuitting) return null; - bool doRecycleAllByDefault = recycleAllByDefault == null ? false : (bool)recycleAllByDefault; - bool doUseSafeMode = useSafeMode == null ? true : (bool)useSafeMode; - LogBehaviour doLogBehaviour = logBehaviour == null ? LogBehaviour.ErrorsOnly : (LogBehaviour)logBehaviour; DOTweenSettings settings = Resources.Load(DOTweenSettings.AssetName) as DOTweenSettings; - return Init(settings, doRecycleAllByDefault, doUseSafeMode, doLogBehaviour); + return Init(settings, recycleAllByDefault, useSafeMode, logBehaviour); } // Auto-init static void AutoInit() { DOTweenSettings settings = Resources.Load(DOTweenSettings.AssetName) as DOTweenSettings; - if (settings == null) Init(null, defaultRecyclable, useSafeMode, logBehaviour); - else Init(settings, settings.defaultRecyclable, settings.useSafeMode, settings.logBehaviour); + Init(settings, null, null, null); } // Full init - static IDOTweenInit Init(DOTweenSettings settings, bool recycleAllByDefault, bool useSafeMode, LogBehaviour logBehaviour) + static IDOTweenInit Init(DOTweenSettings settings, bool? recycleAllByDefault, bool? useSafeMode, LogBehaviour? logBehaviour) { initialized = true; // Options - DOTween.defaultRecyclable = recycleAllByDefault; - DOTween.useSafeMode = useSafeMode; - DOTween.logBehaviour = logBehaviour; + if (recycleAllByDefault != null) DOTween.defaultRecyclable = (bool)recycleAllByDefault; + if (useSafeMode != null) DOTween.useSafeMode = (bool)useSafeMode; + if (logBehaviour != null) DOTween.logBehaviour = (LogBehaviour)logBehaviour; // Gameobject - also assign instance DOTweenComponent.Create(); // Assign settings if (settings != null) { -// DOTween.useSafeMode = settings.useSafeMode; -// DOTween.logBehaviour = settings.logBehaviour; -// DOTween.defaultRecyclable = settings.defaultRecyclable; + if (useSafeMode == null) DOTween.useSafeMode = settings.useSafeMode; + if (logBehaviour == null) DOTween.logBehaviour = settings.logBehaviour; + if (recycleAllByDefault == null) DOTween.defaultRecyclable = settings.defaultRecyclable; + DOTween.defaultRecyclable = recycleAllByDefault == null ? settings.defaultRecyclable : (bool)recycleAllByDefault; DOTween.showUnityEditorReport = settings.showUnityEditorReport; DOTween.defaultAutoPlay = settings.defaultAutoPlay; DOTween.defaultUpdateType = settings.defaultUpdateType; @@ -168,7 +165,7 @@ namespace DG.Tweening DOTween.defaultLoopType = settings.defaultLoopType; } // Log - if (Debugger.logPriority >= 2) Debugger.Log("DOTween initialization (useSafeMode: " + useSafeMode + ", logBehaviour: " + logBehaviour + ")"); + if (Debugger.logPriority >= 2) Debugger.Log("DOTween initialization (useSafeMode: " + DOTween.useSafeMode + ", recycling: " + (DOTween.defaultRecyclable ? "ON" : "OFF") + ", logBehaviour: " + DOTween.logBehaviour + ")"); return instance; } @@ -827,9 +824,7 @@ namespace DG.Tweening { if (initialized || !Application.isPlaying || isQuitting) return; -// Init(defaultRecyclable, useSafeMode, logBehaviour); AutoInit(); -// Debugger.LogWarning("DOTween auto-initialized with default settings (recycleAllByDefault: " + defaultRecyclable + ", useSafeMode: " + useSafeMode + ", logBehaviour: " + logBehaviour + "). Call DOTween.Init before creating your first tween in order to choose the settings yourself"); } static TweenerCore ApplyTo( diff --git a/_DOTween.Assembly/DOTween/DOTween.csproj b/_DOTween.Assembly/DOTween/DOTween.csproj index 7255990..c42e8c1 100644 --- a/_DOTween.Assembly/DOTween/DOTween.csproj +++ b/_DOTween.Assembly/DOTween/DOTween.csproj @@ -81,6 +81,7 @@ + diff --git a/_DOTween.Assembly/DOTween/Plugins/Options/StringOptions.cs b/_DOTween.Assembly/DOTween/Plugins/Options/StringOptions.cs index ba7c62c..882339b 100644 --- a/_DOTween.Assembly/DOTween/Plugins/Options/StringOptions.cs +++ b/_DOTween.Assembly/DOTween/Plugins/Options/StringOptions.cs @@ -9,7 +9,11 @@ namespace DG.Tweening.Plugins.Options { public struct StringOptions { - public bool scramble; + public bool richTextEnabled; + public ScrambleMode scrambleMode; public char[] scrambledChars; // If empty uses default scramble characters + + // Stored by StringPlugin + internal int startValueStrippedLength, changeValueStrippedLength; // No-tag lengths of start and change value } } \ No newline at end of file diff --git a/_DOTween.Assembly/DOTween/Plugins/StringPlugin.cs b/_DOTween.Assembly/DOTween/Plugins/StringPlugin.cs index 6d2e14a..032f6c2 100644 --- a/_DOTween.Assembly/DOTween/Plugins/StringPlugin.cs +++ b/_DOTween.Assembly/DOTween/Plugins/StringPlugin.cs @@ -6,6 +6,7 @@ using System; using System.Text; +using System.Text.RegularExpressions; using DG.Tweening.Core; using DG.Tweening.Core.Easing; using DG.Tweening.Plugins.Core; @@ -47,6 +48,10 @@ namespace DG.Tweening.Plugins public override void SetChangeValue(TweenerCore t) { t.changeValue = t.endValue; + + // Store no-tags versions of values + t.plugOptions.startValueStrippedLength = Regex.Replace(t.startValue, @"<[^>]*>", "").Length; + t.plugOptions.changeValueStrippedLength = Regex.Replace(t.changeValue, @"<[^>]*>", "").Length; } public override float GetSpeedBasedDuration(StringOptions options, float unitsXSecond, string changeValue) @@ -73,24 +78,24 @@ namespace DG.Tweening.Plugins } } - int startValueLen = startValue.Length; - int changeValueLen = changeValue.Length; + int startValueLen = options.richTextEnabled ? options.startValueStrippedLength : startValue.Length; + int changeValueLen = options.richTextEnabled ? options.changeValueStrippedLength : changeValue.Length; int len = (int)Math.Round(changeValueLen * EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod)); if (len > changeValueLen) len = changeValueLen; else if (len < 0) len = 0; if (isRelative) { _Buffer.Append(startValue); - if (options.scramble) { - setter(_Buffer.Append(changeValue, 0, len).AppendScrambledChars(changeValueLen - len, options.scrambledChars ?? StringPluginExtensions.ScrambledChars).ToString()); + if (options.scrambleMode != ScrambleMode.None) { + setter(_Buffer.Append(changeValue, 0, len).AppendScrambledChars(changeValueLen - len, ScrambledCharsToUse(options)).ToString()); return; } setter(_Buffer.Append(changeValue, 0, len).ToString()); return; } - if (options.scramble) { - setter(_Buffer.Append(changeValue, 0, len).AppendScrambledChars(changeValueLen - len, options.scrambledChars ?? StringPluginExtensions.ScrambledChars).ToString()); + if (options.scrambleMode != ScrambleMode.None) { + setter(_Buffer.Append(changeValue, 0, len).AppendScrambledChars(changeValueLen - len, ScrambledCharsToUse(options)).ToString()); return; } @@ -101,10 +106,125 @@ namespace DG.Tweening.Plugins float perc = (float)len / changeValueLen; startValueMaxLen -= (int)(startValueMaxLen * perc); } else startValueMaxLen -= len; - _Buffer.Append(changeValue, 0, len); - if (len < changeValueLen && len < startValueLen) _Buffer.Append(startValue, len, startValueMaxLen); + Append(changeValue, 0, len, options.richTextEnabled); + if (len < changeValueLen && len < startValueLen) Append(startValue, len, options.richTextEnabled ? len + startValueMaxLen : startValueMaxLen, options.richTextEnabled); setter(_Buffer.ToString()); } + + // Manages eventual rich text, if enabled, readding tags to the given string and closing them when necessary + void Append(string value, int startIndex, int length, bool richTextEnabled) + { + if (!richTextEnabled) { + _Buffer.Append(value, startIndex, length); + return; + } + + const string tagMatch = @"<.*?(>)"; + const string closeTagMatch = @"("; + bool hasOpenTag = false; + int fullLen = value.Length; + int i; + for (i = 0; i < length; ++i) { + Char c = value[i]; + if (c == '<') { + bool hadOpenTag = hasOpenTag; + hasOpenTag = !(i < fullLen - 1 && value[i + 1] == '/'); + string s = value.Substring(i); + Match m = Regex.Match(s, tagMatch); + if (m.Success) { + if (!hasOpenTag && !hadOpenTag) { + // We have a closing tag without an opening tag, try to find opening tag an apply it + int t = i - 1; + while (t > -1) { + if (value[t] == '<' && value[t + 1] != '/') { + _Buffer.Insert(0, value.Substring(t, value.IndexOf('>', t) + 1 - t)); + break; + } + t--; + } + } + // Append tag and increase loop length to match + _Buffer.Append(m.Value); + int add = m.Groups[1].Index + 1; + length += add; + startIndex += add; + i += add - 1; + } + } else if (i >= startIndex) _Buffer.Append(c); + } + if (hasOpenTag && i < fullLen - 1) { + // Last open tag was not closed: find next close tag and apply it + string next = value.Substring(i); + Match m = Regex.Match(next, closeTagMatch); + if (m.Success) _Buffer.Append(m.Value); + } + } + + char[] ScrambledCharsToUse(StringOptions options) + { + switch (options.scrambleMode) { + case ScrambleMode.Uppercase: + return StringPluginExtensions.ScrambledCharsUppercase; + case ScrambleMode.Lowercase: + return StringPluginExtensions.ScrambledCharsLowercase; + case ScrambleMode.Numerals: + return StringPluginExtensions.ScrambledCharsNumerals; + case ScrambleMode.Custom: + return options.scrambledChars; + default: + return StringPluginExtensions.ScrambledCharsAll; + } + } + + +// public override void EvaluateAndApply(StringOptions options, Tween t, bool isRelative, DOGetter getter, DOSetter setter, float elapsed, string startValue, string changeValue, float duration, bool usingInversePosition) +// { +// _Buffer.Remove(0, _Buffer.Length); +// +// // Incremental works only with relative tweens (otherwise the tween makes no sense) +// // Sequence with Incremental loops have no effect here (why should they?) +// if (isRelative && t.loopType == LoopType.Incremental) { +// int iterations = t.isComplete ? t.completedLoops - 1 : t.completedLoops; +// if (iterations > 0) { +// _Buffer.Append(startValue); +// for (int i = 0; i < iterations; ++i) _Buffer.Append(changeValue); +// startValue = _Buffer.ToString(); +// _Buffer.Remove(0, _Buffer.Length); +// } +// } +// +// int startValueLen = startValue.Length; +// int changeValueLen = changeValue.Length; +// int len = (int)Math.Round(changeValueLen * EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod)); +// if (len > changeValueLen) len = changeValueLen; +// else if (len < 0) len = 0; +// +// if (isRelative) { +// _Buffer.Append(startValue); +// if (options.scramble) { +// setter(_Buffer.Append(changeValue, 0, len).AppendScrambledChars(changeValueLen - len, options.scrambledChars ?? StringPluginExtensions.ScrambledChars).ToString()); +// return; +// } +// setter(_Buffer.Append(changeValue, 0, len).ToString()); +// return; +// } +// +// if (options.scramble) { +// setter(_Buffer.Append(changeValue, 0, len).AppendScrambledChars(changeValueLen - len, options.scrambledChars ?? StringPluginExtensions.ScrambledChars).ToString()); +// return; +// } +// +// int diff = startValueLen - changeValueLen; +// int startValueMaxLen = startValueLen; +// if (diff > 0) { +// // String to be replaced is longer than endValue: remove parts of it while tweening +// float perc = (float)len / changeValueLen; +// startValueMaxLen -= (int)(startValueMaxLen * perc); +// } else startValueMaxLen -= len; +// _Buffer.Append(changeValue, 0, len); +// if (len < changeValueLen && len < startValueLen) _Buffer.Append(startValue, len, startValueMaxLen); +// setter(_Buffer.ToString()); +// } } // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -113,16 +233,28 @@ namespace DG.Tweening.Plugins internal static class StringPluginExtensions { - public static readonly char[] ScrambledChars = new[] { + public static readonly char[] ScrambledCharsAll = new[] { 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','X','Y','Z', -// 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','x','y','z', -// '1','2','3','4','5','6','7','8','9','0' + 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','x','y','z', + '1','2','3','4','5','6','7','8','9','0' + }; + public static readonly char[] ScrambledCharsUppercase = new[] { + 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','X','Y','Z' + }; + public static readonly char[] ScrambledCharsLowercase = new[] { + 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','x','y','z' + }; + public static readonly char[] ScrambledCharsNumerals = new[] { + '1','2','3','4','5','6','7','8','9','0' }; static int _lastRndSeed; static StringPluginExtensions() { - ScrambledChars.ScrambleChars(); + ScrambledCharsAll.ScrambleChars(); + ScrambledCharsUppercase.ScrambleChars(); + ScrambledCharsLowercase.ScrambleChars(); + ScrambledCharsNumerals.ScrambleChars(); } internal static void ScrambleChars(this char[] chars) diff --git a/_DOTween.Assembly/DOTween/ScrambleMode.cs b/_DOTween.Assembly/DOTween/ScrambleMode.cs new file mode 100644 index 0000000..ec1e9a8 --- /dev/null +++ b/_DOTween.Assembly/DOTween/ScrambleMode.cs @@ -0,0 +1,35 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2015/03/29 11:12 +namespace DG.Tweening +{ + /// + /// Type of scramble to apply to string tweens + /// + public enum ScrambleMode + { + /// + /// No scrambling of characters + /// + None, + /// + /// A-Z + a-z + 0-9 characters + /// + All, + /// + /// A-Z characters + /// + Uppercase, + /// + /// a-z characters + /// + Lowercase, + /// + /// 0-9 characters + /// + Numerals, + /// + /// Custom characters + /// + Custom + } +} \ No newline at end of file diff --git a/_DOTween.Assembly/DOTween/TweenSettingsExtensions.cs b/_DOTween.Assembly/DOTween/TweenSettingsExtensions.cs index 38cb5ac..3ac9845 100644 --- a/_DOTween.Assembly/DOTween/TweenSettingsExtensions.cs +++ b/_DOTween.Assembly/DOTween/TweenSettingsExtensions.cs @@ -674,15 +674,18 @@ namespace DG.Tweening } /// Options for Vector4 tweens - /// If TRUE the string will appear from a random animation of characters + /// If TRUE, rich text will be interpreted correctly while animated, + /// otherwise all tags will be considered as normal text + /// The type of scramble to use, if any /// A string containing the characters to use for scrambling. /// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters. /// Leave it to NULL to use default ones - public static Tweener SetOptions(this TweenerCore t, bool scramble, string scrambleChars = null) + public static Tweener SetOptions(this TweenerCore t, bool richTextEnabled, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null) { if (!t.active) return t; - t.plugOptions.scramble = scramble; + t.plugOptions.richTextEnabled = richTextEnabled; + t.plugOptions.scrambleMode = scrambleMode; if (!string.IsNullOrEmpty(scrambleChars)) { if (scrambleChars.Length <= 1) scrambleChars += scrambleChars; t.plugOptions.scrambledChars = scrambleChars.ToCharArray(); diff --git a/_DOTween.Assembly/DOTween46/ShortcutExtensions.cs b/_DOTween.Assembly/DOTween46/ShortcutExtensions.cs index 68459ad..6fa607e 100644 --- a/_DOTween.Assembly/DOTween46/ShortcutExtensions.cs +++ b/_DOTween.Assembly/DOTween46/ShortcutExtensions.cs @@ -226,14 +226,16 @@ namespace DG.Tweening /// Tweens a Text's text to the given value. /// Also stores the Text as the tween's target so it can be used for filtered operations /// The end string to tween toThe duration of the tween - /// If TRUE the string will appear from a random animation of characters + /// If TRUE (default), rich text will be interpreted correctly while animated, + /// otherwise all tags will be considered as normal text + /// The type of scramble mode to use, if any /// A string containing the characters to use for scrambling. /// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters. /// Leave it to NULL (default) to use default ones - public static Tweener DOText(this Text target, string endValue, float duration, bool scramble = false, string scrambleChars = null) + public static Tweener DOText(this Text target, string endValue, float duration, bool richTextEnabled = true, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null) { return DOTween.To(() => target.text, x => target.text = x, endValue, duration) - .SetOptions(scramble, scrambleChars) + .SetOptions(richTextEnabled, scrambleMode, scrambleChars) .SetTarget(target); } diff --git a/_DOTween.Assembly/bin/DOTween.XML b/_DOTween.Assembly/bin/DOTween.XML index 8308150..dca1428 100644 --- a/_DOTween.Assembly/bin/DOTween.XML +++ b/_DOTween.Assembly/bin/DOTween.XML @@ -567,9 +567,11 @@ Options for Vector4 tweens If TRUE the tween will smoothly snap all values to integers - + Options for Vector4 tweens - If TRUE the string will appear from a random animation of characters + If TRUE, rich text will be interpreted correctly while animated, + otherwise all tags will be considered as normal text + The type of scramble to use, if any A string containing the characters to use for scrambling. Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters. Leave it to NULL to use default ones @@ -1941,5 +1943,40 @@ Public only so custom shortcuts can access some of these methods + + + Type of scramble to apply to string tweens + + + + + No scrambling of characters + + + + + A-Z + a-z + 0-9 characters + + + + + A-Z characters + + + + + a-z characters + + + + + 0-9 characters + + + + + Custom characters + + diff --git a/_DOTween.Assembly/bin/DOTween.dll b/_DOTween.Assembly/bin/DOTween.dll index 4309232..09b6c14 100644 Binary files a/_DOTween.Assembly/bin/DOTween.dll and b/_DOTween.Assembly/bin/DOTween.dll differ diff --git a/_DOTween.Assembly/bin/DOTween.dll.mdb b/_DOTween.Assembly/bin/DOTween.dll.mdb index f1f2fe7..21beec9 100644 Binary files a/_DOTween.Assembly/bin/DOTween.dll.mdb and b/_DOTween.Assembly/bin/DOTween.dll.mdb differ diff --git a/_DOTween.Assembly/bin/DOTween43.dll b/_DOTween.Assembly/bin/DOTween43.dll index d09d0a6..30c81f8 100644 Binary files a/_DOTween.Assembly/bin/DOTween43.dll and b/_DOTween.Assembly/bin/DOTween43.dll differ diff --git a/_DOTween.Assembly/bin/DOTween43.dll.mdb b/_DOTween.Assembly/bin/DOTween43.dll.mdb index 3140ae0..017ad8e 100644 Binary files a/_DOTween.Assembly/bin/DOTween43.dll.mdb and b/_DOTween.Assembly/bin/DOTween43.dll.mdb differ diff --git a/_DOTween.Assembly/bin/DOTween46.dll b/_DOTween.Assembly/bin/DOTween46.dll index 3960083..3f426ec 100644 Binary files a/_DOTween.Assembly/bin/DOTween46.dll and b/_DOTween.Assembly/bin/DOTween46.dll differ diff --git a/_DOTween.Assembly/bin/DOTween46.dll.mdb b/_DOTween.Assembly/bin/DOTween46.dll.mdb index 808e1c6..3306de7 100644 Binary files a/_DOTween.Assembly/bin/DOTween46.dll.mdb and b/_DOTween.Assembly/bin/DOTween46.dll.mdb differ diff --git a/_DOTween.Assembly/bin/DOTween46.xml b/_DOTween.Assembly/bin/DOTween46.xml index d630ed1..f6ff80e 100644 --- a/_DOTween.Assembly/bin/DOTween46.xml +++ b/_DOTween.Assembly/bin/DOTween46.xml @@ -107,11 +107,13 @@ Also stores the Text as the tween's target so it can be used for filtered operations The end value to reachThe duration of the tween - + Tweens a Text's text to the given value. Also stores the Text as the tween's target so it can be used for filtered operations The end string to tween toThe duration of the tween - If TRUE the string will appear from a random animation of characters + If TRUE (default), rich text will be interpreted correctly while animated, + otherwise all tags will be considered as normal text + The type of scramble mode to use, if any A string containing the characters to use for scrambling. Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters. Leave it to NULL (default) to use default ones diff --git a/_DOTween.Assembly/bin/DOTween50.dll b/_DOTween.Assembly/bin/DOTween50.dll index 1ccc8d0..be94bfc 100644 Binary files a/_DOTween.Assembly/bin/DOTween50.dll and b/_DOTween.Assembly/bin/DOTween50.dll differ diff --git a/_DOTween.Assembly/bin/DOTween50.dll.mdb b/_DOTween.Assembly/bin/DOTween50.dll.mdb index 4c956e6..d1da6bb 100644 Binary files a/_DOTween.Assembly/bin/DOTween50.dll.mdb and b/_DOTween.Assembly/bin/DOTween50.dll.mdb differ diff --git a/_DOTween.Assembly/bin/Editor/DOTweenEditor.dll b/_DOTween.Assembly/bin/Editor/DOTweenEditor.dll index 03b5d6d..997f544 100644 Binary files a/_DOTween.Assembly/bin/Editor/DOTweenEditor.dll and b/_DOTween.Assembly/bin/Editor/DOTweenEditor.dll differ diff --git a/_DOTween.Assembly/bin/Editor/DOTweenEditor.dll.mdb b/_DOTween.Assembly/bin/Editor/DOTweenEditor.dll.mdb index c228cff..e021ddc 100644 Binary files a/_DOTween.Assembly/bin/Editor/DOTweenEditor.dll.mdb and b/_DOTween.Assembly/bin/Editor/DOTweenEditor.dll.mdb differ