public void Initialize(IUniTweenSequencePlayer owner, string name, int loops = 0, LoopType loopType = LoopType.Incremental, float timeScale = 1)
{
if (HasInitialized)
{
throw new Exception("Trying to initialize a Sequence that's already initialized.");
}
TweenPlayer = owner;
SequenceInstance = DOTween.Sequence();
SequenceInstance.SetId($"{owner.DisplayName}_{name}");
SequenceInstance.SetAutoKill(false);
SequenceInstance.SetLoops(loops, loopType);
SequenceInstance.timeScale = timeScale;
originalTimeScale = timeScale;
foreach (var uniTween in uniTweens)
{
switch (uniTween.operation)
{
case UniTweenObject.TweenOperation.Append:
SequenceInstance.Append(GetTween(uniTween, TweenPlayer.gameObject, TweenPlayer.DisplayName));
break;
case UniTweenObject.TweenOperation.AppendInterval:
SequenceInstance.AppendInterval(uniTween.GetInterval());
break;
case UniTweenObject.TweenOperation.AppendCallback:
SequenceInstance.AppendCallback(uniTween.unityEvent.Invoke);
break;
case UniTweenObject.TweenOperation.Join:
SequenceInstance.Join(GetTween(uniTween, TweenPlayer.gameObject, TweenPlayer.DisplayName));
break;
}
}
}
private void Fake_FakeBossMove(Transform fakeBoss, Vector3 dest)
{
var effect1 = new Effect <Transform, Vector3> ();
effect1.Duration = 2f;
effect1.RetrieveStart = (fake, lastValue) => fake.position;
effect1.RetrieveEnd = (fake) => dest;
effect1.OnUpdate = (fake, pos) => fake.position = pos;
var effect2 = new Effect <Transform, Vector3> ();
effect2.Duration = _fakeDashTime;
effect2.RetrieveStart = (fake, lastValue) => lastValue;
effect2.RetrieveEnd = (fake) => new Vector3(dest.x,
BulletDestroyBound.Instance.Center.y - BulletDestroyBound.Instance.Size.y * 0.65f, dest.z);
effect2.OnUpdate = (fake, pos) => fake.position = pos;
effect2.CalculatePercentDone = Easing.GetEase(Easing.EaseType.Pow3Out);
var seq = new Sequence <Transform, Vector3> ();
seq.Add(effect1);
seq.Add(effect2);
seq.Reference = fakeBoss;
seq.OnComplete = (fake) =>
{
_fakeBossShotPattern.transform.position = fake.position;
_fakeBossShotPattern.OnShotFinish += (shotPattern) => Destroy(fake.gameObject);
_fakeBossShotPattern.Shot();
};
_fakeBossMoveSeq = Movement.Run(seq);
}
private void WindPause_Move()
{
var seq = new Sequence <Transform, Vector3> ();
seq.Reference = _falcon;
Effect <Transform, Vector3> effect;
for (int i = 0; i < _windPauseStateMovePoints.Length - 1; i++)
{
effect = new Effect <Transform, Vector3> ();
effect.Duration = (_windPauseStateMovePoints[i] - _windPauseStateMovePoints[i + 1]).magnitude /
_windPauseStateMoveSpeed;
effect.RetrieveStart = (falcon, lastValue) => _windPauseStateMovePoints[i];
effect.RetrieveEnd = (falcon) => _windPauseStateMovePoints[i + 1];
effect.OnUpdate = (falcon, pos) => falcon.position = pos;
seq.Add(effect);
}
effect = new Effect <Transform, Vector3> ();
effect.Duration = (_windPauseStateMovePoints[_windPauseStateMovePoints.Length - 1] -
_windPauseStateMovePoints[0]).magnitude / _windPauseStateMoveSpeed;
effect.RetrieveStart = (falcon, lastValue) => lastValue;
effect.RetrieveEnd = (falcon) => _windPauseStateMovePoints[0];
effect.OnUpdate = (falcon, pos) => falcon.position = pos;
seq.Add(effect);
_windPauseMoveIns = Movement.Run(seq);
_windPauseMoveIns.Loop = true;
}
private void Fake_RealBossMove(Vector3 dest)
{
var moveEffect = new Effect <Transform, Vector3> ();
moveEffect.Duration = 2f;
moveEffect.RetrieveStart = (falcon, lastValue) => falcon.position;
moveEffect.RetrieveEnd = (falcon) => dest;
moveEffect.OnUpdate = (falcon, pos) => falcon.position = pos;
moveEffect.RunEffectUntilTime = (curTime, stopTime) => curTime < stopTime + _fakeDashTime;
moveEffect.OnDone = (falcon) =>
{
_realBossShotPattern.transform.position = falcon.position;
_realBossShotPattern.Shot();
};
var pauseEffect = new Effect <Transform, Vector3> ();
pauseEffect.Duration = _fakeStateWaitTime;
pauseEffect.OnUpdate = (falcon, pos) => Debug.Log(Time.time);
var seq = new Sequence <Transform, Vector3> ();
seq.Add(moveEffect);
seq.Add(pauseEffect);
seq.Reference = _falcon;
seq.OnComplete = (falcon) => Fake_Transistion();
_realBossMoveSeq = Movement.Run(seq);
}
private IEnumerator SideWind_BossMove()
{
Vector3 downPoint = new Vector3(_sideWindBossCenter.x,
BulletDestroyBound.Instance.Down - 1f, _sideWindBossCenter.z);
Vector3 upPoint = new Vector3(_sideWindBossCenter.x,
BulletDestroyBound.Instance.Up + 1f, _sideWindBossCenter.z);
var effect1 = new Effect <Transform, Vector3> ();
effect1.Duration = 3 * 1f / _sideWindMoveSpeed;
effect1.RetrieveStart = (falcon, lastValue) => falcon.position;
effect1.RetrieveEnd = (falcon) => downPoint;
effect1.OnUpdate = (falcon, value) => falcon.position = value;
effect1.CalculatePercentDone = Easing.GetEase(Easing.EaseType.Pow2Out);
var effect2 = new Effect <Transform, Vector3> ();
effect2.Duration = 1 * 1f / _sideWindMoveSpeed;
effect2.RetrieveStart = (falcon, lastValue) => upPoint;
effect2.RetrieveEnd = (falcon) => _sideWindBossCenter;
effect2.OnUpdate = (falcon, value) => falcon.position = value;
effect2.CalculatePercentDone = Easing.GetEase(Easing.EaseType.Pow2Out);
var seq = new Sequence <Transform, Vector3> ();
seq.Reference = _falcon;
seq.Add(effect1);
seq.Add(effect2);
_sideBossMoveSeqInstance = Movement.Run(seq);
yield return(new WaitForSeconds(effect1.Duration + effect2.Duration));
}
public SequenceInstance ActivateSequence(Sequence sequence)
{
SequenceInstance instance = new SequenceInstance(sequence);
addedSequences.Enqueue(instance);
return(instance);
}
public void Kill()
{
if (HasInitialized && SequenceInstance.IsPlaying())
{
SequenceInstance.Pause();
}
SequenceInstance.Kill();
}
public void AbortSequence(SequenceInstance sequence)
{
if (!activeSequences.Contains(sequence))
{
return;
}
removedSequences.Enqueue(sequence);
}
void OnWalkComplete(ActionState walkState)
{
if (interactionTarget != null)
{
interactionTarget.DoInteract(controlledActor);
}
interactionTarget = null;
sequenceInstance = null;
}
// /////////////////////////////////////////////////////////////////////////////////////////
// Here is where I run both sequences whenever the "Run Test" button is pressed and also at start.
//
// Movement.Run starts everything in motion. Here I'm setting the inertia and springiness for
// the smoothed sequence, but leaving it alone on the linear sequence. I'm also saving the
// SequenceInstance variable for the smoothed sequence that is returned by Sequence.Run. You
// don't need to save that variable unless you want to modify or kill sequences while they are
// running, but I want to modify the smoothed instance so we save it here. I then modify the
// inertia or springiness value in the instance every time I get a "value changed" event from
// one of the sliders.
//
// Feel free to consider this project a standbox. Play around with the positions, set variables,
// etc. I like an inertia of .72 and a springiness of .98.
//
// If you want to get a better feel for Slerp then try adding the following line in RunTest:
// _smoothedSequence.MovementSpace = Movement.MovementSpace.Spherical;
// Slerp moves in spheres and circles around the zero point and is mostly used for rotations.
// /////////////////////////////////////////////////////////////////////////////////////////
public void RunTest()
{
Movement.Run(_linearSequence);
for (int i = 0; i < _smoothedSequence.Effects.Length; i++)
{
_smoothedSequence.Inertia = _inertia;
_smoothedSequence.Elasticity = _elasticity;
}
_smoothedInstance = Movement.Run(_smoothedSequence);
_smoothedInstance.Timescale = _timescale;
_smoothedInstance.Loop = _loop;
}
private bool CanShowResumeButton()
{
if (!Application.isPlaying)
{
return(false);
}
if (SequenceInstance == null)
{
return(false);
}
float elapsedPercentage = SequenceInstance.ElapsedPercentage();
return(!SequenceInstance.IsPlaying() && elapsedPercentage > 0 && elapsedPercentage < 1);
}
public void Activate(SequenceInstance sequence)
{
targetActor = Actor.GetActorByName(targetActorName);
System.Type actionType = System.Type.GetType(actionClass);
// validate variables?
action = (Action)System.Activator.CreateInstance(actionType);
if (action == null)
{
Debug.LogError("Invalid action class: " + actionClass);
Complete();
return;
}
action.Init(sequence, this);
action.OnActivate();
}
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonDown(0) && !SteamPunkConsole.IsConsoleOpen &&
!UnityEngine.EventSystems.EventSystem.current.IsPointerOverGameObject())
{
Vector3 targetPosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
// if clicked on a thing
// do, interact sequence
Collider2D hitCollider = Physics2D.OverlapPoint(targetPosition, LayerMask.GetMask("Interactable"));
if (hitCollider)
{
// determine where to walk to interact. (interaction distance stored in target?)
// update the walk sequence (abort it if its already running) this is the only time we need to 'cancel' a sequence.
// when we've arrived, call 'DoInteract' on target.
interactionTarget = hitCollider.GetComponent <IInteractable>();
if (interactionTarget != null)
{
if (interactionTarget.CanInteract(controlledActor))
{
if (sequenceInstance != null)
{
GameInstance.Singleton.SequenceManager.AbortSequence(sequenceInstance);
}
walkSequence.actionStates[0].Set("Position Target", (Vector2)interactionTarget.GetInteractionPosition(controlledActor));
sequenceInstance = GameInstance.Singleton.SequenceManager.ActivateSequence(walkSequence);
}
}
}
else
{
interactionTarget = null;
targetPosition.z = 0;
walkSequence.actionStates[0].Set("Position Target", (Vector2)targetPosition);
if (sequenceInstance != null)
{
GameInstance.Singleton.SequenceManager.AbortSequence(sequenceInstance);
}
sequenceInstance = GameInstance.Singleton.SequenceManager.ActivateSequence(walkSequence);
}
}
}
private void JustPlay()
{
if (Enabled)
{
if (SequenceInstance.IsComplete())
{
SequenceInstance.Rewind();
}
SequenceInstance.Play();
}
else
{
if (SequenceInstance.onComplete != null)
{
SequenceInstance.onComplete.Invoke();
}
}
}
// Update is called once per frame
void Update()
{
foreach (SequenceInstance sequence in activeSequences)
{
sequence.Tick();
}
while (addedSequences.Count != 0)
{
SequenceInstance sequence = addedSequences.Dequeue();
activeSequences.Add(sequence);
sequence.onSequenceComplete += OnSequenceComplete;
sequence.Start();
}
while (removedSequences.Count != 0)
{
activeSequences.Remove(removedSequences.Dequeue());
}
}
private bool CanShowPauseButton()
{
return(Application.isPlaying && SequenceInstance != null && SequenceInstance.IsPlaying());
}
public void Rewind()
{
SequenceInstance.Rewind();
}
public void Pause()
{
SequenceInstance.Pause();
}
public void Resume()
{
SequenceInstance.Play();
}
public void Init(SequenceInstance sequence, ActionState actionState)
{
Sequence = sequence;
State = actionState;
}
void OnSequenceComplete(SequenceInstance sequence)
{
removedSequences.Enqueue(sequence);
}
