def _animate(self, name, value, duration=.1, curve=curve.in_expo, loop=False, resolution=None, interrupt=True, time_step=None, auto_destroy=True):
animator_name = name + '_animator'
# print('start animating value:', name, animator_name )
if interrupt and hasattr(self, animator_name):
getattr(self, animator_name).pause()
# print('interrupt', animator_name)
else:
try:
getattr(self, animator_name).finish()
except:
pass
setattr(self, animator_name, Sequence(loop=loop, time_step=time_step, auto_destroy=auto_destroy))
sequence = getattr(self, animator_name)
self.animations.append(sequence)
# sequence.append(Wait(delay))
if not resolution:
resolution = max(int(duration * 60), 1)
for i in range(resolution+1):
t = i / resolution
# if isinstance(curve, CubicBezier):
# t = curve.calculate(t)
# else:
t = curve(t)
sequence.append(Wait(duration / resolution))
sequence.append(Func(setattr, self, name, lerp(getattr(self, name), value, t)))
sequence.start()
return sequence
def _animate(self, name, value, duration=.1, curve=curve.in_expo, resolution=None, interrupt=True):
animator_name = name + '_animator'
# print('start animating value:', name, animator_name )
if interrupt and hasattr(self, animator_name):
try:
getattr(self, animator_name).pause()
# print('interrupt', animator_name)
except:
pass
else:
try:
getattr(self, animator_name).finish()
except:
pass
setattr(self, animator_name, Sequence())
sequence = getattr(self, animator_name)
self.animations.append(sequence)
# sequence.append(Wait(delay))
if not resolution:
resolution = max(int(duration * 60), 1)
for i in range(resolution+1):
t = i / resolution
t = curve(t)
sequence.append(Wait(duration / resolution))
sequence.append(Func(setattr, self, name, lerp(getattr(self, name), value, t)))
sequence.start()
return sequence
def animate(self, name, value, duration=.1, delay=0, curve=curve.in_expo, loop=False, resolution=None, interrupt=True, time_step=None, auto_destroy=True):
s = Sequence(
Wait(delay),
Func(self._animate, name, value, duration, curve, loop, resolution, interrupt, time_step, auto_destroy)
)
s.start()
return s
def destroy(entity, delay=0):
if delay == 0:
_destroy(entity)
return
s = Sequence(Wait(delay), Func(_destroy, entity))
s.start()
def animate(self,
name,
value,
duration=.1,
delay=0,
curve=curve.in_expo,
loop=False,
resolution=None,
interrupt='kill',
time_step=None,
auto_destroy=True):
if duration == 0 and delay == 0:
setattr(self, name, value)
return None
if delay:
from ursina.ursinastuff import invoke
return invoke(self.animate,
name,
value,
duration=duration,
curve=curve,
loop=loop,
resolution=resolution,
time_step=time_step,
auto_destroy=auto_destroy,
delay=delay)
animator_name = name + '_animator'
# print('start animating value:', name, animator_name )
if interrupt and hasattr(self, animator_name):
getattr(getattr(self, animator_name), interrupt)(
) # call kill() or finish() depending on what the interrupt value is.
# print('interrupt', interrupt, animator_name)
sequence = Sequence(loop=loop,
time_step=time_step,
auto_destroy=auto_destroy)
setattr(self, animator_name, sequence)
self.animations.append(sequence)
if not resolution:
resolution = max(int(duration * 60), 1)
for i in range(resolution + 1):
t = i / resolution
t = curve(t)
sequence.append(Wait(duration / resolution))
sequence.append(
Func(setattr, self, name, lerp(getattr(self, name), value, t)))
sequence.start()
return sequence
def invoke(function, *args, **kwargs):
if 'delay' in kwargs and kwargs['delay'] <= 0:
print('invoke delay is <= 0')
function(*args)
return function
s = Sequence()
if 'delay' in kwargs:
s.append(Wait(kwargs['delay']))
s.append(Func(function, *args))
s.start()
return s
def blink(self, value=color.clear, duration=.1, delay=0, curve=curve.in_expo, resolution=None, interrupt=False, time_step=None):
_original_color = self.color
if hasattr(self, 'blink_animator'):
self.blink_animator.finish()
self.blink_animator.kill()
# print('finish blink_animator')
self.blink_animator = Sequence(
Func(self.animate_color, value, duration*.4, 0, curve, resolution, interrupt),
Func(self.animate_color, _original_color, duration*.4, duration*.5, curve, resolution, interrupt, time_step)
)
self.blink_animator.start()
return self.blink_animator
def invoke(function, *args, **kwargs):
delay = 0
if 'delay' in kwargs:
delay = kwargs['delay']
del kwargs['delay']
if not delay:
function(*args, **kwargs)
return function
s = Sequence(Wait(delay), Func(function, *args, **kwargs))
s.start()
return s
def shake(self, duration=.2, magnitude=1, speed=.05, direction=(1,1)):
s = Sequence()
self.original_position = self.position
for i in range(int(duration / speed)):
s.append(self.posInterval(speed, Point3(
self.x + (random.uniform(-.1, .1) * magnitude * direction[0]),
self.z,
self.y + (random.uniform(-.1, .1) * magnitude * direction[1]))
))
s.append(self.posInterval(speed, Point3(
self.original_position[0],
self.original_position[2],
self.original_position[1])
))
s.start()
def shake(self, duration=.2, magnitude=1, speed=.05, direction=(1,1)):
import random
s = Sequence()
original_position = self.position
for i in range(int(duration / speed)):
s.append(Func(self.set_position,
Vec3(
original_position[0] + (random.uniform(-.1, .1) * magnitude * direction[0]),
original_position[1] + (random.uniform(-.1, .1) * magnitude * direction[1]),
original_position[2],
)))
s.append(Wait(speed))
s.append(Func(self.set_position, original_position))
s.start()
return s
def appear(self, speed=.025, delay=0):
from ursina.ursinastuff import invoke
self.enabled = True
# self.visible = True # setting visible seems to reset the colors
if self.appear_sequence:
self.appear_sequence.finish()
x = 0
self.appear_sequence = Sequence()
for i, tn in enumerate(self.text_nodes):
target_text = tn.node().getText()
tn.node().setText('')
new_text = ''
for j, char in enumerate(target_text):
new_text += char
self.appear_sequence.append(Wait(speed))
self.appear_sequence.append(Func(tn.node().setText, new_text))
self.appear_sequence.start()
return self.appear_sequence
def animate(self, name, value, duration=.1, delay=0, curve=curve.in_expo, resolution=None, interrupt=True):
Sequence(
Wait(delay),
Func(self._animate, name, value, duration, curve, resolution, interrupt)
).start()
