mch2022.badge.team Hatchery

game.py

raw

Content

import display
import main
import utils
import random
import custom_shapes
import time
import buttons
import easydraw

STATUS_BAR_HEIGHT = 40
PROGRESS_BAR_HEIGHT = 10
TEXT_BLOCK_HEIGHT = 55
CONTROL_TYPES = ["VERTICAL_SLIDER", "ROTARY_SWITCH", "BINARY_SWITCH"]

INTRO_STATE = {
    "totalTime": 5,
    "remainingTime": 5,
    "assignment": "Starting the game in 5 seconds",
}
INTRO_HEALTH_INFO = {
    "death_limit": 0.0,
    "health": 50.0
}

class GameState:
    def __init__(self, grid):
        self.state = INTRO_STATE
        self.health_info = INTRO_HEALTH_INFO
        self.grid = grid
        self.control_mapping = {}
        seen_switch = False
        seen_joystick = False
        self.intro = True
        self.first_command_received = False
        for i, control in enumerate(grid):
            control_type = control["type"]
            value = {"id": i, "name": control["name"], "type": control_type}
            if control_type == CONTROL_TYPES[2]:
                if seen_switch:
                    self.control_mapping[buttons.BTN_A] = value
                else:
                    seen_switch = True
                    self.control_mapping[buttons.BTN_B] = value
            elif control_type in CONTROL_TYPES[:2]:
                if seen_joystick:
                    self.control_mapping[buttons.BTN_LEFT] = value
                    self.control_mapping[buttons.BTN_RIGHT] = value
                else:
                    seen_joystick = True
                    self.control_mapping[buttons.BTN_UP] = value
                    self.control_mapping[buttons.BTN_DOWN] = value
        print("control mapping:", self.control_mapping)

def update_grid(self, grid):
        self.grid = grid
        self.draw_game_screen()

def update_assignment(self, assignment):
        if self.first_command_received:
            self.intro = False
        else:
            self.first_command_received = True
        self.state["assignment"] = assignment["text"]
        self.state["totalTime"] = assignment["time"]
        self.state["remainingTime"] = int(assignment["time"])
        self.trigger_counter()

def update_health_info(self, health_info):
        self.health_info = health_info
        self.draw_game_screen()

def handle_button_press(self, button):
        if not self.intro and self.control_mapping:
            command = self.control_mapping[button]
            index = command["id"]
            if button == buttons.BTN_A or button == buttons.BTN_B:
                self.toggle_button(index)
            else:
                self.change_control_value(index, button == buttons.BTN_DOWN or button == buttons.BTN_RIGHT)

self.draw_game_screen()
            return {"name": command["name"], "value": self.grid[index]["value"]}
        else:
            print("Ignoring button press, game not started yet")

def toggle_button(self, index):
        self.grid[index]["value"] = not self.grid[index]["value"]

def change_control_value(self, index, higher):
        control = self.grid[index]
        if higher:
            self.grid[index]["value"] = min(control["value"] + 1, control["max"])
        else:
            self.grid[index]["value"] = max(control["value"] - 1, control["min"])

def draw_game_screen(self):
        display.drawFill(utils.BG_DARK)

draw_status_bar(self.state["remainingTime"], self.state["assignment"])

draw_health_bar(self.health_info["death_limit"], self.health_info["health"])

def get_intro_name(control_type, seen_switch, seen_joystick):
            if control_type == CONTROL_TYPES[2]:
                return "Toggle with A" if seen_switch else "Toggle with B"
            elif control_type in CONTROL_TYPES[:2]:
                return "Use Joystick Right/Left" if seen_joystick else "Use Joystick Up/Down"
            else:
                raise Exception("Unknown control_type '%s' for get_intro_name(%s, %s, %s)" % (control_type, control_type, seen_switch, seen_joystick))

seen_switch = False
        seen_joystick = False
        for i, control in enumerate(self.grid):
            draw_control(control, i, get_intro_name(control["type"], seen_switch, seen_joystick) if self.intro else control["name"])
            if control["type"] == CONTROL_TYPES[2]:
                seen_switch = True
            if control["type"] in CONTROL_TYPES[:2]:
                seen_joystick = True

