added next major revision with cleanups and documentation

gametest_rev2.py

@@ -0,0 +1,769 @@
+#!/usr/bin/env python
+#coding=utf-8
+
+############################################
+########### GENERAL INFORMATION ############
+############################################
+
+"""
+This is the software for the project heisser_draht from the bfi itlabs st.stefan
+
+The idea of the game is to follow a wire with a ring, without touching it.
+The ones with the fastest times to reach the end (and with the least errors)
+are written onto the highscore table. Said table is temporary, and not saved on exit!
+
+The main game loop is running in 4 states:
+
+    * The game is not running and not ending (State 0)
+        This state is the default "starting" page of the game.
+        The screen shows the highscore table, and the game waits for a start signal.
+
+    * The game is running and not ending (State 1)
+        This is the game running. A timer is displayed on screen.
+        Errors are shown on screen aswell.
+        The game is waiting for error signals and stop signals
+
+    * The game is not running and ending (State 2)
+        Once the stop signal has been reached in the running game, this state is reached.
+        The game checks for highscores and asks for a name, should a highscore have been made.
+        This state automatically ends after a few seconds and returns the game to State 0.
+
+    * The game is neither running nor ending (State 3)
+        This state is currently invalid and does nothing. it should never be reached.
+        there's no functionality assigned to this, and this state is never run, but included
+        for completeness sake.
+
+The game also features a (not entirely interactive) LED lighting control. The LEDs are supposed
+to be driven by a small MOSFET driver circuit. DO NOT ATTACH LEDS DIRECTLY!
+The correct type of LEDs are the ones that have a common 12V rail per segment, and are switched
+by clamping the ground. Those ground clamps are driven by the Raspberry via a PWM signal.
+
+Pin explanation:
+
+pin_blue, pin_green, pin_red
+
+    Type: PWM Output
+    Use: These pins are for controlling the lighting. They are to be connected to a  MOSFET driver stage
+    that clamps the ground.
+
+pin_start
+
+    Type: Input, Pull Up
+    Use: Start pin. If this is active, the game starts.
+
+pin_stop
+
+    Type: Input, Pull Up
+    Use: Stop pin. If this is active, the game ends
+
+pin_error
+
+    Type: Input, Pull Up
+    Use: This is to be attached to the game wire. If the wire is touched,
+    the pin is pulled up and an error is registered.
+
+pin_shutdown
+
+    Type: Input, Pull Up
+    Use: Triggering this input causes a system shutdown.
+
+GPIO Pinout for assembly:
+
+              3V3  (1) (2)  5V
+                -  (3) (4)  5V
+                -  (5) (6)  GND
+                -  (7) (8)  -
+              GND  (9) (10) -
+                - (11) (12) -
+                - (13) (14) GND
+                - (15) (16) pin_blue
+              3V3 (17) (18) pin_green
+                - (19) (20) GND
+                - (21) (22) pin_red
+                - (23) (24) -
+              GND (25) (26) -
+                - (27) (28) -
+                - (29) (30) GND
+                - (31) (32) pin_start
+        pin_error (33) (34) GND
+                - (35) (36) pin_shutdown
+         pin_stop (37) (38) -
+              GND (39) (40) -
+
+Default state of pins:
+
+32: pull up
+33: pull up
+36: pull up
+37: pull up
+
+Make sure leds are on pull-up default pins
+so when their state is undefined, the led
+strips are switched off!
+
+22: pull up
+18: pull up
+16: pull up
+
+Credits:
+Based on a script made by TODO: source, although it has been heavily altered
+Changes made by: Clima Philip, Krajnc Moris, Glantschnig Raphael
+
+Hosted on:
+https://git.wolfsberg.local/philip.clima/heisser_draht
+
+"""
+
+
+############################################
+############# START OF IMPORTS #############
+############################################
+import signal
+import sys
+import os
+import pygame
+from PIL import Image
+from pygame.locals import *
+import RPi.GPIO as GPIO
+
+############################################
+############## END OF IMPORTS ##############
+############################################
+
+############################################
+########### START OF DEFINITIONS ###########
+############################################
+
+# base pygame settings
+pygame_fps = 30 #frames per second setting
+pygame_clock = pygame.time.Clock()
+
+# GPIO for Buttons
+pin_start = 32
+pin_stop = 37
+pin_error = 33
+pin_shutdown = 36
+
+# GPIO for LED
+pin_red = 22
+pin_green = 18
+pin_blue = 16
+
+# other constants
+# every time the wire is touched, some time is added as penalty.
+# number is in ms
+time_per_error = 5000
+
+# screen settings
+screen_size_x = 1920
+screen_size_y = 1080
+
+# name length for highscores
+max_name_length = 10
+
+# preset highscores
+hs1_name = "Fritz"
+hs2_name = "Bernd"
+hs3_name = "Max"
+hs1_time = 100
+hs2_time = 200
+hs3_time = 300
+
+############################################
+############ END OF DEFINITIONS ############
+############################################
+
+############################################
+####### START OF PRE-INITIALISATION ########
+############################################
+
+# here goes stuff that is requires by functions
+# so they can be properly defined
+
+# initialise the game
+pygame.init()
+
+# fonts
+pygame_font_1 = pygame.font.Font('freesansbold.ttf', 90)
+pygame_font_2 = pygame.font.Font('freesansbold.ttf', 65)
+pygame_font_3 = pygame.font.Font('freesansbold.ttf', 45)
+
+# colors
+pygame_color_green = pygame.Color(42, 217, 13)
+pygame_color_black = pygame.Color(0, 0, 0)
+pygame_color_white = pygame.Color(255, 255, 255)
+pygame_color_yellow = pygame.Color(255, 215, 0)
+pygame_color_grey = pygame.Color(196, 202, 206)
+pygame_color_brown = pygame.Color(177, 86, 15)
+
+# font colors
+pygame_font_main_color = pygame_color_black
+
+# initialise gpio
+GPIO.setmode(GPIO.BOARD)
+GPIO.setup(pin_start, GPIO.IN)
+GPIO.setup(pin_error, GPIO.IN)
+GPIO.setup(pin_shutdown, GPIO.IN)
+
+# predefinition of led variables, for use in functions
+led_red = 0
+led_green = 0
+led_blue = 0
+
+############################################
+######## END OF PRE-INITIALISATION #########
+############################################
+
+############################################
+###### START OF FUNCTION DEFINITIONS #######
+############################################
+
+def get_image_width(filepath):
+    """get the width of an image"""
+    return (Image.open(filepath).size)[0]
+
+def get_image_height(filepath):
+    """get the height of an image"""
+    return (Image.open(filepath).size)[1]
+
+def signal_handler(sig, frame):
+    """
+    signal handler, later called to interpret
+    ctrl+c as "quit" rather than "abort"
+    """
+    print('Programm exiting')
+    exit_application()
+
+def led_init():
+    """
+    initialises the LED pins
+    mind that the pins for the LEDs are pullup by default,
+    which is on purpose, since this causes the LED strip to
+    be turned off when the program isnt running or their state
+    is undefined
+
+    set the led pins to be outputs
+    careful: these pins dont drive the
+    led strip themselves, but rather 3
+    n-channel mosfets, type IRLZ34N
+    """
+    global led_red, led_green, led_blue
+    GPIO.setup(pin_red, GPIO.OUT)
+    GPIO.setup(pin_green, GPIO.OUT)
+    GPIO.setup(pin_blue, GPIO.OUT)
+
+    # set the pwm frequency to 100
+    # if you experience strobing, try changing
+    # the number
+    led_red = GPIO.PWM(pin_red, 100)
+    led_blue = GPIO.PWM(pin_blue, 100)
+    led_green = GPIO.PWM(pin_green, 100)
+
+    # start pwm generation with a duty cycle of 0
+    led_green.start(0)
+    led_blue.start(0)
+    led_red.start(0)
+
+def change_red(amount):
+    """
+    takes an input from 0 to 255 and converts it to Duty Cycle
+    valid duty cycle values are between 0 and 100
+    stores the new value in led_brightness_COLOUR
+    this value is later read by the led_handler to set the
+    corresponding duty cycles to allow fast interactive updating
+    to be used by change_led_colour
+    """
+
+    global led_red
+    factor = 100/255
+    led_green.ChangeDutyCycle(amount*factor)
+
+def change_green(amount):
+    """
+    takes an input from 0 to 255 and converts it to Duty Cycle
+    valid duty cycle values are between 0 and 100
+    stores the new value in led_brightness_COLOUR
+    this value is later read by the led_handler to set the
+    corresponding duty cycles to allow fast interactive updating
+    to be used by change_led_colour
+    """
+
+    global led_green
+    factor = 100/255
+    led_green.ChangeDutyCycle(amount*factor)
+
+def change_blue(amount):
+    """
+    takes an input from 0 to 255 and converts it to Duty Cycle
+    valid duty cycle values are between 0 and 100
+    stores the new value in led_brightness_COLOUR
+    this value is later read by the led_handler to set the
+    corresponding duty cycles to allow fast interactive updating
+    to be used by change_led_colour
+    """
+
+    global led_blue
+    factor = 100/255
+    led_blue.ChangeDutyCycle(amount*factor)
+
+def change_led_colour(red_amount, green_amount, blue_amount):
+    """
+    takes an rgb value as input
+    and converts it to duty cycles
+    and then applies that.
+    """
+    global led_red, led_green, led_blue
+    # sets an RGB value for the led strip.
+    if red_amount < 0 or red_amount > 255:
+        # valid rgb values should be between 0 and 255
+        print('change_led_colour: invalid red value received: ' + str(red_amount))
+        return False
+    if green_amount < 0 or green_amount > 255:
+        # valid rgb values should be between 0 and 255
+        print('change_led_colour: invalid green value received: '+ str(green_amount))
+        return False
+    if blue_amount < 0 or blue_amount > 255:
+        # valid rgb values should be between 0 and 255
+        print('change_led_colour: invalid blue value received: ' + str(blue_amount))
+        return False
+
+    change_red(red_amount)
+    change_blue(blue_amount)
+    change_green(green_amount)
+    return True
+
+def toggle_fullscreen():
+    """switches the game to fullscreen"""
+    screen = pygame.display.get_surface()
+    tmp = screen.convert()
+    caption = pygame.display.get_caption()
+    cursor = pygame.mouse.get_cursor() # Duoas 16-04-2007
+
+    screen_width, screen_height = screen.get_width(), screen.get_height()
+    flags = screen.get_flags()
+    bits = screen.get_bitsize()
+
+    pygame.display.quit()
+    pygame.display.init()
+
+    screen = pygame.display.set_mode((screen_width, screen_height), flags^FULLSCREEN, bits)
+    screen.blit(tmp, (0, 0))
+    pygame.display.set_caption(*caption)
+
+    pygame.key.set_mods(0) # HACK: work-a-round for a SDL bug??
+
+    pygame.mouse.set_cursor(*cursor) # Duoas 16-04-2007
+    return screen
+
+def clear_screen():
+    """fills the screen with a colour"""
+    screen.fill(pygame_color_white)
+
+def handle_events():
+    """looks for things to do every tick"""
+    for event in pygame.event.get():
+        if event.type == KEYDOWN and event.key == K_ESCAPE:
+            exit_application()
+
+    # shutdown raspberry if shutdown pin is detected
+    if GPIO.INPUT(pin_shutdown):
+        shutdown_raspberry()
+
+def exit_application():
+    """ exit the application with proper cleanup"""
+    pygame.quit()
+    GPIO.cleanup()
+    sys.exit()
+
+def shutdown_raspberry():
+    """shutdown the system with proper cleanup"""
+    pygame.quit()
+    GPIO.cleanup()
+    os.system("sudo shutdown -h now")
+
+def enter_name():
+    """asks for a name on screen and then returns that name"""
+    clear_screen()
+    print('text entry started')
+    name = ''
+    while True:
+        clear_screen()
+
+        # add all needed surfaces
+        highscore_surface = pygame_font_1.render('High Score!', True, pygame_font_main_color)
+        highscore_rectangle = highscore_surface.get_rect()
+        highscore_rectangle.topleft = (700, 250)
+
+        screen.blit(highscore_surface, highscore_rectangle)
+
+        textbox_text_surface = pygame_font_2.render('Enter Name:', True, pygame_font_main_color)
+        textbox_text_rectangle = textbox_text_surface.get_rect()
+        textbox_text_rectangle.topleft = (700, 400)
+
+        textbox_surface = pygame_font_2.render(str(name), True, pygame_font_main_color)
+        textbox_rectangle = textbox_surface.get_rect()
+        textbox_rectangle.topleft = (800, 480)
+
+        # draw everything
+        screen.blit(textbox_text_surface, textbox_text_rectangle)
+        screen.blit(textbox_surface, textbox_rectangle)
+
+        # add the border and logos
+        draw_border()
+        draw_logos()
+
+        # display everything
+        pygame.display.flip()
+
+        # handle key events
+        for event in pygame.event.get():
+            # read new keys for as long as the max length for the name hasnt been reached
+            if len(name) < max_name_length:
+                if event.type == KEYDOWN:
+                    # if someone presses the erase key, erase 1 letter
+                    if event.key == pygame.K_BACKSPACE:
+                        name = name[:-1]
+                    # if enter is pressed with at least 1 letter as the name,
+                    # return the name
+                    elif event.key == pygame.K_RETURN and len(name) > 0:
+                        clear_screen()
+                        return name
+                    # if enter is pressed without any letters in the name,
+                    # dont return a name. do nothing instead.
+                    elif event.key == pygame.K_RETURN:
+                        # do nothing
+                        pass
+                    # if escape is pressed, exit.
+                    # this prevents lockups since the main game loop is not running inside this function.
+                    elif event.key == pygame.K_ESCAPE:
+                        exit_application()
+                    # for any other key, add the letter to the name
+                    # Caution: this includes all sorts of weird letters, control sequences, and other unprintable chars.
+                    else:
+                        name += event.unicode
+            # none of the following may be needed
+            # TODO: Testing
+            # if someone presses the erase key, erase 1 letter
+            #elif event.key == pygame.K_BACKSPACE:
+            #    name = name[:-1]
+            #
+            #elif event.type == KEYDOWN and event.key == pygame.K_RETURN:
+            #    clear_screen()
+            #    return name
+
+    # this part of the code should be unreachable, and only here in case the event handling goes wrong horribly.
+    clear_screen()
+    name = 'Error'
+    return name
+
+def check_highscores(time):
+    """
+    check if a new highscore has been made
+    this is coded in a horrible way and adding more than 3 high scores with this sorta system would be too much work.
+    """
+    global hs1_time, hs2_time, hs3_time, hs1_name, hs2_name, hs3_name
+    if time <= hs1_time:
+        print('new high score:'+str(time))
+        # make the second the third
+        hs3_time = hs2_time
+        hs3_name = hs2_name
+
+        # make the first the second
+        hs2_time = hs1_time
+        hs2_name = hs1_name
+
+        # new high score
+        hs1_time = time
+        hs1_name = enter_name()
+        return True
+    elif time <= hs2_time:
+        print('new second:'+str(time))
+
+        # make the second the third
+        hs3_time = hs2_time
+        hs3_name = hs2_name
+
+        # new second time
+        hs2_time = time
+        hs2_name = enter_name()
+        return True
+    elif time <= hs3_time:
+        print('new third:'+str(time))
+        hs3_time = time
+        hs3_name = enter_name()
+        return True
+    else:
+        return False
+
+def draw_border():
+    """draw logos"""
+    screen.blit(img_itlablogo_image, (screen_size_x-img_itlablogo_imagex-20, screen_size_y-img_itlablogo_imagey-20))
+    # TODO: Metallic Logo
+
+def draw_logos():
+    """draw rectangle border around everything"""
+    pygame.draw.rect(screen, pygame_color_black, (500, 200, (screen_size_x-500*2), (screen_size_y-200*2)), 5)
+
+def show_debug():
+    """show debug information"""
+    print('#############')
+    print('Game running: ' + str(game_running))
+    print('Game ending: ' + str(game_ending))
+    print('Pin status: ')
+    print('Start pin: ' + str(GPIO.INPUT(pin_start)))
+    print('Error pin: ' + str(GPIO.INPUT(pin_error)))
+    print('Shutdown pin: ' + str(GPIO.input(pin_shutdown)))
+    print('#############')
+
+############################################
+####### END OF FUNCTION DEFINITIONS ########
+############################################
+
+############################################
+######### START OF INITIALISATION ##########
+############################################
+
+# signal handing setup for controlled exit via ctrl+c
+signal.signal(signal.SIGINT, signal_handler)
+
+# hide mouse from screen
+pygame.mouse.set_visible(False)
+
+# start fullscreen mode with defined screen geometrics
+screen = pygame.display.set_mode((screen_size_x, screen_size_y), pygame.FULLSCREEN)
+#pygame.display.set_caption('Heisser Draht') # not required for fullscreen application
+
+# currently unused because its not needed
+#screen = toggle_fullscreen()
+
+# define image variables
+img_itlablogo = 'img/itlablogo.png'
+img_itlablogo_image = pygame.image.load(img_itlablogo)
+img_itlablogo_imagex = get_image_width(img_itlablogo)
+img_itlablogo_imagey = get_image_height(img_itlablogo)
+
+# TODO: Metallic Logo einfügen
+#img_metalliclogo = 'img/metalliclogo.png'
+#img_metalliclogo_image  = pygame.image.load(img_metalliclogo)
+#img_metalliclogo_imagex = get_image_width(img_metalliclogo)
+#img_metalliclogo_imagey = get_image_height(img_metalliclogo)
+
+# initialise led strip
+led_init()
+
+# set the start state
+game_running = False
+game_ending = False
+
+# enable the one-shot for changing the LEDs
+game_just_started = True
+
+# set start inhibitor to false by default
+pin_start_inhibit = False
+
+############################################
+########## END OF INITIALISATION ###########
+############################################
+
+############################################
+######### START OF MAIN GAME LOOP ##########
+############################################
+
+while True:
+    # default actions to be done every cycle
+    clear_screen()
+    handle_events()
+    show_debug()
+    print(str(pygame.time.get_ticks()))
+
+    # State 0
+
+    if not game_running and not game_ending:
+        # one shot for changing the led colour
+        if game_just_started:
+            print('game just started, changed colour of leds to green')
+            change_led_colour(0, 200, 0)
+            game_just_started = False
+
+        # reset all the surfaces to be empty
+        time_surface = 0
+        errors_surface = 0
+        time_rectangle = 0
+        errors_rectangle = 0
+
+        # fill all surfaces again to contain the proper text
+        header_surface = pygame_font_1.render('Dr' + u'ü' + 'cken Sie Start!', True, pygame_font_main_color)
+        header_rectangle = header_surface.get_rect()
+        header_rectangle.topleft = (560, 250)
+
+        highscore_header_surface = pygame_font_2.render('Highscores:', True, pygame_font_main_color)
+        highscore_header_rectangle = highscore_header_surface.get_rect()
+        highscore_header_rectangle = (770, 410)
+
+        score1_surface = pygame_font_3.render(hs1_name + ": " + str(hs1_time/1000) + 's', True, pygame_color_yellow)
+        score1_rectangle = score1_surface.get_rect()
+        score1_rectangle.topleft = (820, 540)
+
+        score2_surface = pygame_font_3.render(hs2_name + ": " + str(hs2_time/1000) + 's', True, pygame_color_grey)
+        score2_rectangle = score2_surface.get_rect()
+        score2_rectangle.topleft = (820, 630)
+
+        score3_surface = pygame_font_3.render(hs3_name + ": " + str(hs3_time/1000) + 's', True, pygame_color_brown)
+        score3_rectangle = score3_surface.get_rect()
+        score3_rectangle.topleft = (820, 720)
+
+        # draw headline, highscore headline, the 3 scores, as well as the logos to the screen
+        screen.blit(header_surface, header_rectangle)
+        screen.blit(highscore_header_surface, highscore_header_rectangle)
+        screen.blit(score1_surface, score1_rectangle)
+        screen.blit(score2_surface, score2_rectangle)
+        screen.blit(score3_surface, score3_rectangle)
+
+        # event handling for if the start button is pushed
+        #wait for the user to press start button
+        if GPIO.input(pin_start) and not pin_start_inhibit:
+            # change game state to running and not ending
+            game_running = True
+            game_ending = False
+
+            # set an inhibitor bit to stop the contact from possibly vibrating and
+            # causing a stop of the game immediately after start
+            pin_start_inhibit = True
+            timer_pin_start_inhibit_starttime = pygame.time.get_ticks()
+
+            # reset errors
+            errors = 0
+            error_added = False
+            error_cooldown_start = 0
+
+            # change the headline
+            header_surface = pygame_font_1.render('Spiel l' + u'ä' + 'uft!', True, pygame_font_main_color)
+
+            # start the timer
+            timer_game_running_start = pygame.time.get_ticks()
+
+            # change led colour to blue
+            change_led_colour(0, 0, 200)
+
+    # State 1
+
+    if game_running and not game_ending:
+
+        # reset the highscore check
+        highscore_checked = False
+
+        # if the start pin is inhibited and at least 3 seconds have passed,
+        # one shot: stop blocking the pin
+        if pin_start_inhibit:
+            if (pygame.time.get_ticks()-timer_pin_start_inhibit_starttime) > 3000:
+                pin_start_inhibit = False
+
+        # add errors if error pin is detected, only once per 500 ms
+        if GPIO.input(pin_error):
+            if not error_added:
+                errors += 1
+                error_added = True
+                error_cooldown_start = pygame.time.get_ticks()
+                change_led_colour(200, 0, 0)
+
+        # if an error happened, error_added is set to true - which prohibits adding another error.
+        # after 500 ms error_added is set to false again.
+        # this provides a cooldown
+        if error_added and (pygame.time.get_ticks()-error_cooldown_start) > 500:
+            error_added = False
+            change_led_colour(0, 0, 200)
+
+        # calculate the current time
+        timer_game_running = (pygame.time.get_ticks() - timer_game_running_start) + (errors * time_per_error)
+
+        # fill the surface with the current time and errors
+        time_surface = pygame_font_2.render('Zeit: ' + str(timer_game_running/1000) + 's', True, pygame_font_main_color)
+        time_rectangle = time_surface.get_rect()
+        time_rectangle.topleft = (640, 480)
+
+        errors_surface = pygame_font_2.render('Fehler: ' + str(errors), True, pygame_font_main_color)
+        errors_rectangle = errors_surface.get_rect()
+        errors_rectangle.topleft = (640, 560)
+
+        clear_screen()
+
+        # draw errors, time and headline to the screen
+        screen.blit(errors_surface, errors_rectangle) #errors
+        screen.blit(time_surface, time_rectangle) #time
+        screen.blit(header_surface, header_rectangle) #header
+
+        # display everything
+        #pygame.display.flip()
+
+        # if another push of start is detected (i.e. the game is ending!)
+        if GPIO.input(pin_stop):
+            # change led colour to red
+            change_led_colour(200, 0, 200)
+
+            # reset the one shot latch for the end of game timer
+            timer_game_ending_started = False
+
+            # change the state to not running and ending
+            game_running = False
+            game_ending = True
+
+    # State 2
+
+    if not game_running and game_ending:
+        # check highscores only once when game ended
+        if not highscore_checked:
+            check_highscores(timer_game_running)
+            highscore_checked = True
+
+        # timer for ending the game after 5 seconds
+        if not timer_game_ending_started:
+            timer_game_ending_timout = pygame.time.get_ticks()
+            timer_game_ending_started = True
+
+        clear_screen()
+
+        # change the headline to game over
+        header_surface = pygame_font_1.render('Game over!', True, pygame_font_main_color)
+
+        # draw errors, time, and new headline to the screen
+        screen.blit(errors_surface, errors_rectangle) #errors
+        screen.blit(time_surface, time_rectangle) #time
+        screen.blit(header_surface, header_rectangle) #header
+
+        # if 5 seconds have passed since the game state changed to ending (see: timer_game_ending_timeout)
+        if ((pygame.time.get_ticks()-timer_game_ending_timout)/1000) > 5:
+            # reset game_just_started flag to enable the one shot led change in the first state
+            game_just_started = True
+
+            # change state
+            game_running = False
+            game_ending = False
+
+            # reset highscore one shot
+            highscore_checked = False
+
+            # reset timer started one shot
+            timer_game_ending_started = False
+
+            # unblock the start pin unconditionally
+            pin_start_inhibit = False
+
+    # State 3
+
+    if game_running and game_ending:
+        # something went horribly wrong...
+        # this state is never supposed to be reached
+        pass
+
+    # overlaying structure - this is to be drawn no matter what's below
+    draw_border()
+    draw_logos()
+
+    # flip everything, update display, do a tick
+    pygame.display.flip()
+    pygame.display.update()
+    pygame_clock.tick(pygame_fps)
+
+############################################
+########## END OF MAIN GAME LOOP ###########
+############################################