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)}

但是，我想填充它，以便它与建筑物匹配。因此，如果首先设置room_A，并将room_B设置为北，则room_B将room_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

您可能希望矩阵编码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

分配到room_arrangement的房间，使用这些数字来引用房间对象或字符串。如果你需要房间稀疏地安排，即他们可以分散到任何地方，将一些0插入rooms数组，然后将下一行更改为reshape(m, n) m*n==np.sum(rooms.shape)。

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

Answer 2

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

假设＃x＃矩阵：

如果房间[0] [3] = random.choice（random_rooms），你唯一关心的是确保所有房间都连通（添加一个通过过滤器以便返回，如果[0] [0]，例如==有效房间，[0] [1]必须，或[1] [0]必须，这将填补连接所有房间的空白。

Answer 3

这似乎是开始使用课程的好时机。通过课程，您将能够处理连接到每个房间的方向，以及通过哪个方向。这是一个简单的例子。

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

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

3 个答案: