Dave's Branch

2023-Oct-18/Dave/.gitignore

@@ -0,0 +1 @@
+node_modules

2023-Oct-18/Dave/direction.py

@@ -0,0 +1,30 @@
+from enum import Enum, EnumMeta
+from point import Point
+
+
+class DirectValueMeta(EnumMeta):
+    # This allows us to unpack enum members directly, in the format:
+    # row, col = Direction.RIGHT
+    def __getattribute__(cls, name):
+        value = super().__getattribute__(name)
+        if isinstance(value, cls):
+            return value.value
+        else:
+            return value
+
+    # This allows us to iterate through enum members in a for loop and access
+    # the Point value directly
+    def __iter__(cls):
+        for value in super().__iter__():
+            yield value.value
+
+
+class Direction(Enum, metaclass=DirectValueMeta):
+    RIGHT = Point(0, 1)
+    DOWN = Point(1, 0)
+    UP = Point(-1, 0)
+    LEFT = Point(0, -1)
+    UP_LEFT = Point(-1, -1)
+    UP_RIGHT = Point(-1, 1)
+    DOWN_LEFT = Point(1, -1)
+    DOWN_RIGHT = Point(1, 1)

2023-Oct-18/Dave/exceptions.py

@@ -0,0 +1,14 @@
+class FailedToGenerateWordSearchError(Exception):
+    ...
+
+
+class FailedToPlaceAllWordsError(Exception):
+    ...
+
+
+class NoLegalPlacementsError(Exception):
+    ...
+
+
+class GridOverflowError(Exception):
+    ...

2023-Oct-18/Dave/main.py

@@ -0,0 +1,101 @@
+import random
+from copy import deepcopy
+from word_grid import WordGrid
+from point import Point
+from direction import Direction
+from placement import Placement
+from exceptions import (
+    FailedToGenerateWordSearchError,
+    FailedToPlaceAllWordsError,
+    NoLegalPlacementsError,
+    GridOverflowError,
+)
+
+
+def main():
+    word_list = ["PYTHON", "DOJO", "CODEHUB", "BRISTOL"]
+
+    try:
+        word_search = generate_word_search(rows=6, cols=9, word_list=word_list)
+        print(word_search)
+        print("Find these words:")
+        print(", ".join(word_list))
+    except FailedToGenerateWordSearchError:
+        print("Failed to generate word search.")
+        exit(1)
+
+
+def generate_word_search(rows: int, cols: int, word_list: list[str]) -> WordGrid:
+    word_grid = WordGrid(rows, cols)
+
+    attempts = 0
+    max_attempts = 10
+
+    while attempts < max_attempts:
+        word_grid.initialise_grid()
+        try:
+            filled_word_search = place_words(word_grid, word_list)
+            filled_word_search.fill_blank_space()
+            return filled_word_search
+        except FailedToPlaceAllWordsError:
+            attempts += 1
+    else:
+        raise FailedToGenerateWordSearchError()
+
+
+def place_words(word_grid: WordGrid, word_list: list[str]) -> WordGrid:
+    word_search = deepcopy(word_grid)
+
+    for word in word_list:
+        try:
+            placements = get_all_legal_placements_for_word(word_search, word)
+            position, direction = random.choice(placements)
+            word_search.write_line(position, direction, word)
+        except NoLegalPlacementsError:
+            raise FailedToPlaceAllWordsError()
+
+    return word_search
+
+
+def get_all_legal_placements_for_word(
+    word_grid: WordGrid, word: str
+) -> list[Placement]:
+    legal_placements = []
+
+    # Iterate through all possible grid locations and orientations
+    for row_index, row in enumerate(word_grid.grid):
+        for col_index, col in enumerate(row):
+            for direction in Direction:
+                position = Point(row_index, col_index)
+
+                line_can_be_written = word_grid.is_valid_line(
+                    position, direction, len(word)
+                )
+                if not line_can_be_written:
+                    continue
+
+                target_line = word_grid.read_line(
+                    position, direction, len(word))
+                line_can_be_placed = is_legal_placement(
+                    target_line=target_line, line_to_write=word
+                )
+                if not line_can_be_placed:
+                    continue
+
+                legal_placements.append(Placement(position, direction))
+
+    if len(legal_placements) == 0:
+        raise NoLegalPlacementsError()
+    else:
+        return legal_placements
+
+
+def is_legal_placement(target_line: str, line_to_write: str) -> bool:
+    for target_char, char_to_write in zip(target_line, line_to_write):
+        if (char_to_write != target_char) and (target_char != " "):
+            return False
+    return True
+
+
+if __name__ == "__main__":
+    main()

2023-Oct-18/Dave/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "Dave",
+  "version": "0.0.2",
+  "description": "",
+  "main": "main.py",
+  "scripts": {
+    "start": "nodemon main.py",
+    "test": "pytest"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "nodemon": "^3.0.1"
+  }
+}

2023-Oct-18/Dave/placement.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+from point import Point
+from direction import Direction
+
+
+@dataclass
+class Placement:
+    position: Point
+    direction: Direction
+
+    # This allows us to unpack a placement with the syntax:
+    # position, direction = placement
+    def __iter__(self):
+        yield self.position
+        yield self.direction