display.flush()

def trigger_counter(self):
        if self.first_command_received:
            self.state["remainingTime"] = max(self.state["remainingTime"] - 1, 0)
            self.draw_game_screen()

def text_centered(x, y, width, text, font, color):
    if font:
        text_width = display.getTextWidth(text, font)
    else:
        text_width = display.getTextWidth(text)
    pos_x = int((width - text_width) / 2)
    if font:
        display.drawText(x + pos_x, y, text, color, font)
    else:
        display.drawText(pos_x, y, text, color)

def draw_assignment(assignment, x, y, width, height):
    ASSIGNMENT_FONT = utils.ARCADE_FONT[12]
    HORIZONTAL_PADDING = 10
    LINE_SPACING = 4

split_assignment = assignment.upper()

assignment_lines = easydraw.lineSplit(
        split_assignment, width=width, font=ASSIGNMENT_FONT
    )

line_heights = sum(
        [display.getTextHeight(line, ASSIGNMENT_FONT) for line in assignment_lines]
    )

total_height = line_heights + (len(assignment_lines) - 1) * LINE_SPACING

for i, line in enumerate(assignment_lines):
        text_centered(
            x + HORIZONTAL_PADDING,
            y
            + (height - total_height) // 2
            + (i * (line_heights // len(assignment_lines) + LINE_SPACING)),
            width - 2 * HORIZONTAL_PADDING,
            line,
            ASSIGNMENT_FONT,
            utils.BG_LIGHT,
        )

# Save some bucks on font licensing
    # Draw horizontal lines through assignment text
    for i in range(0, height, 2):
        display.drawLine(x, i, x + width, i, utils.BG_DARK)

def draw_status_bar(remaining_time, assignment):
    TIME_REMAINING_WIDTH = WIFI_INDICATOR_WIDTH = 40
    ASSIGNMENT_WIDTH = (
        utils.DISPLAY_SIZE[0] - TIME_REMAINING_WIDTH - WIFI_INDICATOR_WIDTH
    )

# Background
    display.drawRect(
        0, 0, utils.DISPLAY_SIZE[0], STATUS_BAR_HEIGHT, True, utils.BG_DARK
    )

# Time Remaining
    timer_height = display.getTextHeight(str(remaining_time), utils.ARCADE_FONT[9])
    text_centered(0, STATUS_BAR_HEIGHT - ((STATUS_BAR_HEIGHT + timer_height) // 2), TIME_REMAINING_WIDTH, str(remaining_time), utils.ARCADE_FONT[9], utils.TEXT_MAIN)

# Assignment
    draw_assignment(
        assignment, TIME_REMAINING_WIDTH, 0, ASSIGNMENT_WIDTH, STATUS_BAR_HEIGHT
    )

custom_shapes.draw_wifi_indicator(
        utils.DISPLAY_SIZE[0] - WIFI_INDICATOR_WIDTH,
        5,
        utils.COLOR_SECONDARY,
        utils.BG_DARK,
    )

def draw_health_bar(death_limit, health):
    progress = health / 100.0
    display.drawRect(
        0,
        STATUS_BAR_HEIGHT,
        utils.DISPLAY_SIZE[0],
        PROGRESS_BAR_HEIGHT,
        True,
        utils.COLOR_SECONDARY,
    )

arrow_data = display.pngInfo(utils.PROGRESS_ARROW_RED)
    ARROW_SPACING = 3.0

death_limit_width = round((death_limit / 100.0) * utils.DISPLAY_SIZE[0])
    arrow_amount = 1 + int(death_limit_width / (arrow_data[0] + ARROW_SPACING))
    display.drawRect(
        0,
        STATUS_BAR_HEIGHT,
        death_limit_width,
        PROGRESS_BAR_HEIGHT,
        True,
        utils.PROGRESS_GREEN,
    )

for i in range(arrow_amount):
        current_x = int(i * (arrow_data[0] + ARROW_SPACING))
        if current_x >= 0:
            display.drawPng(
                current_x,
                STATUS_BAR_HEIGHT,
                utils.PROGRESS_ARROW_RED,
            )

health_bar_width = round(progress * utils.DISPLAY_SIZE[0])
    if health_bar_width > 0:
        display.drawRect(
            death_limit_width,
            STATUS_BAR_HEIGHT,
            health_bar_width - death_limit_width,
            PROGRESS_BAR_HEIGHT,
            True,
            utils.PROGRESS_GREEN,
        )

def draw_control_text(text, x, y, width, height, is_light):
    TEXT_VERTICAL_SPACING = 3
    FONT = utils.ARCADE_FONT[6]

lines = [t.upper() for t in text.split(" ")]
    line_heights = [display.getTextHeight(line, FONT) for line in lines]
    total_height = sum(line_heights, (len(lines) - 1) * TEXT_VERTICAL_SPACING)

if total_height > height:
        raise Exception(
            f"Cannot render text '{text}' using given height constraint {height}px, need {total_height}px"
        )

base_y = y + (height - total_height) // 2

for i, line in enumerate(lines):
        text_centered(
            x,
            base_y + sum(line_heights[0:i]) + i * TEXT_VERTICAL_SPACING,
            width,
            line,
            FONT,
            utils.BG_DARK if is_light else utils.BG_LIGHT,
        )

def draw_binary_control_indicator(text, enabled, x, y, width, is_light):
    INDICATOR_HEIGHT = 20
    BORDER_WIDTH = 2

# Center fill
    if enabled:
        display.drawRect(
            x + BORDER_WIDTH,
            y + BORDER_WIDTH,
            width - 2 * BORDER_WIDTH,
            INDICATOR_HEIGHT - 2 * BORDER_WIDTH,
            True,
            utils.BG_DARK if is_light else utils.BG_LIGHT,
        )

# Top bar
    display.drawRect(
        x + BORDER_WIDTH,
        y,
        width - 2 * BORDER_WIDTH,
        BORDER_WIDTH,
        True,
        utils.BG_DARK if is_light else utils.BG_LIGHT,
    )

# Bottom bar
    display.drawRect(
        x + BORDER_WIDTH,
        y + INDICATOR_HEIGHT - BORDER_WIDTH,
        width - 2 * BORDER_WIDTH,
        2,
        True,
        utils.BG_DARK if is_light else utils.BG_LIGHT,
    )

# Left bar
    display.drawRect(
        x,
        y + BORDER_WIDTH,
        BORDER_WIDTH,
        INDICATOR_HEIGHT - 2 * BORDER_WIDTH,
        True,
        utils.BG_DARK if is_light else utils.BG_LIGHT,
    )

# Right bar
    display.drawRect(
        x + width - BORDER_WIDTH,
        y + BORDER_WIDTH,
        BORDER_WIDTH,
        INDICATOR_HEIGHT - 2 * BORDER_WIDTH,
        True,
        utils.BG_DARK if is_light else utils.BG_LIGHT,
    )

text_centered(
        x,
        y + 7,
        width,
        text,
        utils.ARCADE_FONT[8],
        utils.BG_LIGHT if is_light == enabled else utils.BG_DARK,
    )

def draw_binary_switch(value, x, y, width, height, is_light):
    center_x = x + width // 2

sprite_file = (
        (utils.JOYSTICK_DARK_OFF if is_light else utils.JOYSTICK_LIGHT_OFF)
        if value == 0
        else (utils.JOYSTICK_DARK_ON if is_light else utils.JOYSTICK_LIGHT_ON)
    )

sprite_info = display.pngInfo(sprite_file)

display.drawPng(
        center_x - sprite_info[0] // 2, y + 25 + (11 if value == 0 else 0), sprite_file
    )

draw_binary_control_indicator(
        "ON", value == 1, center_x - sprite_info[0] // 2, y, sprite_info[0], is_light
    )

draw_binary_control_indicator(
        "OFF",
        value == 0,
        center_x - sprite_info[0] // 2,
        y + height - 25,
        sprite_info[0],
        is_light,
    )

def draw_vertical_slider(value, min_val, max_val, x, y, width, height, is_light):
    VERTICAL_PADDING = 5
    LEFT_PADDING = 7
    FONT_SIZE = utils.ARCADE_FONT[8]
    SLIDER_BAR_WIDTH = 3
    tick_amount = 1 + max_val - min_val

total_text_height = sum(
        [display.getTextHeight(str(i), FONT_SIZE) for i in range(min_val, max_val + 1)]
    )
    text_spacing = (height - 2 * VERTICAL_PADDING - total_text_height) // (
        tick_amount - 1
    )

# Draw slider legend
    for i in range(min_val, max_val + 1):
        display.drawText(
            x + LEFT_PADDING,
            y
            + VERTICAL_PADDING
            + (i - min_val) * ((total_text_height // tick_amount) + text_spacing),
            str(i),
            utils.BG_DARK if is_light else utils.BG_LIGHT,
            FONT_SIZE,
        )

total_text_width = LEFT_PADDING + display.getTextWidth(str(max_val), FONT_SIZE)
    slider_bar_x = (
        x + total_text_width + (width - total_text_width) // 2 - SLIDER_BAR_WIDTH // 2
    )

# Draw slider bar
    display.drawRect(
        slider_bar_x,
        y + VERTICAL_PADDING,
        SLIDER_BAR_WIDTH,
        height - 2 * VERTICAL_PADDING,
        True,
        utils.SLIDER_PURPLE,
    )

# Draw slider handle
    slider_handle_data = display.pngInfo(utils.SLIDER_HANDLE_DARK)
    display.drawPng(
        slider_bar_x + (SLIDER_BAR_WIDTH // 2) - (slider_handle_data[0] // 2),
        y
        + (value - min_val)
        * ((height - slider_handle_data[1] - VERTICAL_PADDING) // (tick_amount - 1)),
        utils.SLIDER_HANDLE_DARK if is_light else utils.SLIDER_HANDLE_LIGHT,
    )

def draw_rotary_switch(value, x, y, min_val, max_val, width, height, is_light):
    FONT_SIZE = utils.ARCADE_FONT[8]
    HORIZONTAL_PADDING = 5
    MAX_TICK_COUNT = 5
    TICK_COUNT = 1 + max_val - min_val
    if TICK_COUNT not in [3, 5]:
        raise Exception("Invalid rotary switch provided with value range: [%s, %s]" % (min_val, max_val))

total_text_width = sum(
        [display.getTextWidth(str(i), FONT_SIZE) for i in range(MAX_TICK_COUNT)]
    )
    text_spacing = (width - 2 * HORIZONTAL_PADDING - total_text_width) // (
        MAX_TICK_COUNT - 1
    )

for i in range(min_val, max_val + 1):
        index = i - min_val if TICK_COUNT == 5 else [0, 2, 4][i - min_val]

y_pos = y + 15
        if index == 0 or index == 4:
            y_pos += 2 * 12
        elif index == 1 or index == 3:
            y_pos += 12

display.drawText(
            x
            + HORIZONTAL_PADDING
            + index * ((total_text_width // MAX_TICK_COUNT) + text_spacing),
            y_pos,
            str(i),
            utils.BG_DARK if is_light else utils.BG_LIGHT,
            FONT_SIZE,
        )

control_sprite = utils.ROTARY_CONTROL(value if TICK_COUNT == 5 else [1, 3, 5][value - min_val], is_light)

# Draw control handle
    rotary_control_data = display.pngInfo(control_sprite)
    display.drawPng(
        x + (width // 2 - rotary_control_data[0] // 2),
        y + 45,
        control_sprite,
    )

def draw_control(control, i, control_name):
    is_light = i % 2 == 0

block_width = utils.DISPLAY_SIZE[0] // 4
    x0 = block_width * i
    y0 = STATUS_BAR_HEIGHT + PROGRESS_BAR_HEIGHT
    block_height = utils.DISPLAY_SIZE[1] - y0

display.drawRect(
        x0,
        y0,
        block_width,
        block_height,
        True,
        utils.BG_LIGHT if is_light else utils.BG_DARK,
    )

draw_control_text(
        control_name, x0, y0, block_width, TEXT_BLOCK_HEIGHT, is_light
    )

if control["type"] == CONTROL_TYPES[0]:
        draw_vertical_slider(
            control["value"],
            control["min"],
            control["max"],
            x0,
            y0 + TEXT_BLOCK_HEIGHT,
            block_width,
            block_height - TEXT_BLOCK_HEIGHT,
            is_light,
        )
    elif control["type"] == CONTROL_TYPES[1]:
        draw_rotary_switch(
            control["value"],
            x0,
            y0 + TEXT_BLOCK_HEIGHT,
            control["min"],
            control["max"],
            block_width,
            block_height - TEXT_BLOCK_HEIGHT,
            is_light,
        )
    elif control["type"] == CONTROL_TYPES[2]:
        draw_binary_switch(
            control["value"],
            x0,
            y0 + TEXT_BLOCK_HEIGHT,
            block_width,
            block_height - TEXT_BLOCK_HEIGHT,
            is_light,
        )

# Below can be removed once all game elements are integrated - this is only for testing/demo purposes
# state = {
#     "totalTime": 8,
#     "remainingTime": 8,
#     "assignment": "Set power plant level to 5",
#     "controls": [
#         {
#             "type": CONTROL_TYPES[0],
#             "tickAmount": 6,
#             "value": 3,
#             "title": "Money Supply",
#         },
#         {"type": CONTROL_TYPES[1], "value": 2, "title": "Power Plant Level"},
#         {
#             "type": CONTROL_TYPES[2],
#             "value": 0,
#             "title": "Traffic Light Control",
#         },
#         {
#             "type": CONTROL_TYPES[2],
#             "value": 1,
#             "title": "Flood Control",
#         },
#     ],
# }
#
#
# def set_vertical_switch(up):
#     vertical_switch = state["controls"][0]
#
#     if not (
#         ((not up) and vertical_switch["value"] == vertical_switch["tickAmount"] - 1)
#         or (up and vertical_switch["value"] == 0)
#     ):
#         vertical_switch["value"] += -1 if up else 1
#
#     state["controls"][0] = vertical_switch
#
#     draw_game_screen(state)
#
#
# def set_rotary_switch(left):
#     rotary_switch = state["controls"][1]
#
#     if not (
#         ((not left) and rotary_switch["value"] == 4)
#         or (left and rotary_switch["value"] == 0)
#     ):
#         rotary_switch["value"] += -1 if left else 1
#
#     state["controls"][1] = rotary_switch
#
#     draw_game_screen(state)
#
#
# def toggle_binary_switch(left):
#     binary_switch = state["controls"][2 if left else 3]
#
#     binary_switch["value"] = int(not binary_switch["value"])
#
#     state["controls"][2 if left else 3] = binary_switch
#
#     draw_game_screen(state)
#
#
#
# def draw_demo_game():
#     buttons.attach(
#         buttons.BTN_UP,
#         lambda pressed: set_vertical_switch(True) if pressed else 0,
#     )
#     buttons.attach(
#         buttons.BTN_DOWN,
#         lambda pressed: set_vertical_switch(False) if pressed else 0,
#     )
#     buttons.attach(
#         buttons.BTN_LEFT, lambda pressed: set_rotary_switch(True) if pressed else 0
#     )
#     buttons.attach(
#         buttons.BTN_RIGHT, lambda pressed: set_rotary_switch(False) if pressed else 0
#     )
#     buttons.attach(
#         buttons.BTN_A,
#         lambda pressed: toggle_binary_switch(False) if pressed else 0,
#     )
#     buttons.attach(
#         buttons.BTN_B,
#         lambda pressed: toggle_binary_switch(True) if pressed else 0,
#     )
#
#     buttons.attach(buttons.BTN_HOME, lambda pressed: main.main_menu() if pressed else 0)
#
#     draw_game_screen(state)