def animation(self):
animation_state = AnimationState(self.mode)
animation_list = [FieldColorsAnimation(animation_state, self.board.field)]
while not self.animation_thread.stopped() or animation_list[-1].is_blocking() or not self.queue.empty():
if not animation_list[-1].is_blocking():
try:
event = self.queue.get_nowait()
# some animations have to stop when a new one is started
animation_list[-1].new_animation_available()
if event[0] == PLAY:
super().player_plays(*event[1:3])
animation_list.append(PlayAnimation(animation_state))
elif event[0] == UNDO:
x = event[1]
y = event[2]
z = self.get_z(x, y)
c = self.board.next_color
animation_list.append(UndoAnimation(animation_state, x, y, z, c))
elif event[0] == SELECT:
x = event[1]
y = event[2]
z = self.get_z(x, y)
c = self.board.next_color
top = self.board.field(x, y, z) is not EMPTY
animation_list.append(SelectAnimation(animation_state, x, y, z, c, top))
elif event[0] == FINISH:
c = RED
if self.board.next_color == RED:
c = BLUE
animation_list.append(FinishAnimation(animation_state, event[1], c))
except Empty:
pass
cube_buffer = get_empty_cube_buffer()
for a in animation_list:
a.animate(cube_buffer)
# remove completed animations from list
animation_list[:] = [a for a in animation_list if not a.is_done()]
# draw the completed cube
self.cube.draw(cube_buffer)
self.cube.show()
animation_state.update()
if not is_a_raspberry():
sleep(0.01)
def run(self):
steps = 100
try:
while True:
self.wheel_stop = self.get_random_wheel()
for i in range(steps):
if self.button_events.get_event(block=False):
LOG.debug("button pressed, interrupting rainbow")
raise RandomInterrupted()
self.step(self.wheel_start, self.wheel_stop, float(i) / steps)
self.cube.draw(self.cube_buffer)
self.cube.show()
if not is_a_raspberry():
sleep(0.02)
self.wheel_start = copy.deepcopy(self.wheel_stop)
except RandomInterrupted:
return
def run(self) -> None:
try:
last_time = monotonic()
self.apple.set_random_position(self.snake.snake)
while True:
self.handle_events()
current_time = monotonic()
if (current_time - last_time) > DELAY:
last_time = current_time
self.snake.move(self.apple)
cube_buffer = get_empty_cube_buffer()
cube_buffer = self.apple.draw(cube_buffer)
cube_buffer = self.snake.draw(cube_buffer)
self.cube.draw(cube_buffer)
self.cube.show()
if not is_a_raspberry():
sleep(0.01)
except SnakeCollision:
LOG.debug("collision")
self.death_animation()
return
except SnakeInterrupted:
return
def run(self):
try:
while True:
self.handle_events()
v = [
sin(self.theta) * cos(self.phi),
sin(self.theta) * sin(self.phi),
cos(self.theta)
]
self.rainbow(self.cube_buffer, v, self.wheel_offset)
self.cube.draw(self.cube_buffer)
self.cube.show()
# Rotate vector
self.theta += self.theta_d
self.phi += self.phi_d
# Cycle through all colors so the rainbow not only rotates, but also
# moves through the cube.
self.wheel_offset += self.wheel_offset_d
self.wheel_offset %= 256
if not is_a_raspberry():
sleep(0.02)
except RainbowInterrupted:
return
import logging
import copy
from random import randint
from connect4cube.app import App
from connect4cube.hardware.button_events import ButtonEvents
from connect4cube.hardware.cube import Cube, get_empty_cube_buffer
from connect4cube.hardware.util import is_a_raspberry
from connect4cube.util.color import wheel
if not is_a_raspberry():
from time import sleep
LOG = logging.getLogger(__name__)
class Random(App):
"""
fill the cube with random stuff and change it slowly
"""
def __init__(self):
self.button_events = ButtonEvents()
self.cube = Cube()
self.cube_buffer = get_empty_cube_buffer()
self.wheel_start = self.get_random_wheel()
self.wheel_stop = self.get_random_wheel()
def run(self):
steps = 100
try:
while True:
def __init__(self,
axis_up=19,
axis_down=26,
axis_left=6,
axis_right=13,
button_a=12,
button_b=16):
"""
all pin numbers in BMC, see https://pinout.xyz/
"""
if not is_a_raspberry():
Device.pin_factory = MockFactory()
pin2fn = {
axis_up:
(lambda: self.button_pressed_dir(EventEnum.UP_PRESSED),
lambda: self.button_repeated(EventEnum.UP_REPEATED),
lambda: self.button_released(EventEnum.UP_PRESSED)),
axis_down:
(lambda: self.button_pressed_dir(EventEnum.DOWN_PRESSED),
lambda: self.button_repeated(EventEnum.DOWN_REPEATED),
lambda: self.button_released(EventEnum.DOWN_PRESSED)),
axis_left:
(lambda: self.button_pressed_dir(EventEnum.LEFT_PRESSED),
lambda: self.button_repeated(EventEnum.LEFT_REPEATED),
lambda: self.button_released(EventEnum.LEFT_PRESSED)),
axis_right:
(lambda: self.button_pressed_dir(EventEnum.RIGHT_PRESSED),
lambda: self.button_repeated(EventEnum.RIGHT_REPEATED),
lambda: self.button_released(EventEnum.RIGHT_PRESSED)),
button_a: (lambda: self.button_pressed(EventEnum.A_PRESSED),
lambda: self.button_repeated(EventEnum.A_REPEATED),
lambda: self.button_released(EventEnum.A_PRESSED)),
button_b: (lambda: self.button_pressed(EventEnum.B_PRESSED),
lambda: self.button_repeated(EventEnum.B_REPEATED),
lambda: self.button_released(EventEnum.B_PRESSED)),
}
self.buttons = []
for pin, fns in pin2fn.items():
# Debouncing function of Button (argument bounce_time) is broken and is not usable.
button = Button(pin, hold_repeat=True, hold_time=1)
button.when_pressed = fns[0]
button.when_held = fns[1]
button.when_released = fns[2]
self.buttons.append(button)
self.last_up_time = self.LastEventTime()
self.last_down_time = self.LastEventTime()
self.last_left_time = self.LastEventTime()
self.last_right_time = self.LastEventTime()
self.last_a_time = self.LastEventTime()
self.last_b_time = self.LastEventTime()
self.last_event_times = {
EventEnum.UP_PRESSED: self.last_up_time,
EventEnum.DOWN_PRESSED: self.last_down_time,
EventEnum.LEFT_PRESSED: self.last_left_time,
EventEnum.RIGHT_PRESSED: self.last_right_time,
EventEnum.A_PRESSED: self.last_a_time,
EventEnum.B_PRESSED: self.last_b_time
}
# Dictionary to get the event times of the reverse direction.
# Used for additional debouncing of joystick.
self.last_reverse_dir_event_times = {
EventEnum.UP_PRESSED: self.last_down_time,
EventEnum.DOWN_PRESSED: self.last_up_time,
EventEnum.LEFT_PRESSED: self.last_right_time,
EventEnum.RIGHT_PRESSED: self.last_left_time
}
self.lock = Lock()
self.event_queue = Queue()
def __init__(self):
if is_a_raspberry():
self.cube = LedCube()
else:
self.cube = VPythonCube()
from typing import List, Tuple
from connect4cube.hardware.util import is_a_raspberry
if is_a_raspberry():
from connect4cube.hardware.cube_led import LedCube
else:
from connect4cube.hardware.cube_vpython import VPythonCube
CubeType = List[List[List[Tuple[int, int, int]]]]
CoordType = Tuple[int, int, int]
class Cube:
"""
Singleton class of an LED cube. Depending on the target the real LED cube or a vpython mockup is used.
"""
instance = None
class __Cube:
cube = None
def __init__(self):
if is_a_raspberry():
self.cube = LedCube()
else:
self.cube = VPythonCube()
def set_color(self, x: int, y: int, z: int, r: int, g: int,
b: int) -> None:
self.cube.set_color(x, y, z, r, g, b)