screenMeltDoom/tweening.py at master · ameuret/screenMeltDoom · 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
import pyxel
import math
import pytweening

class TimedValue():
    def __init__(self, v=0, duration=30, f='easeOutElastic', offset=0, delay=0, p=None, autoreset=False, inverted=False, bounce=False):
        """
        d: duration (in frames).
        f: easing function name. Look them up at http://easings.net.
        offset: start from a non-zero value.
        p: instance of TimedValue to copy parameters from.
        delay: start after this many frames
        """

        if p:
            self.buildFromPeer(p)
        else:
            self.v = v
            self.duration = duration
            self.function = getattr(pytweening, f)
            self.offset = offset
            self.autoreset = autoreset
            self.inverted = inverted
            self.bounce = bounce
            self.delay = delay

        self.reset()

        self.FORWARD = True
        self.BACK = not self.FORWARD

        self.dir = self.FORWARD
        self.lastBounceTime = -1

    def buildFromPeer(self, p):
        self.v = p.v
        self.duration = p.duration
        self.function = p.function
        self.offset = p.offset
        self.autoreset = p.autoreset
        self.inverted = p.inverted
        self.bounce = p.bounce
        self.delay = p.delay

    def value(self):
        if pyxel.frame_count < self.delayedBirthTime: return self.offset

        progress = (pyxel.frame_count - self.delayedBirthTime) / self.duration

        if self.bounce:
            p = self.bouncingProgress(progress)
        else:
            p = self.normalProgress(progress)

        return self.offset + (self.v - self.offset) * self.function(p)

    def normalProgress(self, p):
        if p >= 1:
            if self.autoreset:
                self.reset()
                p = 0
            else:
                p = 1

        if self.inverted:
            p = 1 - p

        return p

    def bouncingProgress(self, p):
        if p < 1: return p
        pp = math.floor(p)
        if pp % 2 == 1:
            r = 1 - (p - pp)
        else:
            r = p - pp
        return r

    def setValue(self, newVal):
        """
        Change the target value. Can be called at any time.
        """
        self.v = newVal

    def reset(self):
        """
        Reset the birth time, effectively restarting the interpolation.
        """
        self.birthTime = pyxel.frame_count
        self.delayedBirthTime = self.birthTime + self.delay

#################################################################################

class TimedBool():
    def __init__(self, delay=30, autoreset=False):
        """
        delay: delay before which the value becomes True (in frames).
        """
        self.birthTime = pyxel.frame_count
        self.delay = delay
        self.autoreset = autoreset

    def reset(self, delay=0):
        """
        Reset the birth time, effectively restarting the countdown.
        delay: new delay
        """
        if delay > 0:
            self.delay = delay
        self.birthTime = pyxel.frame_count

    def value(self):
        if pyxel.frame_count > self.birthTime + self.delay:
            if self.autoreset: self.reset()
            return True
        return False

    def true(self):
        return self.value()

    def false(self):
        return not self.value()

    def elapsed(self):
        return self.value()

    def up(self):
        return self.value()