Python-使用字典创建建筑地图

Question

我想创建一个建筑地图，每个房间都有字典，包含从列表中随机选择的房间（想想旧的学校文本冒险）。

例如：

random_rooms = [class_room,hall,entrance]
room_A.directions = {"North":random.choice(random_rooms),"East":random.choice(random_rooms),"South":random.choice(random_rooms),"West":random.choice(random_rooms)}

但是，我想填充它，以便它与建筑匹配。因此，如果先设置房间A，并将房间B设置为北面，则房间B将房间A设置为南面。

所以：

room_A.directions = {"North":room_B,"East":None,"South":None,"West":None}
room_B.directions = {"North":None,"East":None,"South":room_A,"West":None}

我不知道最好的方法是什么。我不担心事情的顺序，只要一个房间不会同时在另一个房间的南北两边。

Answer 1

这似乎是开始使用类的好时机。通过一门课程，你将能够处理与每个房间相连的内容，以及通过哪个方向。这里有一个简单的例子。

class Room(object):
    def __init__(self, name=None):
        self.name = str(name)
        self.matching_direction = { "N": "S", "S": "N", "W": "E", "E": "W"}
        self.open_walls = ["N", "S", "E", "W"]
        self.connected_rooms = {}

    def connect_room(self, room_obj=None, room_obj_exit=None):
        """
        Connect two rooms if able.
        Params:
            room_obj: Room(Object)
            room_obj_exit: Direction(String)
        Return: Bool
        """
        try:
            opposite_direction = self.matching_direction[room_obj_exit]

            if opposite_direction not in self.open_walls:
                print "{} door is occupied by {}".format(opposite_direction, self.connected_rooms[opposite_direction].name)
                return False

            if room_obj_exit not in room_obj.open_walls:
                print "{} is occupied by {}".format(room_obj_exit, room_obj.connected_rooms[room_obj_exit].name)
                return False

            self.connected_rooms[opposite_direction] = room_obj
            room_obj.connected_rooms[room_obj_exit] = self
            self.open_walls.remove(opposite_direction)
            room_obj.open_walls.remove(room_obj_exit)
            return True

        except Exception as e:
            print e
        return False

    def explore_door(self, direction=None):
        """
        Try to move to another Room
        Return : Room(Object)
        """
        try:
            if direction in self.connected_rooms:
                print "The {} Door is open to {}".format(direction, self.connected_rooms[direction].name)
                return self.connected_rooms[direction]
            else:
                print "The {} Door is locked".format(direction)
        except Exception as e:
            print e
        return False

这里有一些用法：

room_one = Room(name="Room One")
room_two = Room(name="Room Two")
room_three = Room(name="Room Three")

room_one.connect_room(room_obj=room_two, room_obj_exit="N")
room_two.connect_room(room_obj=room_three, room_obj_exit="E")
room_three.connect_room(room_obj=room_one, room_obj_exit="S")

room_one.explore_door(direction="N")
room_one.explore_door(direction="S")
room_one.explore_door(direction="E")
room_one.explore_door(direction="W")

输出：

S is occupied by Room Two
The N Door is locked
The S Door is open to Room Two
The E Door is locked
The W Door is locked

Answer 2

听起来你实际上要找的更多的是一个坐标映射系统，而不是一个方向图。为此，您需要创建一个网格数组。然后，您的阵列将由您的布局组成（例如，4x4网格区域可以是4x4矩阵，也可以是简单的16单元阵列）。

假设一个#x#矩阵：

如果房间[0][3]=随机。选择（random_rooms）您唯一关心的是确保所有房间都已连接（添加一个通过过滤器以返回，如果[0][0]例如==有效房间，则必须大于[0][1]或[1][0]，这将填补连接所有房间的空白。

Answer 3

您可能需要一个矩阵来编码roomA，roomB，。。。通过这种方式，它们的相对位置可以按原样定义，因此您不必担心碰撞。例如：

import numpy as np

rooms = np.arange(4)  # 0, 1, 2, 3 stands for 4 rooms/roometypes/whatever
room_arrangement = np.random.shuffle(tmp).reshape(2,2)  # reshape into a 2x2 grid

分配到房间布置中的房间，使用数字表示房间对象或字符串。如果您需要房间稀疏排列，即它们可以分散到任何地方，请将一些0插入房间数组，并将下一行更改为重塑（m，n）其中m*n==np。总和（房间形状）。

顺便说一句，这是一个好主意，看看人们如何模型去游戏矩阵。基本原理与上面相同：1）定义您要处理的接地板，2）将标签插入接地板，3）必要时，将标签链接到您感兴趣的对象（简单情况：字典、数据框条目；稍微复杂的情况：定义类）。通常，数据编码在矩阵中，字典/类实例处理元数据/特殊规则部分。