from getkey import getkey, keys

import random

from datetime import datetime, timedelta

import time

import threading

from inputmodule.inputmodule import (

GameControlVal,

send_command,

CommandVals,

Game,

)

from inputmodule.inputmodule.ledmatrix import (

show_string,

WIDTH,

HEIGHT,

render_matrix,

)

# Constants

ARG_UP = 0

ARG_DOWN = 1

ARG_LEFT = 2

ARG_RIGHT = 3

ARG_QUIT = 4

ARG_2LEFT = 5

ARG_2RIGHT = 6

# Variables

direction = None

body = []

def opposite_direction(direction):

if direction == keys.RIGHT:

return keys.LEFT

elif direction == keys.LEFT:

return keys.RIGHT

elif direction == keys.UP:

return keys.DOWN

elif direction == keys.DOWN:

return keys.UP

return direction

def snake_keyscan():

global direction

global body

while True:

current_dir = direction

key = getkey()

if key in [keys.RIGHT, keys.UP, keys.LEFT, keys.DOWN]:

# Don't allow accidental suicide if we have a body

if key == opposite_direction(current_dir) and body:

continue

direction = key

def snake_embedded_keyscan(dev):

while True:

key_arg = None

key = getkey()

if key == keys.UP:

key_arg = GameControlVal.Up

elif key == keys.DOWN:

key_arg = GameControlVal.Down

elif key == keys.LEFT:

key_arg = GameControlVal.Left

elif key == keys.RIGHT:

key_arg = GameControlVal.Right

elif key == "q":

# Quit

key_arg = GameControlVal.Quit

if key_arg is not None:

send_command(dev, CommandVals.GameControl, [key_arg])

def game_over(dev):

global body

while True:

show_string(dev, "GAME ")

time.sleep(0.75)

show_string(dev, "OVER!")

time.sleep(0.75)

score = len(body)

show_string(dev, f"{score:>3} P")

time.sleep(0.75)

def pong_embedded(dev):

# Start game

send_command(dev, CommandVals.StartGame, [Game.Pong])

while True:

key_arg = None

key = getkey()

if key == keys.LEFT:

key_arg = ARG_LEFT

elif key == keys.RIGHT:

key_arg = ARG_RIGHT

elif key == "a":

key_arg = ARG_2LEFT

elif key == "d":

key_arg = ARG_2RIGHT

elif key == "q":

# Quit

key_arg = ARG_QUIT

if key_arg is not None:

send_command(dev, CommandVals.GameControl, [key_arg])

def game_of_life_embedded(dev, arg):

# Start game

# TODO: Add a way to stop it

print("Game", int(arg))

send_command(dev, CommandVals.StartGame, [Game.GameOfLife, int(arg)])

def snake_embedded(dev):

# Start game

send_command(dev, CommandVals.StartGame, [Game.Snake])

snake_embedded_keyscan(dev)

def snake(dev):

global direction

global body

head = (0, 0)

direction = keys.DOWN

food = (0, 0)

while food == head:

food = (random.randint(0, WIDTH - 1), random.randint(0, HEIGHT - 1))

# Setting

WRAP = False

thread = threading.Thread(target=snake_keyscan, args=(), daemon=True)

thread.start()

prev = datetime.now()

while True:

now = datetime.now()

delta = (now - prev) / timedelta(milliseconds=1)

if delta > 200:

prev = now

else:

continue

# Update position

(x, y) = head

oldhead = head

if direction == keys.RIGHT:

head = (x + 1, y)

elif direction == keys.LEFT:

head = (x - 1, y)

elif direction == keys.UP:

head = (x, y - 1)

elif direction == keys.DOWN:

head = (x, y + 1)

# Detect edge condition

(x, y) = head

if head in body:

return game_over(dev)

elif x >= WIDTH or x < 0 or y >= HEIGHT or y < 0:

if WRAP:

if x >= WIDTH:

x = 0

elif x < 0:

x = WIDTH - 1

elif y >= HEIGHT:

y = 0

elif y < 0:

y = HEIGHT - 1

head = (x, y)

else:

return game_over(dev)

elif head == food:

body.insert(0, oldhead)

while food == head:

food = (random.randint(0, WIDTH - 1),

random.randint(0, HEIGHT - 1))

elif body:

body.pop()

body.insert(0, oldhead)

# Draw on screen

matrix = [[0 for _ in range(HEIGHT)] for _ in range(WIDTH)]

matrix[x][y] = 1

matrix[food[0]][food[1]] = 1

for bodypart in body:

(x, y) = bodypart

matrix[x][y] = 1

render_matrix(dev, matrix)

def wpm_demo(dev):

"""Capture keypresses and calculate the WPM of the last 10 seconds

TODO: I'm not sure my calculation is right."""

start = datetime.now()

keypresses = []

while True:

_ = getkey()

now = datetime.now()

keypresses = [x for x in keypresses if (now - x).total_seconds() < 10]

keypresses.append(now)

# Word is five letters

wpm = (len(keypresses) / 5) * 6

total_time = (now - start).total_seconds()

if total_time < 10:

wpm = wpm / (total_time / 10)

show_string(dev, " " + str(int(wpm)))