public static void SetTweensCapacity(int tweenersCapacity, int sequencesCapacity)
{
TweenManager.SetCapacities(tweenersCapacity, sequencesCapacity);
}
public static int TotalPlayingTweens()
{
return(TweenManager.TotalPlayingTweens());
}
override public void OnInspectorGUI()
{
EditorGUIUtils.SetGUIStyles();
int totActiveTweens = TweenManager.totActiveTweens;
int totPlayingTweens = TweenManager.TotalPlayingTweens();
int totPausedTweens = totActiveTweens - totPlayingTweens;
int totActiveDefaultTweens = TweenManager.totActiveDefaultTweens;
int totActiveLateTweens = TweenManager.totActiveLateTweens;
GUILayout.Space(4);
GUILayout.Label(_title, TweenManager.isDebugBuild ? EditorGUIUtils.redLabelStyle : EditorGUIUtils.boldLabelStyle);
GUILayout.Space(6);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Documentation"))
{
Application.OpenURL("http://dotween.demigiant.com/documentation.php");
}
if (GUILayout.Button("Check Updates"))
{
Application.OpenURL("http://dotween.demigiant.com/download.php?v=" + DOTween.Version);
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
if (GUILayout.Button(_settings.showPlayingTweens ? "Hide Playing Tweens" : "Show Playing Tweens"))
{
_settings.showPlayingTweens = !_settings.showPlayingTweens;
EditorUtility.SetDirty(_settings);
}
if (GUILayout.Button(_settings.showPausedTweens ? "Hide Paused Tweens" : "Show Paused Tweens"))
{
_settings.showPausedTweens = !_settings.showPausedTweens;
EditorUtility.SetDirty(_settings);
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
if (GUILayout.Button("Play all"))
{
DOTween.PlayAll();
}
if (GUILayout.Button("Pause all"))
{
DOTween.PauseAll();
}
if (GUILayout.Button("Kill all"))
{
DOTween.KillAll();
}
GUILayout.EndHorizontal();
GUILayout.Space(8);
_strBuilder.Length = 0;
_strBuilder.Append("Active tweens: ").Append(totActiveTweens)
.Append(" (").Append(TweenManager.totActiveTweeners)
.Append("/").Append(TweenManager.totActiveSequences).Append(")")
.Append("\nDefault/Late tweens: ").Append(totActiveDefaultTweens)
.Append("/").Append(totActiveLateTweens)
.Append("\nPlaying tweens: ").Append(totPlayingTweens);
if (_settings.showPlayingTweens)
{
foreach (Tween t in TweenManager._activeTweens)
{
if (t != null && t.isPlaying)
{
_strBuilder.Append("\n - [").Append(t.tweenType).Append("] ").Append(t.target);
}
}
}
_strBuilder.Append("\nPaused tweens: ").Append(totPausedTweens);
if (_settings.showPausedTweens)
{
foreach (Tween t in TweenManager._activeTweens)
{
if (t != null && !t.isPlaying)
{
_strBuilder.Append("\n - [").Append(t.tweenType).Append("] ").Append(t.target);
}
}
}
_strBuilder.Append("\nPooled tweens: ").Append(TweenManager.TotalPooledTweens())
.Append(" (").Append(TweenManager.totPooledTweeners)
.Append("/").Append(TweenManager.totPooledSequences).Append(")");
GUILayout.Label(_strBuilder.ToString());
GUILayout.Space(8);
_strBuilder.Remove(0, _strBuilder.Length);
_strBuilder.Append("Tweens Capacity: ").Append(TweenManager.maxTweeners).Append("/").Append(TweenManager.maxSequences)
.Append("\nMax Simultaneous Active Tweens: ").Append(DOTween.maxActiveTweenersReached).Append("/").Append(DOTween.maxActiveSequencesReached);
GUILayout.Label(_strBuilder.ToString());
GUILayout.Space(8);
_strBuilder.Remove(0, _strBuilder.Length);
_strBuilder.Append("SETTINGS ▼");
_strBuilder.Append("\nSafe Mode: ").Append(DOTween.useSafeMode ? "ON" : "OFF");
_strBuilder.Append("\nLog Behaviour: ").Append(DOTween.logBehaviour);
_strBuilder.Append("\nShow Unity Editor Report: ").Append(DOTween.showUnityEditorReport);
_strBuilder.Append("\nTimeScale (Unity/DOTween): ").Append(Time.timeScale).Append("/").Append(DOTween.timeScale);
GUILayout.Label(_strBuilder.ToString());
GUILayout.Label("NOTE: DOTween's TimeScale is not the same as Unity's Time.timeScale: it is actually multiplied by it except for tweens that are set to update independently", EditorGUIUtils.wordWrapItalicLabelStyle);
GUILayout.Space(8);
_strBuilder.Remove(0, _strBuilder.Length);
_strBuilder.Append("DEFAULTS ▼");
_strBuilder.Append("\ndefaultRecyclable: ").Append(DOTween.defaultRecyclable);
_strBuilder.Append("\ndefaultUpdateType: ").Append(DOTween.defaultUpdateType);
_strBuilder.Append("\ndefaultTSIndependent: ").Append(DOTween.defaultTimeScaleIndependent);
_strBuilder.Append("\ndefaultAutoKill: ").Append(DOTween.defaultAutoKill);
_strBuilder.Append("\ndefaultAutoPlay: ").Append(DOTween.defaultAutoPlay);
_strBuilder.Append("\ndefaultEaseType: ").Append(DOTween.defaultEaseType);
_strBuilder.Append("\ndefaultLoopType: ").Append(DOTween.defaultLoopType);
GUILayout.Label(_strBuilder.ToString());
GUILayout.Space(10);
}
public static List <Tween> PlayingTweens()
{
return(TweenManager.GetActiveTweens(true));
}
public static int SmoothRewindAll()
{
return(TweenManager.FilteredOperation(OperationType.SmoothRewind, FilterType.All, null, false, 0f, null, null));
}
public static int KillAll(bool complete = false)
{
return((complete ? CompleteAndReturnKilledTot() : 0) + TweenManager.DespawnAll());
}
public static List <Tween> PausedTweens()
{
return(TweenManager.GetActiveTweens(false));
}
public virtual void stop(bool bringToCompletion = false)
{
TweenManager.removeTween(this);
_isCurrentlyManagedByTweenManager = false;
_isPaused = true;
}
private static bool ApplyInternalCycle(Sequence s, float fromPos, float toPos, UpdateMode updateMode, bool useInverse, bool prevPosIsInverse, bool multiCycleStep = false)
{
bool flag = toPos < fromPos;
if (flag)
{
int num = s._sequencedObjs.Count - 1;
for (int i = num; i > -1; i--)
{
if (!s.active)
{
return(true);
}
ABSSequentiable aBSSequentiable = s._sequencedObjs[i];
if (aBSSequentiable.sequencedEndPosition >= toPos && aBSSequentiable.sequencedPosition <= fromPos)
{
if (aBSSequentiable.tweenType == TweenType.Callback)
{
if (updateMode == UpdateMode.Update && prevPosIsInverse)
{
Tween.OnTweenCallback(aBSSequentiable.onStart);
}
}
else
{
float num2 = toPos - aBSSequentiable.sequencedPosition;
if (num2 < 0f)
{
num2 = 0f;
}
Tween tween = (Tween)aBSSequentiable;
if (tween.startupDone)
{
tween.isBackwards = true;
if (TweenManager.Goto(tween, num2, false, updateMode))
{
return(true);
}
if (multiCycleStep && tween.tweenType == TweenType.Sequence)
{
if (s.position <= 0f && s.completedLoops == 0)
{
tween.position = 0f;
}
else
{
bool flag2 = s.completedLoops == 0 || (s.isBackwards && (s.completedLoops < s.loops || s.loops == -1));
if (tween.isBackwards)
{
flag2 = !flag2;
}
if (useInverse)
{
flag2 = !flag2;
}
if (s.isBackwards && !useInverse && !prevPosIsInverse)
{
flag2 = !flag2;
}
tween.position = (flag2 ? 0f : tween.duration);
}
}
}
}
}
}
}
else
{
int count = s._sequencedObjs.Count;
for (int j = 0; j < count; j++)
{
if (!s.active)
{
return(true);
}
ABSSequentiable aBSSequentiable2 = s._sequencedObjs[j];
if (aBSSequentiable2.sequencedPosition <= toPos && aBSSequentiable2.sequencedEndPosition >= fromPos)
{
if (aBSSequentiable2.tweenType == TweenType.Callback)
{
if (updateMode == UpdateMode.Update)
{
bool flag3 = (!s.isBackwards && !useInverse && !prevPosIsInverse) || (s.isBackwards && useInverse && !prevPosIsInverse);
if (flag3)
{
Tween.OnTweenCallback(aBSSequentiable2.onStart);
}
}
}
else
{
float num3 = toPos - aBSSequentiable2.sequencedPosition;
if (num3 < 0f)
{
num3 = 0f;
}
Tween tween2 = (Tween)aBSSequentiable2;
tween2.isBackwards = false;
if (TweenManager.Goto(tween2, num3, false, updateMode))
{
return(true);
}
if (multiCycleStep && tween2.tweenType == TweenType.Sequence)
{
if (s.position <= 0f && s.completedLoops == 0)
{
tween2.position = 0f;
}
else
{
bool flag4 = s.completedLoops == 0 || (!s.isBackwards && (s.completedLoops < s.loops || s.loops == -1));
if (tween2.isBackwards)
{
flag4 = !flag4;
}
if (useInverse)
{
flag4 = !flag4;
}
if (s.isBackwards && !useInverse && !prevPosIsInverse)
{
flag4 = !flag4;
}
tween2.position = (flag4 ? 0f : tween2.duration);
}
}
}
}
}
}
return(false);
}
//fucntion that actually moves the cube
public IEnumerator MoveCube(Vector3 destination, bool isFalling, int playerMouv) // TODO : Change isFalling logic
{
if (!isStatic) // Check si le cube est static ( surement va se faire tej )
{
isStopMouv = false; // Annonce que le cube va bouger
currentPos = basePos = transform.position;
//float currentV = 0;
change = destination - basePos;
while (time <= moveTime) // Mouvement du cube
{
time += Time.deltaTime;
switch (transitionType)
{
case _LoaderQueuer.TransitionType.LinearTween:
currentPos.x = TweenManager.LinearTween(time, basePos.x, change.x, moveTime);
currentPos.y = TweenManager.LinearTween(time, basePos.y, change.y, moveTime);
currentPos.z = TweenManager.LinearTween(time, basePos.z, change.z, moveTime);
yield return(null);
break;
case _LoaderQueuer.TransitionType.EaseInQuad:
currentPos.x = TweenManager.EaseInQuad(time, basePos.x, change.x, moveTime);
currentPos.y = TweenManager.EaseInQuad(time, basePos.y, change.y, moveTime);
currentPos.z = TweenManager.EaseInQuad(time, basePos.z, change.z, moveTime);
yield return(null);
break;
case _LoaderQueuer.TransitionType.EaseOutQuad:
currentPos.x = TweenManager.EaseOutQuad(time, basePos.x, change.x, moveTime);
currentPos.y = TweenManager.EaseOutQuad(time, basePos.y, change.y, moveTime);
currentPos.z = TweenManager.EaseOutQuad(time, basePos.z, change.z, moveTime);
yield return(null);
break;
case _LoaderQueuer.TransitionType.EaseInOutQuad:
currentPos.x = TweenManager.EaseInOutQuad(time, basePos.x, change.x, moveTime);
currentPos.y = TweenManager.EaseInOutQuad(time, basePos.y, change.y, moveTime);
currentPos.z = TweenManager.EaseInOutQuad(time, basePos.z, change.z, moveTime);
yield return(null);
break;
case _LoaderQueuer.TransitionType.EaseInOutQuint:
currentPos.x = TweenManager.EaseInOutQuint(time, basePos.x, change.x, moveTime);
currentPos.y = TweenManager.EaseInOutQuint(time, basePos.y, change.y, moveTime);
currentPos.z = TweenManager.EaseInOutQuint(time, basePos.z, change.z, moveTime);
yield return(null);
break;
case _LoaderQueuer.TransitionType.EaseInOutSine:
currentPos.x = TweenManager.EaseInOutSine(time, basePos.x, change.x, moveTime);
currentPos.y = TweenManager.EaseInOutSine(time, basePos.y, change.y, moveTime);
currentPos.z = TweenManager.EaseInOutSine(time, basePos.z, change.z, moveTime);
yield return(null);
break;
}
transform.position = currentPos;
}
currentPos = destination;
transform.position = currentPos; // Au cas ou, TP le cube sur la position final ( précision )
isStopMouv = true; // Le cube arrete de bouger
//Debug.LogError("isFalling + " + isFalling);
if (isFalling == false)
{
DataManager.instance.AddListActive(0); // Rajoute le deplacement dans les liste de déplacement ( liée au Undo )
}
if (hasChildCubes == true) // Si il a des enfant, les enfants doivent checker si ils sont dans le vide
{
foreach (_MovableCube cubes in physicCube)
{
cubes.MakeMouv();
}
hasChildCubes = false;
physicCube.Clear(); // Reset la liste des cubes qui sont aussi dessus du cube
}
//if (stickyCube != null)
// stickyCube.CheckSides();
if (OutsideKUB == false)
{
MakeMouv(); // CheckFloor au cas ou il est dans les air
}
time = 0; // Reset Lerp value
//parentReset();
GetBasePoint(); // Get TOuch First Position
if (playerMouv == 1)
{
DataManager.instance.EndMouvement.Invoke();
}
}
else
{
yield return(null);
}
}
/// <summary>
/// Load graphics content for the screen.
/// </summary>
public virtual void LoadContent()
{
content = new ContentManager(ScreenManager.Game.Services);
content.RootDirectory = ScreenManager.Game.ContentRoot;
tweenManager = new TweenManager();
}
// ===================================================================================
// METHODS ---------------------------------------------------------------------------
// Returns TRUE if the tween needs to be killed
static bool ApplyInternalCycle(Sequence s, float fromPos, float toPos, UpdateMode updateMode, bool useInverse, bool prevPosIsInverse, bool multiCycleStep = false)
{
bool wasPlaying = s.isPlaying; // Used to interrupt for loops in case a callback pauses a running Sequence
bool isBackwardsUpdate = toPos < fromPos;
// Debug.Log(Time.frameCount + " " + s.id + " " + (multiCycleStep ? "<color=#FFEC03>Multicycle</color> > " : "Cycle > ") + s.position + "/" + s.duration + " - s.isBackwards: " + s.isBackwards + ", useInverse/prevInverse: " + useInverse + "/" + prevPosIsInverse + " - " + fromPos + " > " + toPos + " - UpdateMode: " + updateMode + ", isPlaying: " + s.isPlaying + ", completedLoops: " + s.completedLoops);
if (isBackwardsUpdate)
{
int len = s._sequencedObjs.Count - 1;
for (int i = len; i > -1; --i)
{
if (!s.active)
{
return(true); // Killed by some internal callback
}
if (!s.isPlaying && wasPlaying)
{
return(false); // Paused by internal callback
}
ABSSequentiable sequentiable = s._sequencedObjs[i];
if (sequentiable.sequencedEndPosition < toPos || sequentiable.sequencedPosition > fromPos)
{
continue;
}
if (sequentiable.tweenType == TweenType.Callback)
{
if (updateMode == UpdateMode.Update && prevPosIsInverse)
{
// Debug.Log("<color=#FFEC03>BACKWARDS Callback > " + s.id + " - s.isBackwards: " + s.isBackwards + ", useInverse/prevInverse: " + useInverse + "/" + prevPosIsInverse + " - " + fromPos + " > " + toPos + "</color>");
OnTweenCallback(sequentiable.onStart);
}
}
else
{
// Nested Tweener/Sequence
float gotoPos = toPos - sequentiable.sequencedPosition;
// float gotoPos = (float)((decimal)toPos - (decimal)sequentiable.sequencedPosition);
if (gotoPos < 0)
{
gotoPos = 0;
}
Tween t = (Tween)sequentiable;
if (!t.startupDone)
{
continue; // since we're going backwards and this tween never started just ignore it
}
t.isBackwards = true;
if (TweenManager.Goto(t, gotoPos, false, updateMode))
{
// Nested tween failed. If it's the only tween and there's no callbacks mark for killing the whole sequence
// (default behaviour in any case prior to v1.2.060)...
if (DOTween.nestedTweenFailureBehaviour == NestedTweenFailureBehaviour.KillWholeSequence)
{
return(true);
}
if (s.sequencedTweens.Count == 1 && s._sequencedObjs.Count == 1 && !IsAnyCallbackSet(s))
{
return(true);
}
// ...otherwise remove failed tween from Sequence and continue
TweenManager.Despawn(t, false);
s._sequencedObjs.RemoveAt(i);
s.sequencedTweens.Remove(t);
--i; --len;
continue;
}
// Fixes nested callbacks not being called correctly if main sequence has loops and nested ones don't
if (multiCycleStep && t.tweenType == TweenType.Sequence)
{
if (s.position <= 0 && s.completedLoops == 0)
{
t.position = 0;
}
else
{
bool toZero = s.completedLoops == 0 || s.isBackwards && (s.completedLoops < s.loops || s.loops == -1);
if (t.isBackwards)
{
toZero = !toZero;
}
if (useInverse)
{
toZero = !toZero;
}
if (s.isBackwards && !useInverse && !prevPosIsInverse)
{
toZero = !toZero;
}
t.position = toZero ? 0 : t.duration;
}
}
}
}
}
else
{
int len = s._sequencedObjs.Count;
for (int i = 0; i < len; ++i)
{
if (!s.active)
{
return(true); // Killed by some internal callback
}
if (!s.isPlaying && wasPlaying)
{
return(false); // Paused by internal callback
}
ABSSequentiable sequentiable = s._sequencedObjs[i];
// if (sequentiable.sequencedPosition > toPos || sequentiable.sequencedEndPosition < fromPos) continue;
// Fix rare case with high FPS when a tween/callback might happen in same exact time as it's set
// This fixes it but should check for backwards tweens and loops
if (
sequentiable.sequencedPosition > toPos ||
sequentiable.sequencedPosition > 0 && sequentiable.sequencedEndPosition <= fromPos ||
sequentiable.sequencedPosition <= 0 && sequentiable.sequencedEndPosition < fromPos
)
{
continue;
}
if (sequentiable.tweenType == TweenType.Callback)
{
if (updateMode == UpdateMode.Update)
{
// Debug.Log("<color=#FFEC03>FORWARD Callback > " + s.id + " - s.isBackwards: " + s.isBackwards + ", useInverse/prevInverse: " + useInverse + "/" + prevPosIsInverse + " - " + fromPos + " > " + toPos + "</color>");
bool fire = !s.isBackwards && !useInverse && !prevPosIsInverse ||
s.isBackwards && useInverse && !prevPosIsInverse;
if (fire)
{
OnTweenCallback(sequentiable.onStart);
}
}
}
else
{
// Nested Tweener/Sequence
float gotoPos = toPos - sequentiable.sequencedPosition;
// float gotoPos = (float)((decimal)toPos - (decimal)sequentiable.sequencedPosition);
if (gotoPos < 0)
{
gotoPos = 0;
}
Tween t = (Tween)sequentiable;
// Fix for final nested tween not calling OnComplete in some cases
if (toPos >= sequentiable.sequencedEndPosition)
{
if (!t.startupDone)
{
TweenManager.ForceInit(t, true);
}
if (gotoPos < t.fullDuration)
{
gotoPos = t.fullDuration;
}
}
//
t.isBackwards = false;
if (TweenManager.Goto(t, gotoPos, false, updateMode))
{
// Nested tween failed. If it's the only tween and there's no callbacks mark for killing the whole sequence
// (default behaviour in any case prior to v1.2.060)...
if (DOTween.nestedTweenFailureBehaviour == NestedTweenFailureBehaviour.KillWholeSequence)
{
return(true);
}
if (s.sequencedTweens.Count == 1 && s._sequencedObjs.Count == 1 && !IsAnyCallbackSet(s))
{
return(true);
}
// ...otherwise remove failed tween from Sequence and continue
TweenManager.Despawn(t, false);
s._sequencedObjs.RemoveAt(i);
s.sequencedTweens.Remove(t);
--i; --len;
continue;
}
// Fixes nested callbacks not being called correctly if main sequence has loops and nested ones don't
if (multiCycleStep && t.tweenType == TweenType.Sequence)
{
if (s.position <= 0 && s.completedLoops == 0)
{
t.position = 0;
}
else
{
bool toZero = s.completedLoops == 0 || !s.isBackwards && (s.completedLoops < s.loops || s.loops == -1);
if (t.isBackwards)
{
toZero = !toZero;
}
if (useInverse)
{
toZero = !toZero;
}
if (s.isBackwards && !useInverse && !prevPosIsInverse)
{
toZero = !toZero;
}
t.position = toZero ? 0 : t.duration;
}
}
}
}
}
return(false);
}
void SetupSceneSelector()
{
_table = Canvas.Stage.AddElement(new Table());
var sampleScenes = new Table().PadRight(5);
_table.SetFillParent(true).Right().Top();
var topButtonStyle = new TextButtonStyle(new PrimitiveDrawable(Color.Black, 10f),
new PrimitiveDrawable(Color.Yellow), new PrimitiveDrawable(Color.DarkSlateBlue))
{
DownFontColor = Color.Black
};
_table.Add(new TextButton("Toggle Scene List", topButtonStyle)).SetFillX().SetMinHeight(30)
.GetElement <Button>().OnClicked += butt =>
{
sampleScenes.SetIsVisible(!sampleScenes.IsVisible());
};
_table.Row().SetPadTop(10);
var checkbox = _table.Add(new CheckBox("Debug Render", new CheckBoxStyle
{
CheckboxOn = new PrimitiveDrawable(30, Color.Green),
CheckboxOff = new PrimitiveDrawable(30, new Color(0x00, 0x3c, 0xe7, 0xff))
})).GetElement <CheckBox>();
checkbox.OnChanged += enabled => Core.DebugRenderEnabled = enabled;
checkbox.IsChecked = Core.DebugRenderEnabled;
_table.Row();
_table.Add(sampleScenes).SetAlign(Align.Top);
sampleScenes.Row();
sampleScenes.Add(new Label("Samples", new LabelStyle())).SetFillX().SetMinHeight(30);
sampleScenes.Row();
var buttonStyle = new TextButtonStyle(new PrimitiveDrawable(new Color(78, 91, 98), 10f),
new PrimitiveDrawable(new Color(244, 23, 135)), new PrimitiveDrawable(new Color(168, 207, 115)))
{
DownFontColor = Color.Black
};
// find every Scene with the SampleSceneAttribute and create a button for each one
foreach (var type in GetTypesWithSampleSceneAttribute())
{
foreach (var attr in type.GetCustomAttributes(true))
{
if (attr.GetType() == typeof(SampleSceneAttribute))
{
var sampleAttr = attr as SampleSceneAttribute;
var button = sampleScenes.Add(new TextButton(sampleAttr.ButtonName, buttonStyle)).SetFillX()
.SetMinHeight(30).GetElement <TextButton>();
button.OnClicked += butt =>
{
// stop all tweens in case any demo scene started some up
TweenManager.StopAllTweens();
Core.GetGlobalManager <ImGuiManager>()?.SetEnabled(false);
Core.StartSceneTransition(new FadeTransition(() => Activator.CreateInstance(type) as Scene));
};
sampleScenes.Row().SetPadTop(10);
// optionally add instruction text for the current scene
if (sampleAttr.InstructionText != null && type == GetType())
{
AddInstructionText(sampleAttr.InstructionText);
}
}
}
}
}
void Awake()
{
instance = this;
}
public static int Validate()
{
return(TweenManager.Validate());
}
private static bool ApplyInternalCycle(Sequence s, float fromPos, float toPos, UpdateMode updateMode, bool useInverse, bool prevPosIsInverse, bool multiCycleStep = false)
{
if (toPos < fromPos)
{
for (int num = s._sequencedObjs.Count - 1; num > -1; num--)
{
if (!s.active)
{
return(true);
}
ABSSequentiable aBSSequentiable = s._sequencedObjs[num];
if (!(aBSSequentiable.sequencedEndPosition < toPos) && !(aBSSequentiable.sequencedPosition > fromPos))
{
if (aBSSequentiable.tweenType == TweenType.Callback)
{
if (updateMode == UpdateMode.Update & prevPosIsInverse)
{
Tween.OnTweenCallback(aBSSequentiable.onStart);
}
}
else
{
float num2 = toPos - aBSSequentiable.sequencedPosition;
if (num2 < 0f)
{
num2 = 0f;
}
Tween tween = (Tween)aBSSequentiable;
if (tween.startupDone)
{
tween.isBackwards = true;
if (TweenManager.Goto(tween, num2, false, updateMode))
{
return(true);
}
if (multiCycleStep && tween.tweenType == TweenType.Sequence)
{
if (s.position <= 0f && s.completedLoops == 0)
{
tween.position = 0f;
}
else
{
bool flag = s.completedLoops == 0 || (s.isBackwards && (s.completedLoops < s.loops || s.loops == -1));
if (tween.isBackwards)
{
flag = !flag;
}
if (useInverse)
{
flag = !flag;
}
if (s.isBackwards && !useInverse && !prevPosIsInverse)
{
flag = !flag;
}
tween.position = (flag ? 0f : tween.duration);
}
}
}
}
}
}
}
else
{
int count = s._sequencedObjs.Count;
for (int i = 0; i < count; i++)
{
if (!s.active)
{
return(true);
}
ABSSequentiable aBSSequentiable2 = s._sequencedObjs[i];
if (!(aBSSequentiable2.sequencedPosition > toPos) && !(aBSSequentiable2.sequencedEndPosition < fromPos))
{
if (aBSSequentiable2.tweenType == TweenType.Callback)
{
if (updateMode == UpdateMode.Update && ((!s.isBackwards && !useInverse && !prevPosIsInverse) || ((s.isBackwards & useInverse) && !prevPosIsInverse)))
{
Tween.OnTweenCallback(aBSSequentiable2.onStart);
}
}
else
{
float num3 = toPos - aBSSequentiable2.sequencedPosition;
if (num3 < 0f)
{
num3 = 0f;
}
Tween tween2 = (Tween)aBSSequentiable2;
if (toPos >= aBSSequentiable2.sequencedEndPosition)
{
if (!tween2.startupDone)
{
TweenManager.ForceInit(tween2, true);
}
if (num3 < tween2.fullDuration)
{
num3 = tween2.fullDuration;
}
}
tween2.isBackwards = false;
if (TweenManager.Goto(tween2, num3, false, updateMode))
{
return(true);
}
if (multiCycleStep && tween2.tweenType == TweenType.Sequence)
{
if (s.position <= 0f && s.completedLoops == 0)
{
tween2.position = 0f;
}
else
{
bool flag2 = s.completedLoops == 0 || (!s.isBackwards && (s.completedLoops < s.loops || s.loops == -1));
if (tween2.isBackwards)
{
flag2 = !flag2;
}
if (useInverse)
{
flag2 = !flag2;
}
if (s.isBackwards && !useInverse && !prevPosIsInverse)
{
flag2 = !flag2;
}
tween2.position = (flag2 ? 0f : tween2.duration);
}
}
}
}
}
}
return(false);
}
void OnEnable()
{
m_TweenManager = (TweenManager)serializedObject.targetObject;
}
/// <summary>Send a path tween to the given waypoint.
/// Has no effect if this is not a path tween.
/// <para>BEWARE, this is a special utility method:
/// it works only with Linear eases. Also, the lookAt direction might be wrong after calling this and might need to be set manually
/// (because it relies on a smooth path movement and doesn't work well with jumps that encompass dramatic direction changes)</para></summary>
/// <param name="waypointIndex">Waypoint index to reach
/// (if higher than the max waypoint index the tween will simply go to the last one)</param>
/// <param name="andPlay">If TRUE will play the tween after reaching the given waypoint, otherwise it will pause it</param>
public static void GotoWaypoint(this Tween t, int waypointIndex, bool andPlay = false)
{
if (t == null)
{
if (Debugger.logPriority > 1)
{
Debugger.LogNullTween(t);
}
return;
}
else if (!t.active)
{
if (Debugger.logPriority > 1)
{
Debugger.LogInvalidTween(t);
}
return;
}
else if (t.isSequenced)
{
if (Debugger.logPriority > 1)
{
Debugger.LogNestedTween(t);
}
return;
}
TweenerCore <Vector3, Path, PathOptions> pathTween = t as TweenerCore <Vector3, Path, PathOptions>;
if (pathTween == null)
{
if (Debugger.logPriority > 1)
{
Debugger.LogNonPathTween(t);
}
return;
}
if (!t.startupDone)
{
TweenManager.ForceInit(t); // Initialize the tween if it's not initialized already (required)
}
if (waypointIndex < 0)
{
waypointIndex = 0;
}
else if (waypointIndex > pathTween.changeValue.wps.Length - 1)
{
waypointIndex = pathTween.changeValue.wps.Length - 1;
}
// Find path percentage relative to given waypoint
float wpLength = 0; // Total length from start to the given waypoint
for (int i = 0; i < waypointIndex + 1; i++)
{
wpLength += pathTween.changeValue.wpLengths[i];
}
float wpPerc = wpLength / pathTween.changeValue.length;
// Convert to time taking eventual inverse direction into account
bool useInversePosition = t.loopType == LoopType.Yoyo &&
(t.position < t.duration ? t.completedLoops % 2 != 0 : t.completedLoops % 2 == 0);
if (useInversePosition)
{
wpPerc = 1 - wpPerc;
}
float to = (t.isComplete ? t.completedLoops - 1 : t.completedLoops) * t.duration + wpPerc * t.duration;
TweenManager.Goto(t, to, andPlay);
}
public static int KillAll(bool complete, params object[] idsOrTargetsToExclude)
{
if (idsOrTargetsToExclude == null)
{
return((complete ? CompleteAndReturnKilledTot() : 0) + TweenManager.DespawnAll());
}
return((complete ? CompleteAndReturnKilledTotExceptFor(idsOrTargetsToExclude) : 0) + TweenManager.FilteredOperation(OperationType.Despawn, FilterType.AllExceptTargetsOrIds, null, false, 0f, null, idsOrTargetsToExclude));
}
/// <summary>
/// 符卡结束回调
/// <para>bool isSpellCard 是否为符卡(非符or符卡)</para>
/// <para>bool isFinishSpellCard 是否成功击破符卡</para>
/// <para>bool getBonus 是否获得符卡bonus<para>
/// <para>int timePassed 经过的时间</para>
/// <para>int realTimePassed 经过的时间</para>
/// </summary>
/// <param name="datas"></param>
private void OnSpellCardFinish(object[] datas)
{
// 隐藏符卡时间
_isShowSpellCardTime = false;
_scTimeObject.SetActive(false);
if (_isShowSpellCardInfo)
{
// 隐藏符卡名称
_scNameObject.SetActive(false);
TweenManager.GetInstance().RemoveTweenByGo(_scNameObject);
}
// 如果是符卡，则显示符卡通过信息
bool isSpellCard = (bool)datas[0];
if (isSpellCard == true)
{
_spellCardResultPanel.SetActive(true);
_isFinishSC = (bool)datas[1];
if (_isFinishSC)
{
// 显示符卡击破时间
_finishTimePanel.SetActive(true);
int timePassed = (int)datas[3];
UpdateShowTime(timePassed, _finishTimeDatas);
// 判断是否获得bonus
bool getBonus = (bool)datas[2];
if (getBonus)
{
_getBonusGo.SetActive(true);
_bonusFailGo.SetActive(false);
SoundManager.GetInstance().Play("se_scbonus", Consts.DefaultUISEVolume, false, false);
}
else
{
_getBonusGo.SetActive(false);
_bonusFailGo.SetActive(true);
}
}
else
{
_finishTimePanel.SetActive(false);
_getBonusGo.SetActive(false);
_bonusFailGo.SetActive(true);
SoundManager.GetInstance().Play("se_scfault", Consts.DefaultUISEVolume, false, false);
}
// 显示实际时间
int realTimePassed = (int)datas[4];
UpdateShowTime(realTimePassed, _realTimeDatas);
// 设置符卡结果面板动画参数
_resultState = 0;
_resultTime = 0;
for (int i = 0; i < 10; i++)
{
_realTimeDatas[i].sr.color = new Color(1, 1, 1, 0);
}
_realTimeText.color = new Color(1, 1, 1, 0);
if (_isFinishSC)
{
for (int i = 0; i < 10; i++)
{
_finishTimeDatas[i].sr.color = new Color(1, 1, 1, 0);
}
_finishTimeText.color = new Color(1, 1, 1, 0);
}
_getBonusGo.transform.localScale = new Vector3(100, 100, 1);
_bonusFailGo.transform.localScale = new Vector3(100, 100, 1);
_isShowingSCResult = true;
// 更新BossInfo
if (_isShowBossInfo)
{
if (_bossInfoSCLeft > 0)
{
_bossInfoSCLeft--;
GameObject starGo = _bossInfoStarList[_bossInfoSCLeft].gameObject;
TweenAlpha tween0 = TweenManager.GetInstance().Create <TweenAlpha>();
tween0.SetParas(starGo, 0, 30, ePlayMode.Once);
tween0.SetParas(0, InterpolationMode.Linear);
TweenManager.GetInstance().AddTween(tween0);
TweenScale tween1 = TweenManager.GetInstance().Create <TweenScale>();
tween1.SetParas(starGo, 0, 30, ePlayMode.Once);
tween1.SetParas(new Vector3(2, 2, 1), InterpolationMode.EaseOutQuad);
TweenManager.GetInstance().AddTween(tween1);
}
else
{
_isShowBossInfo = false;
_bossInfoGo.SetActive(false);
}
}
}
else
{
_spellCardResultPanel.SetActive(false);
}
}
public static int PlayForwardAll()
{
return(TweenManager.FilteredOperation(OperationType.PlayForward, FilterType.All, null, false, 0f, null, null));
}
public static int CompleteAll(bool withCallbacks = false)
{
return(TweenManager.FilteredOperation(OperationType.Complete, FilterType.All, null, false, withCallbacks ? ((float)1) : ((float)0), null, null));
}
public static int RewindAll(bool includeDelay = true)
{
return(TweenManager.FilteredOperation(OperationType.Rewind, FilterType.All, null, includeDelay, 0f, null, null));
}
internal static int CompleteAndReturnKilledTot()
{
return(TweenManager.FilteredOperation(OperationType.Complete, FilterType.All, null, true, 0f, null, null));
}
public static int TogglePauseAll()
{
return(TweenManager.FilteredOperation(OperationType.TogglePause, FilterType.All, null, false, 0f, null, null));
}
internal static int CompleteAndReturnKilledTotExceptFor(params object[] excludeTargetsOrIds)
{
return(TweenManager.FilteredOperation(OperationType.Complete, FilterType.AllExceptTargetsOrIds, null, true, 0f, null, excludeTargetsOrIds));
}
public static List <Tween> TweensByTarget(object target, bool playingOnly = false)
{
return(TweenManager.GetTweensByTarget(target, playingOnly));
}
public static int FlipAll()
{
return(TweenManager.FilteredOperation(OperationType.Flip, FilterType.All, null, false, 0f, null, null));
}
// ===================================================================================
// METHODS ---------------------------------------------------------------------------
// Returns TRUE if the tween needs to be killed
static bool ApplyInternalCycle(Sequence s, float fromPos, float toPos, UpdateMode updateMode, bool useInverse, bool prevPosIsInverse, bool multiCycleStep = false)
{
bool isBackwardsUpdate = toPos < fromPos;
// Debug.Log(Time.frameCount + " " + s.id + " " + (multiCycleStep ? "<color=#FFEC03>Multicycle</color> > " : "Cycle > ") + s.position + "/" + s.duration + " - s.isBackwards: " + s.isBackwards + ", useInverse/prevInverse: " + useInverse + "/" + prevPosIsInverse + " - " + fromPos + " > " + toPos + " - UpdateMode: " + updateMode + ", isPlaying: " + s.isPlaying + ", completedLoops: " + s.completedLoops);
if (isBackwardsUpdate)
{
int len = s._sequencedObjs.Count - 1;
for (int i = len; i > -1; --i)
{
if (!s.active)
{
return(true); // Killed by some internal callback
}
ABSSequentiable sequentiable = s._sequencedObjs[i];
if (sequentiable.sequencedEndPosition < toPos || sequentiable.sequencedPosition > fromPos)
{
continue;
}
if (sequentiable.tweenType == TweenType.Callback)
{
if (updateMode == UpdateMode.Update && prevPosIsInverse)
{
// Debug.Log("<color=#FFEC03>BACKWARDS Callback > " + s.id + " - s.isBackwards: " + s.isBackwards + ", useInverse/prevInverse: " + useInverse + "/" + prevPosIsInverse + " - " + fromPos + " > " + toPos + "</color>");
OnTweenCallback(sequentiable.onStart);
}
}
else
{
// Nested Tweener/Sequence
float gotoPos = toPos - sequentiable.sequencedPosition;
// float gotoPos = (float)((decimal)toPos - (decimal)sequentiable.sequencedPosition);
if (gotoPos < 0)
{
gotoPos = 0;
}
Tween t = (Tween)sequentiable;
if (!t.startupDone)
{
continue; // since we're going backwards and this tween never started just ignore it
}
t.isBackwards = true;
if (TweenManager.Goto(t, gotoPos, false, updateMode))
{
return(true);
}
// Fixes nested callbacks not being called correctly if main sequence has loops and nested ones don't
if (multiCycleStep && t.tweenType == TweenType.Sequence)
{
if (s.position <= 0 && s.completedLoops == 0)
{
t.position = 0;
}
else
{
bool toZero = s.completedLoops == 0 || s.isBackwards && (s.completedLoops < s.loops || s.loops == -1);
if (t.isBackwards)
{
toZero = !toZero;
}
if (useInverse)
{
toZero = !toZero;
}
if (s.isBackwards && !useInverse && !prevPosIsInverse)
{
toZero = !toZero;
}
t.position = toZero ? 0 : t.duration;
}
}
}
}
}
else
{
// Debug
int len = s._sequencedObjs.Count;
for (int i = 0; i < len; ++i)
{
if (!s.active)
{
return(true); // Killed by some internal callback
}
ABSSequentiable sequentiable = s._sequencedObjs[i];
if (sequentiable.sequencedPosition > toPos || sequentiable.sequencedEndPosition < fromPos)
{
continue;
}
if (sequentiable.tweenType == TweenType.Callback)
{
if (updateMode == UpdateMode.Update)
{
// Debug.Log("<color=#FFEC03>FORWARD Callback > " + s.id + " - s.isBackwards: " + s.isBackwards + ", useInverse/prevInverse: " + useInverse + "/" + prevPosIsInverse + " - " + fromPos + " > " + toPos + "</color>");
bool fire = !s.isBackwards && !useInverse && !prevPosIsInverse ||
s.isBackwards && useInverse && !prevPosIsInverse;
if (fire)
{
OnTweenCallback(sequentiable.onStart);
}
}
}
else
{
// Nested Tweener/Sequence
float gotoPos = toPos - sequentiable.sequencedPosition;
// float gotoPos = (float)((decimal)toPos - (decimal)sequentiable.sequencedPosition);
if (gotoPos < 0)
{
gotoPos = 0;
}
Tween t = (Tween)sequentiable;
t.isBackwards = false;
if (TweenManager.Goto(t, gotoPos, false, updateMode))
{
return(true);
}
// Fixes nested callbacks not being called correctly if main sequence has loops and nested ones don't
if (multiCycleStep && t.tweenType == TweenType.Sequence)
{
if (s.position <= 0 && s.completedLoops == 0)
{
t.position = 0;
}
else
{
bool toZero = s.completedLoops == 0 || !s.isBackwards && (s.completedLoops < s.loops || s.loops == -1);
if (t.isBackwards)
{
toZero = !toZero;
}
if (useInverse)
{
toZero = !toZero;
}
if (s.isBackwards && !useInverse && !prevPosIsInverse)
{
toZero = !toZero;
}
t.position = toZero ? 0 : t.duration;
}
}
}
}
}
return(false);
}
public static int GotoAll(float to, bool andPlay = false)
{
return(TweenManager.FilteredOperation(OperationType.Goto, FilterType.All, null, andPlay, to, null, null));
}
public static void ClearCachedTweens()
{
TweenManager.PurgePools();
}
public static bool IsTweening(object targetOrId)
{
return(TweenManager.FilteredOperation(OperationType.IsTweening, FilterType.TargetOrId, targetOrId, false, 0f, null, null) > 0);
}
public static int CompleteAll()
{
return(TweenManager.FilteredOperation(OperationType.Complete, FilterType.All, null, false, 0f, null));
}
public static TweenManager instance()
{
if (_instance == null)
_instance = GameObject.Find ("AllTogetherGame").GetComponent<TweenManager> ();
return _instance;
}
