EasyPrimeTween/EasyPrimeSequence.cs at main · UnioGame/EasyPrimeTween · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
namespace Game.Runtime.EasyPrimeTweens
{
    using System;
    using Data;
    using Interfaces;
    using PrimeTween;
    using Sirenix.OdinInspector;
    using UnityEngine;

    public class EasyPrimeSequence : MonoBehaviour, IEasyPrimeSequence
    {
        [BoxGroup("Settings"), HideLabel]
        [SerializeField]
        private SequenceSettings sequenceSettings;

        [SerializeField, BoxGroup("Settings")]
        private bool playOnEnable;

        [SerializeReference]
        public ITween[] tweens;

        private Sequence _sequence;
        private Sequence _backwardsSequence;

        public Sequence Sequence => _sequence;
        public Sequence BackwardSequence => _backwardsSequence;

        public void OnEnable()
        {
            if (playOnEnable)
                Play();
        }

        [ButtonGroup]
        public void Play()
        {
            if (_backwardsSequence.isAlive)
                _backwardsSequence.Stop();

            if (_sequence.isAlive) return;

            _sequence = Sequence.Create(
                sequenceSettings.cycles,
                sequenceSettings.cycleMode,
                sequenceSettings.sequenceEase,
                sequenceSettings.useUnscaledTime,
                sequenceSettings.useFixedUpdate
            );

            foreach (var tween in tweens)
            {
                tween.Play();
                if (!tween.Tween.isAlive) continue;
                switch (tween.PlayInSequenceType)
                {
                    case PlayInSequenceType.Chain:
                        _sequence.Chain(tween.Tween);
                        break;
                    case PlayInSequenceType.Group:
                        _sequence.Group(tween.Tween);
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
        }

        [ButtonGroup]
        public void Backwards()
        {
            if (_sequence.isAlive)
                _sequence.Stop();

            if (_backwardsSequence.isAlive) return;

            _backwardsSequence = Sequence.Create();

            for (var i = tweens.Length - 1; i >= 0; i--)
            {
                var tween = tweens[i];
                tween.Backward();

                if (!tween.Tween.isAlive) continue;

                switch (tween.PlayInSequenceType)
                {
                    case PlayInSequenceType.Chain:
                        _backwardsSequence.Chain(tween.BackwardTween);
                        break;
                    case PlayInSequenceType.Group:
                        _backwardsSequence.Group(tween.BackwardTween);
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
        }

        [ButtonGroup]
        public void Stop()
        {
            if (_sequence.isAlive)
                _sequence.Stop();

            if (_backwardsSequence.isAlive)
                _backwardsSequence.Stop();
        }

        [ButtonGroup]
        public void Reset()
        {
            Stop();

            foreach (var tween in tweens)
            {
                tween.Reset();
            }
        }

        public void Restart()
        {
            Reset();
            Play();
        }

        private void OnDisable() => Stop();

        private void OnDestroy()
        {
            foreach (var tween in tweens)
            {
                tween.Dispose();
            }
        }
    }
}