求助适配非标准化Tileset的类《尖塔奇兵》式地牢生成算法

Hey there! Let's break down how to tackle this dungeon generation problem with your non-standard tileset—since you're dealing with variable-sized tiles, pre-defined doors, and a Slay the Spire-style branching path structure, we need a hybrid approach that combines graph-based routing with tile placement constraints.

1. Lay the Groundwork with a High-Level Path Graph #

First, map out the core structure of your dungeon like Slay the Spire's branching paths:

• Define key nodes: Entrance → 3-4 branch starter nodes → room nodes per branch → Boss Prep Nodes → Boss Arena (with built-in exit)
• Add optional cross-branch edges to enable inter-path shortcuts (just like the game's secret paths between branches)
• Use an undirected weighted graph to control path length—assign weights to edges to ensure each branch has 3-5 rooms before reaching the boss prep zone

2. Preprocess Your Tileset for Constraint Matching #

Since your tiles are non-standard (variable sizes, corner structures, fixed doors), you need to tag each tile to simplify placement:

• Label each tile with:
  • Exact size (e.g., 3x3, 7x9)
  • Door positions/types (e.g., north-straight, east-corner, south-hidden)
  • Structural type (e.g., rectangular, corner-left, L-shaped)
• Build a door-matching rule set: For example, a tile with an east-corner door can only connect to a tile with a west-corner door; straight doors only pair with matching straight doors.

3. Graph-Driven Tile Placement (With Backtracking) #

Now translate the path graph into actual tiles, step by step:

1. Start with the Entrance tile: Pick a tile with exactly one exit door (e.g., a 3x3 tile with only a south door) to force initial path direction.
2. Traverse each edge in the graph:
   • For the current tile's exit door, filter your tileset to find candidates with a matching entry door.
   • Prioritize size compatibility: If the current tile is 5x5, favor adjacent tiles that fit without awkward gaps (e.g., 3x3 centered next to it, or 7x7 overlapping slightly if your corner structures allow).
   • Use corner tiles to signal path turns: When a branch needs to curve left, select a corner-left tile that matches the incoming/outgoing door directions.
3. Handle cross-branch shortcuts: When two branch nodes need to connect, find tiles in both branches that have matching doors (e.g., a branch A tile with east door and a branch B tile with west door) and align them accordingly.

4. Integrate the Boss Arena (With Built-In Exit) #

The boss zone needs a unique, post-fight exit—here's how to embed it:

• Select a large, structurally distinct tile (e.g., 9x9) as the Boss Arena. Tag one specific door (e.g., a hidden corner door) as the exit-door, which is only unlockable after the boss is defeated.
• Connect all branch's Boss Prep Nodes to the arena's entry doors (you can have multiple entry points for different branches, just like Spire's boss room access).
• Ensure the arena's exit door has no matching tiles in your set—this prevents accidental early access.

5. Add Validation & Fallbacks for Edge Cases #

Non-standard tiles can lead to matching dead ends, so add safety nets:

• Implement a backtracking system: If a node can't find a valid matching tile, roll back to the previous node and pick an alternative tile from your candidates.
• Assign tile priorities: Mark common rectangular tiles as high-priority, and corner/L-shaped tiles as low-priority—this ensures easier matching first, saving unique tiles for intentional path turns.
• Keep a library of pre-built path fragments: For cases where auto-generation fails, have 2-3 pre-made branch+boss arena combinations ready to plug in.

Example Workflow Snippet #

# Step 1: Define the path graph
dungeon_graph = {
    "Entrance": ["Branch_Start_1", "Branch_Start_2"],
    "Branch_Start_1": ["Branch1_Room1", "Branch2_Room2"],  # Cross-branch shortcut
    "Branch1_Room1": ["Boss_Prep_1"],
    "Branch_Start_2": ["Branch2_Room1", "Branch2_Room2"],
    "Boss_Prep_1": ["Boss_Arena"],
    "Boss_Prep_2": ["Boss_Arena"],
    "Boss_Arena": ["Exit"]
}

# Step 2: Preprocessed tile example
tiles = [
    {"id": "entrance_01", "size": "3x3", "doors": ["south"], "type": "rectangular"},
    {"id": "corner_right_01", "size": "5x5", "doors": ["north", "east-corner"], "type": "corner-right"},
    {"id": "boss_arena_01", "size": "9x9", "doors": ["north", "west", "exit-corner"], "type": "boss"}
]

# Step 3: Simplified tile placement logic
def place_adjacent_tile(current_tile, target_node):
    matching_doors = get_matching_doors(current_tile["doors"])
    candidates = [t for t in tiles if any(d in t["doors"] for d in matching_doors)]
    # Pick highest priority candidate (e.g., same size first)
    selected_tile = sorted(candidates, key=lambda x: x["size"] == current_tile["size"], reverse=True)[0]
    return selected_tile

内容的提问来源于stack exchange，提问作者Denis Ilyutin