Python 索引器：列出矩阵中超出范围的索引

我一直在尝试创建一个程序生成的地下城，如中所示。但对于我来说，理解这种算法的工作原理有点困难。因此，我一直在用它作为指导，至少可以了解房间的位置

本文中使用的程序是用Java编写的，因此我对我的“现实”做了一些修改，并尝试在Python 3.5中模拟相同的结果

我的代码如下：

from random import randint


class Room:

    """docstring for Room"""

    def __init__(self, x, y, w, h):
        """[summary]

        [description]

        Arguments:
                x {int} -- bottom-left horizontal anchorpoint of the room
                y {int} -- bottom-left vertical anchor point of the room
                w {int} -- width of the room
                h {int} -- height of the room
        """
        self.x1 = x
        self.x2 = x + w
        self.y1 = y
        self.y2 = y + h
        self.w = w
        self.h = h
        self.center = ((self.x1 + self.x2)/2, (self.y1 + self.y2)/2)

    def intersects(self, room):
        """[summary]

        Verifies if the rooms overlap

        Arguments:
                room {Room} -- a room object
        """
        return(self.x1 <= room.x2 and self.x2 >= room.x1 and \
               self.y1 <= room.y2 and self.y2 >= room.y1)

    def __str__(self):
        room_info = ("Coords: (" + str(self.x1) + ", " + str(self.y1) +
                     ") | (" + str(self.x2) + ", " + str(self.y2) + ")\n")
        room_info += ("Center: " + str(self.center) + "\n")
        return(room_info)

MIN_ROOM_SIZE = 10
MAX_ROOM_SIZE = 20
MAP_WIDTH = 400
MAP_HEIGHT = 200
MAX_NUMBER_ROOMS = 20

dungeon_map = [[None] * MAP_WIDTH for i in range(MAP_HEIGHT)]
# print(dungeon_map)


def crave_room(room):
    """[summary]

    "saves" a room in the dungeon map by making everything inside it's limits 1

    Arguments:
            room {Room} -- the room to crave in the dungeon map
    """
    for x in xrange(min(room.x1, room.x2), max(room.x1, room.x2) + 1):
        for y in xrange(min(room.y1, room.y2), max(room.y1, room.y2) + 1):
            print(x, y)  # debug
            dungeon_map[x][y] = 1
    print("Done")  # dungeon


def place_rooms():

    rooms = []

    for i in xrange(0, MAX_NUMBER_ROOMS):
        w = MIN_ROOM_SIZE + randint(0, MAX_ROOM_SIZE - MIN_ROOM_SIZE + 1)
        h = MIN_ROOM_SIZE + randint(0, MAX_ROOM_SIZE - MIN_ROOM_SIZE + 1)
        x = randint(0, MAP_WIDTH - w) + 1
        y = randint(0, MAP_HEIGHT - h) + 1

        new_room = Room(x, y, w, h)
        fail = False
        for other_room in rooms:
            if new_room.intersects(other_room):
                fail = True
                break
        if not fail:
            print(new_room)
            crave_room(new_room)  # WIP
            new_center = new_room.center
            # rooms.append(new_room)
            if len(rooms) != 0:
                prev_center = rooms[len(rooms) - 1].center

                if(randint(0, 1) == 1):
                    h_corridor(prev_center[0], new_center[0], prev_center[1])
                    v_corridor(prev_center[1], new_center[1], prev_center[0])
                else:
                    v_corridor(prev_center[1], new_center[1], prev_center[0])
                    h_corridor(prev_center[0], new_center[0], prev_center[1])
        if not fail:
            rooms.append(new_room)
    for room in rooms:
        print(room)


def h_corridor(x1, x2, y):
    for x in xrange(min(x1, x2), max(x1, x2) + 1):
        dungeon_map[x][y] = 1


def v_corridor(y1, y2, x):
    for y in xrange(min(y1, y2), max(y1, y2) + 1):
        dungeon_map[x][y] = 1

place_rooms()

