Datasets:

---

mlfoundations-dev

/

codereview_1000000_samples

Like 0

Follow

ML Foundations Development 141

ERROR: type should be string, got "https://github.com/speedrun-program/constant_time_snake_game\nMemory efficient snake game with O(1) algorithm for snake movement and bug placement.\nThree grids are used:\n\na grid representing the game grid\na grid partitioned into empty coords, future bug coords, current bug coords, and snake spaces\na grid which maps game grid coords to partitioned grid coords/indexes\n\nThe partitioned grid is needed to randomly select bug spaces in O(1) time.\nIt's also used to find existing bug locations in O(1) time.\ncontrols:\n\nwasd or arrow keys control the snake\nz and x change bug hints\np pauses the game\n\nmain.py:\nimport pygame\n\nfrom bitpacking import BitPackingArray\nfrom clickablebox import ClickableBox, TextEntryBox\n\nfrom random import randrange\n\nfrom collections.abc import Iterable\nfrom typing import Dict, Tuple, Union\n\n# memory efficient snake game with O(1) algorithm for snake movement and bug placement.\n# three grids are used:\n# - a grid representing the game grid\n# - a grid partitioned into empty coords, future bug coords, current bug coords, and snake spaces\n# - a grid which maps game grid coords to partitioned grid coords/indexes\n\n# the partitioned grid is needed to randomly select bug spaces in O(1) time.\n# it's also used to find existing bug locations in O(1) time.\n\n# controls:\n# - wasd or arrow keys control the snake\n# - z and x change bug hints\n# - p pauses the game\n\n\n# values of grid spaces\nEMPTY = 0\nSNAKE_UP = 1\nSNAKE_RIGHT = 2\nSNAKE_DOWN = 3\nSNAKE_LEFT = 4\nBUG = 5\n\nGRID_Y_OFFSET = 20\nGRID_X_OFFSET = 20\nGRID_GUI_WIDTH = 15\nGRID_GUI_HEIGHT = 15\nGRID_SPACE_SIZE = 35\nGUI_WIDTH = 1200\nGUI_HEIGHT = 700\n\n# a class which makes it easier to access data from the memory used by the Game class\n# 0 is a special value which means it's the same as the index being used to access it\n# this is done because bytearray objects initialize their values to 0 very quickly\nclass GridHelper:\n def __init__(\n self,\n grid: BitPackingArray,\n width: int,\n height: int,\n bits_per_index: int,\n start_bit: int,\n bits_to_read: int,\n is_game_grid: bool = False) -> None:\n self.grid = grid\n self.width = width\n self.height = height\n self.bits_per_index = bits_per_index\n self.start_bit = start_bit\n self.bits_to_read = bits_to_read\n self.is_game_grid = is_game_grid\n \n \n def __getitem__(self, pos: Union[Iterable[int, int], int]) -> int:\n if not isinstance(pos, int):\n pos = (pos[0] * self.width) + pos[1]\n \n value = (self.grid[pos] >> self.start_bit) & ((1 << self.bits_to_read) - 1)\n if not self.is_game_grid:\n if value == 0:\n return pos\n return value - 1\n return value\n \n \n def __setitem__(self, pos: Union[Iterable[int, int], int], new_value: int) -> None:\n if not isinstance(pos, int):\n pos = (pos[0] * self.width) + pos[1]\n if not isinstance(new_value, int):\n new_value = (new_value[0] * self.width) + new_value[1]\n \n new_value += not self.is_game_grid\n if not 0 <= new_value <= ((1 << self.bits_to_read) - 1):\n raise ValueError(f\"value must be in range(0, {((1 << self.bits_to_read) - 1)}), value was {new_value}\")\n \n number_of_end_bits = self.bits_per_index - self.start_bit - self.bits_to_read\n bits_at_end = self.grid[pos] & (((1 << number_of_end_bits) - 1) << (self.start_bit + self.bits_to_read))\n bits_at_start = self.grid[pos] & ((1 << self.start_bit) - 1)\n self.grid[pos] = bits_at_end + (new_value << self.start_bit) + bits_at_start\n\n\nclass Game:\n extra_memory = BitPackingArray(0, 0)\n \n def __init__(\n self,\n width: int,\n height: int,\n min_bugs: int,\n max_bugs: int,\n snake_speed: int) -> None:\n total_grid_spaces = width * height\n \n self.snake_spaces = 5\n self.available_bug_spaces = total_grid_spaces - self.snake_spaces\n self.min_bugs = min(self.available_bug_spaces, min_bugs)\n self.max_bugs = min(self.available_bug_spaces, max_bugs)\n self.bug_spaces = self.max_bugs\n self.future_bug_spaces = 0\n self.bug_spawn_cycle = 1\n self.bug_hint_idx = total_grid_spaces - self.snake_spaces - self.max_bugs # used to look up bug location from self.partitioned_grid\n \n self.tail = (height // 2, (width // 2) - 3)\n self.head = (height // 2, (width // 2) + 1)\n \n self.width = width\n self.height = height\n self.snake_speed = snake_speed\n \n # if the maximum number of bugs is always on the grid, the spawn cycle trick isn't needed\n if self.max_bugs != self.min_bugs:\n possible_bug_spawn_cycles = (total_grid_spaces - self.snake_spaces - self.max_bugs) // (self.max_bugs - self.min_bugs)\n possible_bug_spawn_cycles += (total_grid_spaces - self.snake_spaces - self.max_bugs) % (self.max_bugs - self.min_bugs) != 0 # for last cycle\n else:\n possible_bug_spawn_cycles = 1\n \n game_grid_bits = (possible_bug_spawn_cycles + 5).bit_length()\n other_grid_bits = total_grid_spaces.bit_length()\n bits_per_grid_space = (other_grid_bits * 2) + game_grid_bits\n \n Game.extra_memory.reshape(total_grid_spaces, bits_per_grid_space)\n \n self.game_grid = GridHelper(Game.extra_memory, width, height, bits_per_grid_space, 0, game_grid_bits, True)\n self.key_grid = GridHelper(Game.extra_memory, width, height, bits_per_grid_space, game_grid_bits, other_grid_bits)\n self.partitioned_grid = GridHelper(Game.extra_memory, width, height, bits_per_grid_space, game_grid_bits + other_grid_bits, other_grid_bits)\n \n # setting initial snake spaces\n for n in range(5):\n snake_segment = (height // 2, (width // 2 - 3) + n)\n end_position = (self.height - 1, self.width - 1 - n)\n self.game_grid[snake_segment] = SNAKE_RIGHT\n self.key_grid[snake_segment] = end_position\n self.key_grid[end_position] = snake_segment\n self.partitioned_grid[snake_segment] = end_position\n self.partitioned_grid[end_position] = snake_segment\n \n # setting initial bug spaces\n for n in range(1, self.max_bugs + 1):\n partitioned_grid_replace_idx = total_grid_spaces - self.snake_spaces - n\n partitioned_grid_random_idx = randrange(self.available_bug_spaces)\n key_grid_random_idx = self.swap(partitioned_grid_replace_idx, partitioned_grid_random_idx)[1]\n self.game_grid[key_grid_random_idx] = BUG\n self.available_bug_spaces -= 1\n \n \n def free_memory(self) -> None:\n Game.extra_memory.reshape(0, 0)\n \n \n def get_next_coord(self, coord: Iterable[int, int], direction: int) -> Tuple[int, int]:\n vertical_change, horizontal_change = ((-1, 0), (0, 1), (1, 0), (0, -1))[direction - SNAKE_UP]\n return (coord[0] + vertical_change, coord[1] + horizontal_change)\n \n \n def change_bug_hint(self, backwards: bool = False) -> None:\n direction = -1 if backwards else 1\n self.bug_hint_idx += direction\n if self.bug_hint_idx < self.available_bug_spaces + self.future_bug_spaces:\n self.bug_hint_idx = self.available_bug_spaces + self.future_bug_spaces + self.bug_spaces - 1\n elif self.bug_hint_idx >= self.available_bug_spaces + self.future_bug_spaces + self.bug_spaces:\n self.bug_hint_idx = self.available_bug_spaces + self.future_bug_spaces\n \n \n def swap(self, idx_1: Union[Iterable[int, int], int], idx_2: Union[Iterable[int, int], int]) -> Tuple[int, int]:\n swap_value_1 = self.partitioned_grid[idx_1]\n swap_value_2 = self.partitioned_grid[idx_2]\n \n self.partitioned_grid[idx_1] = swap_value_2\n self.partitioned_grid[idx_2] = swap_value_1\n \n self.key_grid[swap_value_2] = idx_1\n self.key_grid[swap_value_1] = idx_2\n \n return (swap_value_1, swap_value_2)\n \n \n # - look up where new_head and old_tail are positioned in partitioned grid using key grid\n # - partitioned grid new_head and old_tail positions swap places, so old_tail is in unoccupied section\n # and new_head is in snake space section\n # - key grid new_head and old_tail positions update so they say where they're positioned in partitioned grid\n def move_into_empty(self, next_head_coord: Union[Iterable[int, int], int], direction: int) -> None:\n partitioned_tail_idx = self.key_grid[self.tail]\n partitioned_head_idx = self.key_grid[next_head_coord]\n \n self.swap(partitioned_tail_idx, partitioned_head_idx)\n \n old_tail_coord = self.tail\n self.tail = self.get_next_coord(self.tail, self.game_grid[self.tail])\n self.game_grid[old_tail_coord] = EMPTY\n self.game_grid[self.head] = direction\n self.head = next_head_coord\n self.game_grid[next_head_coord] = direction\n \n \n # - look up where new_head/future_bug_space and old_tail are positioned in partitioned grid using key grid\n # - partitioned grid new_head and old_tail positions swap places, so old_tail is in future bug space section\n # and new_head/future_bug_space is in snake space section\n # - key grid new_head/future_bug_space and old_tail positions update so they say where they're positioned in partitioned grid\n # - randomly choose new future_bug_space\n # - if new future_bug_space ends up where the tail was, stop here\n # - partitioned grid new future_bug_space and old_tail positions swap places, so old_tail is in unoccupied section\n # and new future_bug_space is in future bug space section\n # - key grid new future_bug_space and old_tail positions update so they say where they're positioned in partitioned grid\n def move_into_future_bug(self, next_head_coord: Union[Iterable[int, int], int], direction: int) -> None:\n partitioned_tail_idx = self.key_grid[self.tail]\n partitioned_head_idx = self.key_grid[next_head_coord]\n \n self.swap(partitioned_tail_idx, partitioned_head_idx)\n \n random_partitioned_grid_idx = randrange(self.available_bug_spaces + 1)\n if random_partitioned_grid_idx == self.available_bug_spaces: # old tail coord was chosen as new future bug space\n old_tail_coord = self.tail\n self.tail = self.get_next_coord(self.tail, self.game_grid[self.tail])\n self.game_grid[old_tail_coord] = BUG + self.bug_spawn_cycle\n self.game_grid[self.head] = direction\n self.head = next_head_coord\n self.game_grid[next_head_coord] = direction\n return\n \n bug_location = self.swap(random_partitioned_grid_idx, partitioned_head_idx)[0]\n \n old_tail_coord = self.tail\n self.tail = self.get_next_coord(self.tail, self.game_grid[self.tail])\n self.game_grid[old_tail_coord] = EMPTY\n self.game_grid[self.head] = direction\n self.head = next_head_coord\n self.game_grid[next_head_coord] = direction\n \n self.game_grid[bug_location] = BUG + self.bug_spawn_cycle\n \n \n # - randomly choose new future_bug_space\n # - look up where new_head/bug_space is positioned in partitioned grid using key grid\n # - partitioned grid new_head/bug_space and the bug position touching the snake space section swap places, so\n # new_head/bug_space becomes part of the snake space section\n # - key grid new_head/bug_space and position touching snake space section update so they say where\n # they're positioned in partitioned grid\n # - partitioned grid future_bug_space and the unoccupied position touching the future bug space section swap places, so\n # future_bug_space becomes part of the future bug space section\n # - key grid future_bug_space and position touching future bug space section update so they say where\n # they're positioned in partitioned grid\n def move_into_bug(self, next_head_coord: Union[Iterable[int, int], int], direction: int) -> None:\n touching_snake_idx = self.available_bug_spaces + self.bug_spaces + self.future_bug_spaces - 1\n \n partitioned_head_idx = self.key_grid[next_head_coord]\n \n self.swap(partitioned_head_idx, touching_snake_idx)\n \n if self.available_bug_spaces > 0:\n random_partitioned_grid_idx = randrange(self.available_bug_spaces)\n touching_bug_idx = self.available_bug_spaces - 1\n \n bug_location = self.swap(random_partitioned_grid_idx, touching_bug_idx)[0]\n \n self.future_bug_spaces += 1\n \n self.game_grid[bug_location] = BUG + self.bug_spawn_cycle if self.max_bugs != self.min_bugs else BUG\n \n self.available_bug_spaces -= self.available_bug_spaces > 0\n self.game_grid[self.head] = direction\n self.head = next_head_coord\n self.game_grid[next_head_coord] = direction\n \n self.snake_spaces += 1\n self.bug_spaces -= 1\n if self.bug_spaces == self.min_bugs - 1: # future bug spaces become current bug spaces\n self.bug_spaces += self.future_bug_spaces\n self.future_bug_spaces = 0\n self.bug_spawn_cycle += 1\n \n if self.bug_hint_idx == partitioned_head_idx:\n self.bug_hint_idx = self.available_bug_spaces + self.future_bug_spaces\n elif self.bug_hint_idx == touching_snake_idx:\n self.bug_hint_idx = partitioned_head_idx\n \n \n def error_check(self) -> None:\n # testing function\n for i in range(self.available_bug_spaces):\n idx = self.partitioned_grid[i]\n if self.game_grid[idx] > 0:\n print(\n \"non-empty space referenced in empty area of self.partitioned_grid.\",\n f\"game grid value: {self.game_grid[idx]}\",\n f\"self.partitioned_grid index: {i}\",\n sep=\"\\n\"\n )\n raise ValueError\n for i in range(self.available_bug_spaces, self.available_bug_spaces + self.future_bug_spaces):\n idx = self.partitioned_grid[i]\n if self.game_grid[idx] != BUG + self.bug_spawn_cycle:\n print(\n \"non-future_bug_space referenced in bug area of self.partitioned_grid.\",\n f\"game grid value: {self.game_grid[idx]}\",\n f\"self.partitioned_grid index: {i}\",\n sep=\"\\n\"\n )\n raise ValueError\n for i in range(self.available_bug_spaces + self.future_bug_spaces, self.available_bug_spaces + self.future_bug_spaces + self.bug_spaces):\n idx = self.partitioned_grid[i]\n if not BUG <= self.game_grid[idx] < BUG + self.bug_spawn_cycle:\n print(\n \"non-bug space referenced in empty area of self.partitioned_grid.\",\n f\"game grid value: {self.game_grid[idx]}\",\n f\"self.partitioned_grid index: {i}\",\n sep=\"\\n\"\n )\n raise ValueError\n for i in range(self.available_bug_spaces + self.future_bug_spaces + self.bug_spaces, self.height * self.width):\n idx = self.partitioned_grid[i]\n if not SNAKE_UP <= self.game_grid[idx] <= SNAKE_LEFT:\n print(\n \"non-snake space referenced in empty area of self.partitioned_grid.\",\n f\"game grid value: {self.game_grid[idx]}\",\n f\"self.partitioned_grid index: {i}\",\n sep=\"\\n\"\n )\n raise ValueError\n \n s1 = set()\n s2 = set()\n for i in range(self.height * self.width):\n value = self.key_grid[i]\n if value in s1:\n print(f\"duplicate value {value} found at index {i} in self.key_grid\")\n raise ValueError\n s1.add(value)\n for i in range(self.height * self.width):\n value = self.partitioned_grid[i]\n if value in s2:\n print(f\"duplicate value {value} found at index {i} in self.partitioned_grid\")\n raise ValueError\n s2.add(value)\n\n\nclass GUI:\n def __init__(self) -> None:\n self.win = pygame.display.set_mode((GUI_WIDTH, GUI_HEIGHT))\n self.font = pygame.font.Font(pygame.font.get_default_font(), 24)\n self.textbox_text = (\"MINIMUM_BUGS\", \"MAXIMUM_BUGS\", \"SNAKE_SPEED\", \"GRID_WIDTH\", \"GRID_HEIGHT\")\n self.textboxes = (\n TextEntryBox(self.win, self.font, \"\", (20, 20), (10, 45), (1000, 30), (15, 50), 20),\n TextEntryBox(self.win, self.font, \"\", (20, 120), (10, 145), (1000, 30), (15, 150), 20),\n TextEntryBox(self.win, self.font, \"\", (20, 220), (10, 245), (1000, 30), (15, 250), 20),\n TextEntryBox(self.win, self.font, \"\", (20, 320), (10, 345), (1000, 30), (15, 350), 20),\n TextEntryBox(self.win, self.font, \"\", (20, 420), (10, 445), (1000, 30), (15, 450), 20)\n )\n self.buttons = (\n ClickableBox(self.win, self.font, \"START\", (GUI_WIDTH - 100, GUI_HEIGHT - 290), (GUI_WIDTH - 110, GUI_HEIGHT - 330), (100, 100)),\n ClickableBox(self.win, self.font, \"CONFIG\", (GUI_WIDTH - 108, GUI_HEIGHT - 180), (GUI_WIDTH - 110, GUI_HEIGHT - 220), (100, 100)),\n (quit_button := ClickableBox(self.win, self.font, \"QUIT\", (GUI_WIDTH - 90, GUI_HEIGHT - 70), (GUI_WIDTH - 110, GUI_HEIGHT - 110), (100, 100))),\n ClickableBox(self.win, self.font, \"<\", (572, GUI_HEIGHT - 40), (565, GUI_HEIGHT - 40), (30, 30)), # NOT CURRENTLY USED\n ClickableBox(self.win, self.font, \">\", (615, GUI_HEIGHT - 40), (605, GUI_HEIGHT - 40), (30, 30)) # NOT CURRENTLY USED\n )\n self.quit_button = quit_button # this specific button is checked in several areas in the code\n \n self.settings = read_cfg()\n if int(self.settings[\"MINIMUM_BUGS\"]) > int(self.settings[\"MAXIMUM_BUGS\"]):\n self.settings[\"MINIMUM_BUGS\"] = self.settings[\"MAXIMUM_BUGS\"]\n \n for button in self.buttons[:3]:\n button.draw()\n \n self.game_drawn = False\n self.config_drawn = False\n self.cfg_page_number = 0 # NOT CURRENTLY USED\n self.cfg_pages = 1 # NOT CURRENTLY USED\n \n \n def toggle_top_two_buttons(self) -> None:\n if self.buttons[0].box is None: # this means self.buttons[0].box isn't drawn\n self.buttons[0].draw()\n self.buttons[1].draw()\n self.buttons[2].text = \"QUIT\"\n self.buttons[2].text_location = (GUI_WIDTH - 90, GUI_HEIGHT - 70)\n self.buttons[2].draw()\n else:\n self.buttons[0].undraw()\n self.buttons[1].undraw()\n self.buttons[2].text = \"BACK\"\n self.buttons[2].text_location = (GUI_WIDTH - 95, GUI_HEIGHT - 70)\n self.buttons[2].draw()\n \n \n def toggle_cfg_screen(self) -> None:\n self.set_messages(\"\")\n self.toggle_top_two_buttons()\n self.cfg_page_number = 0\n if not self.config_drawn:\n # self.buttons[3].draw()\n # self.buttons[4].draw()\n for i in range(len(self.textboxes)):\n self.textboxes[i].text = self.textbox_text[i]\n self.textboxes[i].box_text = self.settings[self.textbox_text[i]]\n self.textboxes[i].draw(self.textboxes[i].box_text)\n self.config_drawn = True\n else:\n # self.buttons[3].undraw()\n # self.buttons[4].undraw()\n for t in self.textboxes:\n t.undraw()\n self.config_drawn = False\n \n \n def toggle_game_screen(self) -> None:\n self.toggle_top_two_buttons()\n if not self.game_drawn:\n self.game_drawn = True\n else:\n pygame.draw.rect(self.win, (0, 0, 0), (GRID_X_OFFSET, GRID_Y_OFFSET, GRID_SPACE_SIZE * GRID_GUI_WIDTH, GRID_SPACE_SIZE * GRID_GUI_HEIGHT)) # undrawing grid\n self.game_drawn = False\n \n \n def set_messages(self, *messages: Iterable[str]) -> None:\n # undrawing previous message\n pygame.draw.rect(self.win, (0, 0, 0), (50, GRID_Y_OFFSET + (GRID_SPACE_SIZE * GRID_GUI_HEIGHT), GUI_WIDTH - 160, GUI_HEIGHT - GRID_Y_OFFSET + (GRID_SPACE_SIZE * GRID_GUI_HEIGHT)))\n \n for n, message in enumerate(messages):\n text_surface = self.font.render(message, True, (50, 50, 50))\n self.win.blit(text_surface, (50, 570 + (50 * n)))\n \n \n def get_grid_color(\n self,\n grid: GridHelper,\n grid_width: int,\n grid_height: int,\n grid_y: int,\n grid_x: int,\n bug_spawn_cycle: int) -> tuple[int, int, int]:\n if (not 0 <= grid_y < grid_height) or (not 0 <= grid_x < grid_width):\n return (100, 100, 100)\n else:\n try:\n grid_value = grid[grid_y, grid_x]\n except TypeError:\n grid_value = grid[grid_y][grid_x] # this function should be able to work with normal lists too\n if grid_value == 0:\n return (200, 200, 200)\n elif SNAKE_UP <= grid_value <= SNAKE_LEFT:\n return (255, 243, 128)\n elif BUG <= grid_value < BUG + bug_spawn_cycle:\n return (65, 163, 23)\n elif grid_value == BUG + bug_spawn_cycle: # this can be used for testing\n return (200, 200, 200) # (255, 165, 0)\n else:\n return (106, 13, 173) # error color\n \n \n def draw_grid_not_centered_on_head(\n self,\n grid: GridHelper,\n grid_width: int,\n grid_height: int,\n bug_spawn_cycle: int) -> None:\n for grid_y in range(grid_height):\n for grid_x in range(grid_width):\n color = self.get_grid_color(grid, grid_width, grid_height, grid_y, grid_x, bug_spawn_cycle)\n pygame.draw.rect(self.win, color, (GRID_X_OFFSET + (grid_x * GRID_SPACE_SIZE), GRID_Y_OFFSET + (grid_y * GRID_SPACE_SIZE), GRID_SPACE_SIZE, GRID_SPACE_SIZE))\n \n \n def draw_grid(\n self,\n grid: GridHelper,\n grid_width: int,\n grid_height: int,\n snake_coord: Iterable[int, int],\n bug_spawn_cycle: int) -> None:\n if grid_width <= 15 and grid_height <= 15:\n self.draw_grid_not_centered_on_head(grid, grid_width, grid_height, bug_spawn_cycle)\n return\n \n for gui_y, grid_y in enumerate(range(snake_coord[0] - 7, snake_coord[0] + 8)):\n for gui_x, grid_x in enumerate(range(snake_coord[1] - 7, snake_coord[1] + 8)):\n color = self.get_grid_color(grid, grid_width, grid_height, grid_y, grid_x, bug_spawn_cycle)\n pygame.draw.rect(self.win, color, (GRID_X_OFFSET + (gui_x * GRID_SPACE_SIZE), GRID_Y_OFFSET + (gui_y * GRID_SPACE_SIZE), GRID_SPACE_SIZE, GRID_SPACE_SIZE))\n\n\ndef read_cfg() -> Dict[str, str]:\n try:\n with open(\"config.txt\") as f:\n settings = dict(map(str.split, f))\n \n # checking if the file is valid\n for k in (\"MINIMUM_BUGS\", \"MAXIMUM_BUGS\", \"SNAKE_SPEED\", \"GRID_WIDTH\", \"GRID_HEIGHT\"):\n if (v := settings.get(k)) is None or (int_v := int(v)) < 0 or (int_v == 0 and k != \"SNAKE_SPEED\"):\n raise ValueError\n \n if int(settings[\"GRID_WIDTH\"]) < 10:\n settings[\"GRID_WIDTH\"] = \"10\"\n if int(settings[\"GRID_HEIGHT\"]) < 10:\n settings[\"GRID_HEIGHT\"] = \"10\"\n if int(settings[\"MINIMUM_BUGS\"]) > int(settings[\"MAXIMUM_BUGS\"]):\n settings[\"MINIMUM_BUGS\"] = settings[\"MAXIMUM_BUGS\"]\n return settings\n except (FileNotFoundError, ValueError, KeyError):\n settings = {\n \"MINIMUM_BUGS\": \"1\",\n \"MAXIMUM_BUGS\": \"1\",\n \"SNAKE_SPEED\": \"30\",\n \"GRID_WIDTH\": \"10\",\n \"GRID_HEIGHT\": \"10\"\n }\n write_cfg(settings)\n return settings\n\n\ndef write_cfg(settings: Dict[str, str]) -> None:\n with open(\"config.txt\", \"w\") as f:\n f.write(\"\\n\".join(map(\" \".join, settings.items())))\n\n\ndef config(gui: GUI) -> bool:\n new_settings = gui.settings.copy() # used to check if settings were changed\n active_box = None\n \n while True:\n pygame.time.wait(16)\n pygame.display.update()\n \n events = pygame.event.get()\n for event in events:\n if event.type == pygame.QUIT:\n return False\n elif event.type == pygame.MOUSEBUTTONUP and event.button == 1:\n mouse_position = pygame.mouse.get_pos()\n if any((tb := textbox).clicked(mouse_position) for textbox in gui.textboxes):\n if active_box is not None:\n active_box.color = (150, 150, 150)\n active_box.redraw()\n active_box = tb\n active_box.color = (200, 200, 200)\n active_box.redraw()\n elif gui.quit_button.clicked(mouse_position):\n if active_box is not None:\n active_box.color = (150, 150, 150)\n active_box.redraw()\n if int(new_settings[\"GRID_WIDTH\"]) < 10:\n new_settings[\"GRID_WIDTH\"] = \"10\"\n if int(new_settings[\"GRID_HEIGHT\"]) < 10:\n new_settings[\"GRID_HEIGHT\"] = \"10\"\n if int(new_settings[\"MINIMUM_BUGS\"]) > int(new_settings[\"MAXIMUM_BUGS\"]):\n new_settings[\"MINIMUM_BUGS\"] = new_settings[\"MAXIMUM_BUGS\"]\n if new_settings != gui.settings: # don't write to file if settings weren't changed\n for k in gui.textbox_text:\n gui.settings[k] = new_settings[k]\n write_cfg(gui.settings)\n return True\n elif event.type == pygame.KEYDOWN and active_box is not None:\n if event.key == pygame.K_BACKSPACE:\n active_box.redraw(active_box.box_text[:-1])\n new_settings[active_box.text] = active_box.box_text\n elif (ch := (pygame.key.name(event.key))).isdecimal():\n active_box.redraw(active_box.box_text + ch)\n new_settings[active_box.text] = active_box.box_text\n\n\ndef wait_for_input(gui: GUI, waiting_for_unpause: bool = False) -> Tuple[int, int]:\n while True:\n pygame.time.wait(16)\n pygame.display.update()\n \n events = pygame.event.get()\n for event in events:\n if (\n (event.type == pygame.MOUSEBUTTONUP and event.button == 1 and gui.quit_button.clicked(pygame.mouse.get_pos()))\n or event.type == pygame.QUIT\n or (event.type == pygame.KEYDOWN and (event.key == pygame.K_p or not waiting_for_unpause))\n ):\n return event.type != pygame.MOUSEBUTTONUP, event.type != pygame.QUIT\n\n\ndef play_game(game: Game, gui: GUI) -> Tuple[int, int]:\n gui.set_messages(\"\")\n ticks_since_last_movement = 0\n direction = None\n current_head_direction = game.game_grid[game.head]\n next_head_y, next_head_x = game.head\n bug_hint_coord = game.partitioned_grid[game.bug_hint_idx]\n bug_hint_x, bug_hint_y = (bug_hint_coord % game.width, bug_hint_coord // game.width)\n gui.set_messages(f\"snake: ({next_head_x}, {next_head_y})\", f\"bug: ({bug_hint_x}, {bug_hint_y})\")\n \n while True:\n pygame.time.wait(16)\n pygame.display.update()\n ticks_since_last_movement += game.snake_speed != 0\n \n events = pygame.event.get()\n for event in events:\n if event.type == pygame.QUIT:\n return False, False\n elif event.type == pygame.MOUSEBUTTONUP and event.button == 1 and gui.quit_button.clicked(pygame.mouse.get_pos()):\n return False, True\n elif event.type == pygame.KEYDOWN:\n if (event.key == pygame.K_UP or event.key == pygame.K_w) and current_head_direction != SNAKE_DOWN:\n direction = SNAKE_UP\n elif (event.key == pygame.K_RIGHT or event.key == pygame.K_d) and current_head_direction != SNAKE_LEFT:\n direction = SNAKE_RIGHT\n elif (event.key == pygame.K_DOWN or event.key == pygame.K_s) and current_head_direction != SNAKE_UP:\n direction = SNAKE_DOWN\n elif (event.key == pygame.K_LEFT or event.key == pygame.K_a) and current_head_direction != SNAKE_RIGHT:\n direction = SNAKE_LEFT\n elif event.key == pygame.K_p:\n ticks_since_last_movement = 0\n gui.set_messages(\"paused\")\n keep_playing, keep_running = wait_for_input(gui, True)\n if not keep_playing or not keep_running:\n return keep_playing, keep_running\n gui.set_messages(f\"snake: ({next_head_x}, {next_head_y})\", f\"bug: ({bug_hint_x}, {bug_hint_y})\")\n elif event.key == pygame.K_z or event.key == pygame.K_x:\n game.change_bug_hint(event.key == pygame.K_x)\n bug_hint_coord = game.partitioned_grid[game.bug_hint_idx]\n bug_hint_x, bug_hint_y = (bug_hint_coord % game.width, bug_hint_coord // game.width)\n gui.set_messages(f\"snake: ({next_head_x}, {next_head_y})\", f\"bug: ({bug_hint_x}, {bug_hint_y})\")\n if direction is not None or (game.snake_speed != 0 and ticks_since_last_movement == game.snake_speed):\n if direction is None:\n direction = game.game_grid[game.head]\n ticks_since_last_movement = 0\n next_head_y, next_head_x = game.get_next_coord(game.head, direction)\n if not 0 <= next_head_y < game.height or not 0 <= next_head_x < game.width or SNAKE_UP <= game.game_grid[next_head_y, next_head_x] <= SNAKE_LEFT:\n game.free_memory() # free memory immediately since it will need to be freed later anyways\n gui.set_messages(\"you lose, press any key to reset\")\n return wait_for_input(gui)\n if game.game_grid[next_head_y, next_head_x] == EMPTY:\n game.move_into_empty((next_head_y, next_head_x), direction)\n elif game.game_grid[next_head_y, next_head_x] == 5 + game.bug_spawn_cycle:\n game.move_into_future_bug((next_head_y, next_head_x), direction)\n else:\n game.move_into_bug((next_head_y, next_head_x), direction)\n if game.snake_spaces == game.width * game.height:\n gui.draw_grid(game.game_grid, game.width, game.height, game.head, game.bug_spawn_cycle)\n game.free_memory() # free memory immediately since it will need to be freed later anyways\n gui.set_messages(\"you win, press any key to reset\")\n return wait_for_input(gui)\n gui.draw_grid(game.game_grid, game.width, game.height, game.head, game.bug_spawn_cycle)\n bug_hint_coord = game.partitioned_grid[game.bug_hint_idx]\n bug_hint_x, bug_hint_y = (bug_hint_coord % game.width, bug_hint_coord // game.width)\n gui.set_messages(f\"snake: ({next_head_x}, {next_head_y})\", f\"bug: ({bug_hint_x}, {bug_hint_y})\")\n current_head_direction = game.game_grid[game.head]\n direction = None\n\n\ndef main() -> None:\n pygame.init()\n pygame.display.set_caption(\"snake game\")\n gui = GUI()\n \n keep_running = True\n while keep_running:\n pygame.time.wait(16)\n pygame.display.update()\n \n events = pygame.event.get()\n for event in events:\n if event.type == pygame.QUIT:\n keep_running = False\n elif (\n event.type == pygame.MOUSEBUTTONUP\n and event.button == 1\n and any((b := button).clicked(pygame.mouse.get_pos()) for button in gui.buttons)\n ):\n if b.text == \"QUIT\":\n keep_running = False\n elif b.text == \"CONFIG\":\n gui.toggle_cfg_screen()\n keep_running = config(gui)\n gui.toggle_cfg_screen()\n elif b.text == \"START\":\n error_happened = False\n keep_playing = True\n gui.toggle_game_screen()\n while keep_playing and keep_running:\n try:\n game = Game(\n int(gui.settings[\"GRID_WIDTH\"]),\n int(gui.settings[\"GRID_HEIGHT\"]),\n int(gui.settings[\"MINIMUM_BUGS\"]),\n int(gui.settings[\"MAXIMUM_BUGS\"]),\n int(gui.settings[\"SNAKE_SPEED\"])\n )\n except (MemoryError, OverflowError) as e:\n gui.set_messages(e.__class__.__name__)\n error_happened = True\n break\n gui.set_messages(\"press any key to start\")\n gui.draw_grid(game.game_grid, game.width, game.height, game.head, game.bug_spawn_cycle)\n pygame.display.update()\n keep_playing, keep_running = wait_for_input(gui)\n if keep_playing and keep_running:\n keep_playing, keep_running = play_game(game, gui)\n game.free_memory()\n gui.toggle_game_screen()\n if not error_happened:\n gui.set_messages(\"\")\n \n pygame.quit()\n\n\nif __name__ == \"__main__\":\n main()\n\nclickablebox.py:\nimport pygame\n\nfrom collections.abc import Iterable\nfrom typing import Optional\n\n# button class\nclass ClickableBox:\n def __init__(\n self,\n win: pygame.Surface,\n font: pygame.font.Font,\n text: str,\n text_location: Iterable[int, int],\n box_location: Iterable[int, int],\n dimensions: Iterable[int, int],\n color: Iterable[int, int, int] = (150, 150, 150)) -> None:\n self.font = font\n self.text = text\n self.text_location = tuple(text_location)\n self.box_location = tuple(box_location)\n self.dimensions = tuple(dimensions)\n self.color = tuple(color)\n \n self.win = win\n self.box = None\n \n \n def draw(self) -> None:\n self.box = pygame.draw.rect(self.win, self.color, (*self.box_location, *self.dimensions))\n text_surface = self.font.render(self.text, True, (50, 50, 50))\n self.win.blit(text_surface, self.text_location)\n \n \n def undraw(self) -> None:\n pygame.draw.rect(self.win, (0, 0, 0), (*self.box_location, *self.dimensions))\n self.box = None\n \n \n def redraw(self) -> None:\n self.undraw()\n self.draw()\n \n \n def clicked(self, coords: Iterable[int, int]) -> bool:\n return self.box is not None and self.box.collidepoint(coords)\n\n\n# text box class\nclass TextEntryBox(ClickableBox):\n def __init__(\n self,\n win: pygame.Surface,\n font: pygame.font.Font,\n text: str,\n text_location: Iterable[int, int],\n box_location: Iterable[int, int],\n dimensions: Iterable[int, int],\n typing_location: Iterable[int, int],\n max_text: int,\n color: Iterable[int, int, int] = (150, 150, 150)) -> None:\n super().__init__(win, font, text, text_location, box_location, dimensions, color)\n self.typing_location = tuple(typing_location)\n self.max_text = max_text\n self.box_text = \"\"\n \n \n def redraw(self, new_box_text: Optional[str] = None) -> None:\n self.undraw()\n self.draw(new_box_text)\n \n \n def draw(self, new_box_text: Optional[str] = None) -> None:\n super().draw()\n new_box_text = new_box_text[:self.max_text] if new_box_text is not None else self.box_text\n typing_surface = self.font.render(new_box_text, True, (70, 70, 70))\n self.win.blit(typing_surface, self.typing_location)\n self.box_text = new_box_text\n \n \n def undraw(self) -> None:\n upper_left_undraw_box = (self.box_location[0], self.text_location[1])\n undraw_box_dimensions = (self.dimensions[0], self.dimensions[1] + (self.box_location[1] - self.text_location[1]))\n pygame.draw.rect(self.win, (0, 0, 0), (*upper_left_undraw_box, *undraw_box_dimensions))\n self.box = None\n\nbitpacking.py:\nimport sys\n\nfrom collections.abc import Iterable, Iterator\ntry: # typing.Self isn't available before 3.11\n from typing import Optional, Self, Tuple, Union\nexcept ImportError:\n from typing import Optional, Tuple, Union\n\nIS_AT_LEAST_3DOT11 = sys.version_info.major > 3 or (sys.version_info.major == 3 and sys.version_info.minor >= 11)\n\n# a class which lets you use a byte array as if it was an arbitrarily deeply nested\n# array with each index being any number of bits wide\nclass BitPackingArray:\n def __init__(\n self,\n dimensions: Union[Iterable[int], int],\n bits_per_index: int,\n bytearrayview: Optional[memoryview] = None,\n start_bit_offset: int = 0,\n current_dimension: int = 0) -> None:\n self.bits_per_index = bits_per_index\n self.dimensions = tuple(map(int, dimensions)) if not isinstance(dimensions, int) else (dimensions,)\n \n if len(self.dimensions) == 1 and self.dimensions[0] == 0:\n self.byte_array = bytearray(0)\n self.start_bit_offset = 0\n self.current_dimension = 0\n return\n \n if bytearrayview is None:\n if any(d <= 0 for d in self.dimensions):\n raise ValueError(\"all dimensions must be greater than 0\")\n elif bits_per_index <= 0:\n raise ValueError(\"bits_per_index must be greater than 0\")\n elif not dimensions:\n raise ValueError(\"no dimensions given\")\n \n total_bits = bits_per_index\n for d in self.dimensions:\n total_bits *= d\n \n total_bytes = (total_bits // 8) + (total_bits % 8 != 0)\n self.byte_array = bytearray(total_bytes)\n else:\n self.byte_array = bytearrayview\n self.start_bit_offset = start_bit_offset\n self.current_dimension = current_dimension\n \n \n # error checks indexes and turns negative indexes into normal indexes\n def index_generator(self, position: Iterable[int]) -> Iterator[int]:\n for depth, (pos, dimension_length) in enumerate(zip(position, self.dimensions)):\n actual_position = pos if pos >= 0 else dimension_length + pos\n if not 0 <= actual_position < dimension_length:\n raise IndexError(f\"attempted to access index {pos} of dimension {depth}, which is length {dimension_length}\")\n \n yield actual_position\n \n \n # finds byte position and bit position of data being accessed\n def get_actual_position(self, position: Union[Iterable[int], int]) -> Tuple[int, int]: # returns (start_byte, start_bit)\n if isinstance(position, int):\n position = (position,)\n if (len(position) != len(self.dimensions)):\n raise ValueError(\n f\"position argument had {len(position)} dimensions, \"\n f\"but self.dimensions has {len(self.dimensions)} dimensions\"\n )\n \n index_generator = self.index_generator(position)\n which_bit = next(index_generator)\n for i, pos in enumerate(index_generator, 1):\n which_bit = (which_bit * self.dimensions[i]) + pos\n which_bit *= self.bits_per_index\n which_bit += self.start_bit_offset\n \n return divmod(which_bit, 8)\n \n \n def get(self, position: Union[Iterable[int], int]) -> int:\n which_byte, byte_start_position = self.get_actual_position(position)\n bits_left_to_read = self.bits_per_index\n current_bit_position = min(8 - byte_start_position, bits_left_to_read)\n \n # reading first byte\n value = (self.byte_array[which_byte] >> byte_start_position) & ((1 << current_bit_position) - 1)\n bits_left_to_read -= current_bit_position\n which_byte += 1\n \n # reading middle byte(s)\n while bits_left_to_read >= 8:\n value += self.byte_array[which_byte] << current_bit_position\n bits_left_to_read -= 8\n current_bit_position += 8\n which_byte += 1\n \n #reading last byte\n if bits_left_to_read > 0:\n value += (self.byte_array[which_byte] & ((1 << bits_left_to_read) - 1)) << current_bit_position\n \n return value\n \n \n def set(self, position: Union[Iterable[int], int], new_value: int) -> None:\n which_byte, byte_start_position = self.get_actual_position(position)\n bits_left_to_set = self.bits_per_index\n \n # setting first byte\n bits_left_in_first_byte = min(8 - byte_start_position, bits_left_to_set)\n first_byte_start_bits = self.byte_array[which_byte] & ((1 << byte_start_position) - 1)\n current_value_to_write = new_value & ((1 << bits_left_in_first_byte) - 1)\n self.byte_array[which_byte] >>= byte_start_position + bits_left_in_first_byte\n self.byte_array[which_byte] <<= bits_left_in_first_byte\n self.byte_array[which_byte] += current_value_to_write\n self.byte_array[which_byte] <<= byte_start_position\n self.byte_array[which_byte] += first_byte_start_bits\n new_value >>= bits_left_in_first_byte\n bits_left_to_set -= bits_left_in_first_byte\n which_byte += 1\n \n # setting middle byte(s)\n while bits_left_to_set >= 8:\n current_value_to_write = new_value & 0b11111111\n self.byte_array[which_byte] = current_value_to_write\n new_value >>= 8\n bits_left_to_set -= 8\n which_byte += 1\n \n # setting last byte\n if bits_left_to_set > 0:\n self.byte_array[which_byte] >>= bits_left_to_set\n self.byte_array[which_byte] <<= bits_left_to_set\n self.byte_array[which_byte] += new_value\n \n \n def __getitem__(self, idx: int) -> Union[Self if IS_AT_LEAST_3DOT11 else None, int]:\n actual_idx = idx if idx >= 0 else self.dimensions[0] + idx\n if not 0 <= actual_idx < self.dimensions[0]:\n raise IndexError(f\"attempted to get index {idx} of dimension {self.current_dimension}, which is length {self.dimensions[0]}\")\n \n if len(self.dimensions) == 1:\n return self.get(idx)\n \n new_dimensions = self.dimensions[1:]\n \n bits_per_outer_index = self.bits_per_index\n for d in new_dimensions:\n bits_per_outer_index *= d\n \n start_bit = (bits_per_outer_index * actual_idx) + self.start_bit_offset\n stop_bit = (bits_per_outer_index * (actual_idx + 1)) + self.start_bit_offset\n start_byte, start_byte_bit_offset = divmod(start_bit, 8)\n stop_byte = (stop_bit // 8) + (stop_bit % 8 != 0)\n bytearrayview = memoryview(self.byte_array)[start_byte:stop_byte]\n \n return BitPackingArray(new_dimensions, self.bits_per_index, bytearrayview, start_byte_bit_offset, self.current_dimension + 1)\n \n \n def __setitem__(self, idx: int, new_value: int) -> None:\n if len(self.dimensions) > 1:\n raise ValueError(\"__setitem__ only supported on 1-dimensional arrays, len(self.dimensions) must be 1\")\n if not 0 <= idx if idx >= 0 else self.dimensions[0] + idx < self.dimensions[0]:\n raise IndexError(f\"attempted to set index {idx} of dimension {self.current_dimension}, which is length {self.dimensions[0]}\")\n if not 0 <= new_value <= ((1 << self.bits_per_index) - 1):\n raise ValueError(f\"value must be in range(0, {((1 << self.bits_per_index) - 1)}), value was {new_value}\")\n \n self.set(idx, new_value)\n \n \n def append(self, new_value: int) -> None:\n if len(self.dimensions) > 1 or self.current_dimension > 0:\n raise ValueError(\"appending only supported on 1-dimensional arrays\")\n if not 0 <= new_value <= ((1 << self.bits_per_index) - 1):\n raise ValueError(f\"value must be in range(0, {((1 << self.bits_per_index) - 1)}), value was {new_value}\")\n \n # allocating more space if necessary\n total_bits = self.bits_per_index * (self.dimensions[0] + 1)\n total_bytes = (total_bits // 8) + (total_bits % 8 != 0)\n while len(self.byte_array) < total_bytes:\n self.byte_array.append(0)\n \n self.dimensions = ((self.dimensions[0] + 1),)\n self.set(-1, new_value)\n \n \n def reshape(self, dimensions: Union[Iterable[int], int], bits_per_index: int) -> None:\n if isinstance(self.byte_array, memoryview):\n raise ValueError(\"can only reshape entire BitPackingArray\")\n \n self.bits_per_index = bits_per_index\n self.dimensions = tuple(map(int, dimensions)) if not isinstance(dimensions, int) else (dimensions,)\n \n if len(self.dimensions) == 1 and self.dimensions[0] == 0:\n self.byte_array = bytearray(0)\n return\n \n if any(d <= 0 for d in self.dimensions):\n raise ValueError(\"all dimensions must be greater than 0\")\n elif bits_per_index <= 0:\n raise ValueError(\"bits_per_index must be greater than 0\")\n elif not dimensions:\n raise ValueError(\"no dimensions given\")\n \n total_bits = bits_per_index\n for d in self.dimensions:\n total_bits *= d\n total_bytes = (total_bits // 8) + (total_bits % 8 != 0)\n \n self.byte_array.__init__(total_bytes)\n\n\nif not IS_AT_LEAST_3DOT11:\n BitPackingArray.__getitem__.__annotations__[\"return\"] = Union[BitPackingArray, int]\n\n"