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); }