来自随机导入randint
教室：
“”“文件室的文档字符串”“”
定义初始值（self，x，y，w，h）：
“”[摘要]
[说明]
论据：
x{int}--房间的左下水平固定点
y{int}——房间的左下垂直定位点
w{int}——房间的宽度
h{int}——房间的高度
"""
self.x1=x
self.x2=x+w
self.y1=y
self.y2=y+h
self.w=w
self.h=h
self.center=（（self.x1+self.x2）/2，（self.y1+self.y2）/2）
def相交（自身、房间）：
“”[摘要]
验证房间是否重叠
论据：
房间{room}--房间对象
"""
返回（self.x1=房间x1和\
self.y1=房间.y1）
定义（自我）：
房间信息=（“坐标：（“+str（self.x1）+”，“+str（self.y1））+
（“+str（self.x2）+”，“+str（self.y2）+”）\n）
房间信息+=（“中心：”+str（self.Center）+“\n”）
返回（房间信息）
最小房间大小=10
最大房间大小=20
地图宽度=400
地图高度=200
最大房间数=20间
地下城地图=[[None]*地图宽度（地图高度）]
#打印（地牢地图）
def crave_房间（房间）：
“”[摘要]
“保存”地牢地图中的一个房间，使其限制范围内的所有内容为1
论据：
房间{room}——地牢地图上渴望的房间
"""
对于x范围内的x（最小值（房间x1，房间x2），最大值（房间x1，房间x2）+1）：
对于X范围内的y（最小值（y1房间，y2房间），最大值（y1房间，y2房间）+1）：
打印（x，y）#调试
地下城地图[x][y]=1
打印（“完成”）#副本
def place_rooms（）：
房间=[]
对于X范围内的i（0，最大房间数）：
w=最小房间大小+randint（0，最大房间大小-最小房间大小+1）
h=最小房间大小+随机数（0，最大房间大小-最小房间大小+1）
x=randint（0，地图宽度-w）+1
y=randint（0，地图高度-h）+1
新房间=房间（x、y、w、h）
失败=错误
对于房间中的其他房间：
如果新房间与（其他房间）相交：
失败=真
打破
如果没有失败：
印刷品（新房）
渴望房间（新房间）#在制品
新建房间中心=新建房间中心
#房间。附加（新房间）
如果len（房间）！=0:
上一个中心=房间[len（房间）-1]。中心
如果（randint（0，1）==1）：
h_走廊（前_中心[0]、新_中心[0]、前_中心[1]）
v_走廊（前_中心[1]、新_中心[1]、前_中心[0]）
其他：
v_走廊（前_中心[1]、新_中心[1]、前_中心[0]）
h_走廊（前_中心[0]、新_中心[0]、前_中心[1]）
如果没有失败：
房间。附加（新房间）
对于房间中的房间：
印刷品（房间）
def h_走廊（x1、x2、y）：
对于x范围内的x（最小值（x1，x2），最大值（x1，x2）+1）：
地下城地图[x][y]=1
def v_走廊（y1、y2、x）：
对于X范围内的y（最小（y1，y2），最大（y1，y2）+1）：
地下城地图[x][y]=1
地点(房间)

但无论何时运行它，都会出现以下错误：

Traceback (most recent call last):
  File "/home/user/dungeon.py", line 114, in <module>
    place_rooms()
  File "/home/user/dungeon.py", line 87, in place_rooms
    crave_room(new_room)  
  File "/home/user/dungeon.py", line 65, in crave_room
    dungeon_map[x][y] = 1
IndexError: list index out of range

回溯（最近一次呼叫最后一次）：
文件“/home/user/dungeon.py”，第114行，在
地点(房间)
文件“/home/user/dungeon.py”，第87行，就地房间
渴望房间（新房间）
文件“/home/user/dungeon.py”，第65行，在crave_room中
地下城地图[x][y]=1
索引器：列表索引超出范围

就我从代码中了解到的情况而言，

crave\u room

功能应该正常工作，因为我使用的是

min

和

max

功能。由于

h_走廊

和

v_走廊

功能以类似的方式工作，因此它们提出了相同的问题

我不确定问题是否发生了，因为我使用了一个矩阵来替代原始文章中使用的画布。我怀疑存在局部/全局变量问题，但我认为这不是问题所在。恐怕我犯了一个非常愚蠢的错误，没有看到它

任何关于更好使用数据结构的代码改进提示或建议都是受欢迎的，如果有人有，可以在主题中写一篇更清晰/更简单的文章，最好是关于Python的，我在这里看到了很多相关的帖子，但我还是有点迷路

---

谢谢你的帮助D

您的

地下城地图

声明不正确：

dungeon_map = [[None] * MAP_WIDTH] * MAP_HEIGHT

正确的方法应该是：

dungeon_map = [[None] * MAP_HEIGHT] * MAP_WIDTH

既然你这么做了，让我们来看看第二个更严重的问题。让我们在小比例尺（小地图）上做一个实验：

在本实验中，我们创建了一个4列X 2行矩阵，我们改变了一个单元的值，所以我们来看看输出：

Before Assignment:
[[None, None], [None, None], [None, None], [None, None]]

After Assignment:
[[None, 'y'], [None, 'y'], [None, 'y'], [None, 'y']]

发生了什么事？本质上，您声明了相同的列表，

MAP\u WIDTH

times。下面的声明行既方便又巧妙，但不正确：

dungeon_map = [[None] * MAP_HEIGHT] * MAP_WIDTH

声明此类矩阵的正确方法是：

dungeon_map = [[None for x in range(MAP_HEIGHT)] for y in range(MAP_WIDTH)]

---

可能与您的问题无关，但

地下城地图=[[None]*地图宽度]*地图高度

稍后会引起麻烦。有关详细信息，请参见Wild guess：尝试使矩阵的行/列更高/更宽<代码>地下城地图=[[None]*（地图宽度+1）范围内（地图高度+1）]另一个提示：使用numpy和它的数组而不是列表，特别是如果你计划以后对它们进行操作的话。我能说的就是

dungeon_map = [[None for x in range(MAP_HEIGHT)] for y in range(MAP_WIDTH)]