Links Awakening: Implement New Game (#1334)

Adds Link's Awakening: DX. Fully imports and forks LADXR, with permission - https://github.com/daid/LADXR

worlds/ladx/LADXR/mapgen/logic.py

@@ -0,0 +1,146 @@
+from .map import Map
+from .locations.entrance import Entrance
+from ..logic import *
+from .tileset import walkable_tiles, entrance_tiles
+
+
+class LogicGenerator:
+    def __init__(self, configuration_options, world_setup, requirements_settings, the_map: Map):
+        self.w = the_map.w * 10
+        self.h = the_map.h * 8
+        self.map = the_map
+        self.logic_map = [None] * (self.w * self.h)
+        self.location_lookup = {}
+        self.configuration_options = configuration_options
+        self.world_setup = world_setup
+        self.requirements_settings = requirements_settings
+
+        self.entrance_map = {}
+        for room in the_map:
+            for location in room.locations:
+                self.location_lookup[(room.x * 10 + location.x, room.y * 8 + location.y)] = location
+                if isinstance(location, Entrance):
+                    location.prepare_logic(configuration_options, world_setup, requirements_settings)
+                    self.entrance_map[location.entrance_name] = location
+
+        start = self.entrance_map["start_house"]
+        self.start = Location()
+        self.egg = self.start  # TODO
+        self.nightmare = Location()
+        self.windfish = Location().connect(self.nightmare, AND(MAGIC_POWDER, SWORD, OR(BOOMERANG, BOW)))
+        self.fill_walkable(self.start, start.room.x * 10 + start.x, start.room.y * 8 + start.y)
+
+        logic_str_map = {None: "."}
+        for y in range(self.h):
+            line = ""
+            for x in range(self.w):
+                if self.logic_map[x + y * self.w] not in logic_str_map:
+                    logic_str_map[self.logic_map[x + y * self.w]] = chr(len(logic_str_map)+48)
+                line += logic_str_map[self.logic_map[x + y * self.w]]
+            print(line)
+
+        for room in the_map:
+            for location in room.locations:
+                if self.logic_map[(room.x * 10 + location.x) + (room.y * 8 + location.y) * self.w] is None:
+                    raise RuntimeError(f"Location not mapped to logic: {room} {location.__class__.__name__} {location.x} {location.y}")
+
+        tmp = set()
+        def r(n):
+            if n in tmp:
+                return
+            tmp.add(n)
+            for item in n.items:
+                print(item)
+            for o, req in n.simple_connections:
+                r(o)
+            for o, req in n.gated_connections:
+                r(o)
+        r(self.start)
+
+    def fill_walkable(self, location, x, y):
+        tile_options = walkable_tiles | entrance_tiles
+        for x, y in self.flood_fill_logic(location, tile_options, x, y):
+            if self.logic_map[x + y * self.w] is not None:
+                continue
+            tile = self.map.get_tile(x, y)
+            if tile == 0x5C:  # bush
+                other_location = Location()
+                location.connect(other_location, self.requirements_settings.bush)
+                self.fill_bush(other_location, x, y)
+            elif tile == 0x20:  # rock
+                other_location = Location()
+                location.connect(other_location, POWER_BRACELET)
+                self.fill_rock(other_location, x, y)
+            elif tile == 0xE8:  # pit
+                if self.map.get_tile(x - 1, y) in tile_options and self.map.get_tile(x + 1, y) in tile_options:
+                    if self.logic_map[x - 1 + y * self.w] == location and self.logic_map[x + 1 + y * self.w] is None:
+                        other_location = Location().connect(location, FEATHER)
+                        self.fill_walkable(other_location, x + 1, y)
+                    if self.logic_map[x - 1 + y * self.w] is None and self.logic_map[x + 1 + y * self.w] == location:
+                        other_location = Location().connect(location, FEATHER)
+                        self.fill_walkable(other_location, x - 1, y)
+                if self.map.get_tile(x, y - 1) in tile_options and self.map.get_tile(x, y + 1) in tile_options:
+                    if self.logic_map[x + (y - 1) * self.w] == location and self.logic_map[x + (y + 1) * self.w] is None:
+                        other_location = Location().connect(location, FEATHER)
+                        self.fill_walkable(other_location, x, y + 1)
+                    if self.logic_map[x + (y - 1) * self.w] is None and self.logic_map[x + (y + 1) * self.w] == location:
+                        other_location = Location().connect(location, FEATHER)
+                        self.fill_walkable(other_location, x, y - 1)
+
+    def fill_bush(self, location, x, y):
+        for x, y in self.flood_fill_logic(location, {0x5C}, x, y):
+            if self.logic_map[x + y * self.w] is not None:
+                continue
+            tile = self.map.get_tile(x, y)
+            if tile in walkable_tiles or tile in entrance_tiles:
+                other_location = Location()
+                location.connect(other_location, self.requirements_settings.bush)
+                self.fill_walkable(other_location, x, y)
+
+    def fill_rock(self, location, x, y):
+        for x, y in self.flood_fill_logic(location, {0x20}, x, y):
+            if self.logic_map[x + y * self.w] is not None:
+                continue
+            tile = self.map.get_tile(x, y)
+            if tile in walkable_tiles or tile in entrance_tiles:
+                other_location = Location()
+                location.connect(other_location, POWER_BRACELET)
+                self.fill_walkable(other_location, x, y)
+
+    def flood_fill_logic(self, location, tile_types, x, y):
+        assert self.map.get_tile(x, y) in tile_types
+        todo = [(x, y)]
+        entrance_todo = []
+
+        edge_set = set()
+        while todo:
+            x, y = todo.pop()
+            if self.map.get_tile(x, y) not in tile_types:
+                edge_set.add((x, y))
+                continue
+            if self.logic_map[x + y * self.w] is not None:
+                continue
+            self.logic_map[x + y * self.w] = location
+            if (x, y) in self.location_lookup:
+                room_location = self.location_lookup[(x, y)]
+                result = room_location.connect_logic(location)
+                if result:
+                    entrance_todo += result
+
+            if x < self.w - 1 and self.logic_map[x + 1 + y * self.w] is None:
+                todo.append((x + 1, y))
+            if x > 0 and self.logic_map[x - 1 + y * self.w] is None:
+                todo.append((x - 1, y))
+            if y < self.h - 1 and self.logic_map[x + y * self.w + self.w] is None:
+                todo.append((x, y + 1))
+            if y > 0 and self.logic_map[x + y * self.w - self.w] is None:
+                if self.map.get_tile(x, y - 1) == 0xA0:  # Chest, can only be collected from the south
+                    self.location_lookup[(x, y - 1)].connect_logic(location)
+                    self.logic_map[x + (y - 1) * self.w] = location
+                todo.append((x, y - 1))
+
+        for entrance_name, logic_connection in entrance_todo:
+            entrance = self.entrance_map[entrance_name]
+            entrance.connect_logic(logic_connection)
+            self.fill_walkable(logic_connection, entrance.room.x * 10 + entrance.x, entrance.room.y * 8 + entrance.y)
+        return edge_set