最新国产好看的视频,伊人天堂AV在线,国产Aaaaaa视频,蜜臀视频在线观看一区,人妻av色图,密臀久久久精品影片,青青视频免费观看毛片,久草在线观看视,国产三级精品色情在线

python實現(xiàn)地牢迷宮生成的完整步驟

 更新時間:2021年09月26日 15:56:58   作者:揉揉漆  
這篇文章主要給大家介紹了關于python實現(xiàn)地牢迷宮生成的相關資料,文中通過示例代碼將實現(xiàn)的過程一步步介紹的非常詳細,對大家學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

基本屬性

定義當前地牢的等級,地圖長寬,房間數(shù)量,房間的最小最大長度,如下

class Map:
    def __init__(self):
        self.width = 30
        self.heigh = 30
        self.level = 1
        self.roomNum = 5
        self.map = np.zeros((self.heigh,self.width))
        self.roomMin = 3
        self.roomMax = 11

生成房間

編寫initRoom()隨機生成房間,限制最多循環(huán)次數(shù),為了簡單起見,先做一個不會重疊的房間?;舅悸肥牵弘S機房間的中心點,隨機房間的長寬,再進行判斷房間有無重疊(在后續(xù)會生成通道,簡單起見在這里也保證房間不會緊貼),若無重疊,房間有效,房間數(shù)加1。貼代碼

    def initRoom(self):
        count = 0
        roomCount = 1
        while True:
            count += 1
            if count > 300:
                break
            if roomCount > self.roomNum:
                break
            x = random.randint(1,self.width-1)
            y = random.randint(1,self.heigh-1)
            wd = random.randint(self.roomMin,self.roomMax)
            ht = random.randint(self.roomMin, self.roomMax)
            r1 = ceil(y - ht/2)
            r2 = ceil(y + ht/2)
            c1 = ceil(x - wd/2)
            c2 = ceil(x + wd/2)
            if r1 < 1:
                r1 = 1
            if r2 >= self.heigh - 1:
                r2 = self.heigh - 2
            if c1 < 1:
                c1 = 1
            if c2 >= self.width - 1:
                c2 = self.width - 2
            w = c2 - c1 + 1
            h = r2 - r1 + 1
            if h / w >= 3 or w / h >= 3: #保證房間不是細長的
                continue
            judge = self.isValidRoom(r1,r2,c1,c2)
            if judge == 0:
                roomCount += 1
                self.room.append(Room(r1,r2,c1,c2))
                for i in range(r1,r2):
                    for j in range(c1,c2):
                        self.map[i,j] = 1
                        
    def isValidRoom(self,r1,r2,c1,c2):
        #檢測有無覆蓋
        for i in range(r1,r2):
            for j in range(c1,c2):
                if self.map[i,j] == 1:
                    return -1
        #檢測有無緊貼房間
        for i in range(r1,r2):
            if self.map[i,c1-1] == 1 or self.map[i,c2+1] == 1:
                return 2
        for i in range(c1,c2):
            if self.map[r1-1,i] == 1 or self.map[r2+1,i] == 1:
                return 2
        return 0

看一下效果

生成五個房間

生成墻壁

編寫initTile()生成包圍房間和通道的墻壁,直接貼代碼

    def initTile(self):
        offset = [[-1,0],[0,-1],[1,0],[0,1],[-1,-1],[1,1],[1,-1],[-1,1]]
        for i in range(self.heigh):
            for j in range(self.width):
                if self.map[i,j] == 0:
                    tag = 0
                    for it in offset:
                        if i+it[0] >= self.heigh or j+it[1] >= self.width or i+it[0] < 0 or j+it[1] < 0:
                            continue
                        if self.map[i+it[0],j+it[1]] != 3 and self.map[i+it[0],j+it[1]] != 4:
                            tag += self.map[i+it[0],j+it[1]]
                    if tag:
                        self.map[i,j] = 3

效果

有墻壁的房間

生成門口

隨機選取房間的一個外圍點當做房門,思路是在房間的長寬內隨機兩個數(shù)作為偏移量,預定義好四個方向的覆蓋模板對偏移量進行加權和偏置,在這里我編寫房間的類,加進地圖的屬性列表里。

除此之外,房間連通的思路是:在所有房間列表中隨機抽出兩個房間,將這兩個房間連通,再隨機選一個房間加回原來的房間列表,直至最后列表里只剩下一個房間。那么現(xiàn)在先來生成房門,代碼如下

class Room():
    def __init__(self,r1,r2,c1,c2):
        w = c2 - c1
        h = r2 - r1
        self.width = w
        self.height = h
        self.cx = c1 + ceil(w/2)
        self.cy = r1 + ceil(h/2)
        self.xStart = c1
        self.xEnd = c2 - 1
        self.yStart = r1
        self.yEnd = r2 - 1

    def randomTile(self):
        direction = random.randint(0,3)
        dir = [[0,1,-1,0],[1,0,0,-1],[1,0,0,self.height],[0,1,self.width,0]]
        x_off = random.randint(0,self.width-1)
        y_off = random.randint(0,self.height-1)
        x = self.xStart + x_off*dir[direction][0] + dir[direction][2]
        y = self.yStart + y_off*dir[direction][1] + dir[direction][3]
        if y == 0 or x == 0:
            return self.randomTile()
        else:
            return [y,x]
class Map:
    def initPath(self):
        #初始化門
        rm = self.room.copy()
        while len(rm) > 1:
            r1 = random.choice(rm)
            rm.remove(r1)
            r2 = random.choice(rm)
            rm.remove(r2)
            point0 = r1.randomTile()
            while point0[0] == self.heigh-1 or point0[1] == self.width-1:
                point0 = r1.randomTile()
            self.map[point0[0],point0[1]] = 2
            self.door.append(point0)
            self.breakTile(point0)
            point1 = r2.randomTile()
            while point1[0] == self.heigh-1 or point1[1] == self.width-1:
                point1 = r2.randomTile()
            self.map[point1[0],point1[1]] = 2
            self.breakTile(point1)
            self.door.append(point1)
            rn = random.randint(0,1)
            #a*算法尋找從point0到point1的路徑
            #self.aStar(point0,point1)
            if rn == 0:
                rm.append(r1)
            else:
                rm.append(r2)
                
    def breakTile(self,p):
        # 打通堵住的周圍的墻壁
        if self.map[p[0] - 1, p[1]] == 1 and self.map[p[0] + 1, p[1]] == 3:
            self.map[p[0] + 1, p[1]] = 2
        elif self.map[p[0], p[1] - 1] == 1 and self.map[p[0], p[1] + 1] == 3:
            self.map[p[0], p[1] + 1] = 2
        elif self.map[p[0] + 1, p[1]] == 1 and self.map[p[0] - 1, p[1]] == 3:
            self.map[p[0] - 1, p[1]] = 2
        elif self.map[p[0], p[1] + 1] == 1 and self.map[p[0], p[1] - 1] == 3:
            self.map[p[0], p[1] - 1] = 2

看下效果

有房門的房間

生成通道

接著完善上述函數(shù),在隨機選取房門后,連接兩個房門。

在這我選擇的是A星算法,打通兩個房門,直接上代碼

    def aStar(self,p0,p1):
        open_list = []
        close_list = []
        offset = [[-1,0],[0,-1],[1,0],[0,1]]
        f = h = abs(p0[0] - p1[0]) * 10 + abs(p0[1] - p1[1]) * 10
        g = 0

        def isInClose(p):
            for it in close_list:
                if it.value[3] == p:
                    return True
            return False
        def isInOpen(p):
            for it in open_list:
                if it.value[3] == p:
                    return True
            return False
        def findFather(p):
            for it in close_list:
                if it.value[3] == p:
                    return it.value[4]
            return [-1,-1]
        def findInOpen(p):
            for it in open_list:
                if it.value[3] == p:
                    return it
            return None

        open_list.append(Node([f,g,h,p0,[-1,-1]]))
        while open_list:
            #for it in open_list:
            #    print(it.value)
            open_list.sort(key=(lambda x:x.value[0]))
            f_min = open_list[0]
            close_list.append(f_min)
            open_list.remove(f_min)
            for it in offset:
                p2 = [f_min.value[3][0]+it[0], f_min.value[3][1]+it[1]]
                if p2[0] == p1[0] and p2[1] == p1[1]:
                    #找到
                    close_list.append(Node([f,g,h,p2,f_min]))
                    p_father = f_min.value[3]
                    while True:
                        self.map[p_father[0],p_father[1]] = 2
                        p_father = findFather(p_father)
                        if p_father[0] == -1:
                            break
                    self.map[p0[0], p0[1]] = 4
                    return
                if p2[0] < 0 or p2[0] >= self.heigh or p2[1] < 0 or p2[1] >= self.width:
                    continue
                if (self.map[p2[0],p2[1]] != 0 and self.map[p2[0],p2[1]] != 2 and self.map[p2[0],p2[1]] != 4) or isInClose(p2):
                    continue
                h = abs(p2[0] - p1[0]) * 10 + abs(p2[1] - p1[1]) * 10
                g = f_min.value[1] + 10
                f = h + g
                if not isInOpen(p2):
                    open_list.append(Node([f,g,h,p2,f_min.value[3]]))
                else:
                    #比較最小的G 值
                    temp = findInOpen(p2)
                    if g < temp.value[1]:
                        open_list.remove(temp)
                        open_list.append(Node([f,g,h,p2,f_min.value[3]]))

效果

這樣,一個隨機房間的地牢就已經(jīng)生成,貼上完整代碼

import random
import numpy as np
from math import ceil

class Node():
    def __init__(self, val=None):
        if val is None:
            val = [0, 0, 0, [-1, -1], [-1, -1]]
        self.value = val

class Room():
    def __init__(self,r1,r2,c1,c2):
        w = c2 - c1
        h = r2 - r1
        self.width = w
        self.height = h
        self.cx = c1 + ceil(w/2)
        self.cy = r1 + ceil(h/2)
        self.xStart = c1
        self.xEnd = c2 - 1
        self.yStart = r1
        self.yEnd = r2 - 1

    def info(self):
        print('r1 c1 r2 c2:  ',self.yStart,self.xStart,self.yEnd,self.xEnd)
        print('cx    cy:     ',self.cx,self.cy)
        print('width height: ',self.width,self.height)

    def randomTile(self):
        direction = random.randint(0,3)
        dir = [[0,1,-1,0],[1,0,0,-1],[1,0,0,self.height],[0,1,self.width,0]]
        x_off = random.randint(0,self.width-1)
        y_off = random.randint(0,self.height-1)
        x = self.xStart + x_off*dir[direction][0] + dir[direction][2]
        y = self.yStart + y_off*dir[direction][1] + dir[direction][3]
        if y == 0 or x == 0:
            return self.randomTile()
        else:
            return [y,x]

class Map:
    def __init__(self):
        self.width = 30
        self.heigh = 30
        self.level = 1
        self.roomNum = 5
        #0 is null, 1 is room, 2 is path, 3 is wall, 4 is door, 5 is up stair, 6 is downstair
        self.map = np.zeros((self.width,self.heigh))
        self.roomMin = 3
        self.roomMax = 11
        self.room = []
        self.door = []

        self.initRoom()
        self.initTile()
        self.initPath()
        #self.initTile()
        #self.initDoor()

    def initRoom(self):
        count = 0
        roomCount = 1
        while True:
            count += 1
            if count > 300:
                break
            if roomCount > self.roomNum:
                break
            x = random.randint(1,self.width-1)
            y = random.randint(1,self.heigh-1)
            wd = random.randint(self.roomMin,self.roomMax)
            if wd % 2 == 0:
                wd += 1
            ht = random.randint(self.roomMin, self.roomMax)
            if ht % 2 == 0:
                ht += 1
            r1 = ceil(y - ht/2)
            r2 = ceil(y + ht/2)
            c1 = ceil(x - wd/2)
            c2 = ceil(x + wd/2)
            if r1 < 1:
                r1 = 1
            if r2 >= self.heigh - 1:
                r2 = self.heigh - 2
            if c1 < 1:
                c1 = 1
            if c2 >= self.width - 1:
                c2 = self.width - 2
            w = c2 - c1 + 1
            h = r2 - r1 + 1
            if w == 0:
                continue
            if h == 0:
                continue
            if h / w >= 3 or w / h >= 3:
                continue
            judge = self.isValidRoom(r1,r2,c1,c2)
            if judge == 0:
                roomCount += 1
                self.room.append(Room(r1,r2,c1,c2))
                for i in range(r1,r2):
                    for j in range(c1,c2):
                        self.map[i,j] = 1

    def initPath(self):
        #初始化門
        rm = self.room.copy()
        while len(rm) > 1:
            r1 = random.choice(rm)
            rm.remove(r1)
            r2 = random.choice(rm)
            rm.remove(r2)
            point0 = r1.randomTile()
            while point0[0] == self.heigh-1 or point0[1] == self.width-1:
                point0 = r1.randomTile()
            self.map[point0[0],point0[1]] = 2
            self.door.append(point0)
            self.breakTile(point0)
            point1 = r2.randomTile()
            while point1[0] == self.heigh-1 or point1[1] == self.width-1:
                point1 = r2.randomTile()
            self.map[point1[0],point1[1]] = 2
            self.breakTile(point1)
            self.door.append(point1)
            rn = random.randint(0,1)
            #a*算法尋找從point0到point1的路徑
            self.aStar(point0,point1)
            if rn == 0:
                rm.append(r1)
            else:
                rm.append(r2)

    def initDoor(self):
        for it in self.door:
            self.map[it[0],it[1]] = 4

    def breakTile(self,p):
        # 打通堵住的周圍的墻壁
        if self.map[p[0] - 1, p[1]] == 1 and self.map[p[0] + 1, p[1]] == 3:
            self.map[p[0] + 1, p[1]] = 2
        elif self.map[p[0], p[1] - 1] == 1 and self.map[p[0], p[1] + 1] == 3:
            self.map[p[0], p[1] + 1] = 2
        elif self.map[p[0] + 1, p[1]] == 1 and self.map[p[0] - 1, p[1]] == 3:
            self.map[p[0] - 1, p[1]] = 2
        elif self.map[p[0], p[1] + 1] == 1 and self.map[p[0], p[1] - 1] == 3:
            self.map[p[0], p[1] - 1] = 2

    def initTile(self):
        offset = [[-1,0],[0,-1],[1,0],[0,1],[-1,-1],[1,1],[1,-1],[-1,1]]
        for i in range(self.heigh):
            for j in range(self.width):
                if self.map[i,j] == 0:
                    tag = 0
                    for it in offset:
                        if i+it[0] >= self.heigh or j+it[1] >= self.width or i+it[0] < 0 or j+it[1] < 0:
                            continue
                        if self.map[i+it[0],j+it[1]] != 3 and self.map[i+it[0],j+it[1]] != 4:
                            tag += self.map[i+it[0],j+it[1]]
                    if tag:
                        self.map[i,j] = 3

    def isValidRoom(self,r1,r2,c1,c2):
        #檢測有無覆蓋
        for i in range(r1,r2):
            for j in range(c1,c2):
                if self.map[i,j] == 1:
                    return -1
        #檢測有無緊貼房間
        for i in range(r1,r2):
            if self.map[i,c1-1] == 1 or self.map[i,c2+1] == 1:
                return 2
        for i in range(c1,c2):
            if self.map[r1-1,i] == 1 or self.map[r2+1,i] == 1:
                return 2
        return 0

    def aStar(self,p0,p1):
        open_list = []
        close_list = []
        offset = [[-1,0],[0,-1],[1,0],[0,1]]
        f = h = abs(p0[0] - p1[0]) * 10 + abs(p0[1] - p1[1]) * 10
        g = 0

        def isInClose(p):
            for it in close_list:
                if it.value[3] == p:
                    return True
            return False
        def isInOpen(p):
            for it in open_list:
                if it.value[3] == p:
                    return True
            return False
        def findFather(p):
            for it in close_list:
                if it.value[3] == p:
                    return it.value[4]
            return [-1,-1]
        def findInOpen(p):
            for it in open_list:
                if it.value[3] == p:
                    return it
            return None

        open_list.append(Node([f,g,h,p0,[-1,-1]]))
        while open_list:
            #for it in open_list:
            #    print(it.value)
            open_list.sort(key=(lambda x:x.value[0]))
            f_min = open_list[0]
            close_list.append(f_min)
            open_list.remove(f_min)
            for it in offset:
                p2 = [f_min.value[3][0]+it[0], f_min.value[3][1]+it[1]]
                if p2[0] == p1[0] and p2[1] == p1[1]:
                    #找到
                    close_list.append(Node([f,g,h,p2,f_min]))
                    p_father = f_min.value[3]
                    while True:
                        self.map[p_father[0],p_father[1]] = 2
                        p_father = findFather(p_father)
                        if p_father[0] == -1:
                            break
                    self.map[p0[0], p0[1]] = 4
                    return
                if p2[0] < 0 or p2[0] >= self.heigh or p2[1] < 0 or p2[1] >= self.width:
                    continue
                if (self.map[p2[0],p2[1]] != 0 and self.map[p2[0],p2[1]] != 2 and self.map[p2[0],p2[1]] != 4) or isInClose(p2):
                    continue
                h = abs(p2[0] - p1[0]) * 10 + abs(p2[1] - p1[1]) * 10
                g = f_min.value[1] + 10
                f = h + g
                if not isInOpen(p2):
                    open_list.append(Node([f,g,h,p2,f_min.value[3]]))
                else:
                    #比較最小的G 值
                    temp = findInOpen(p2)
                    if g < temp.value[1]:
                        open_list.remove(temp)
                        open_list.append(Node([f,g,h,p2,f_min.value[3]]))

    def printMap(self):
        for i in range(self.heigh):
            for j in range(self.width):
                print(int(self.map[i,j]),end='')
            print()

    def printRoom(self):
        for r in self.room:
            r.info()

if __name__ == '__main__':
    map = Map()
    map.printMap()

可視化一下

地牢

總結 

到此這篇關于python實現(xiàn)地牢迷宮生成的文章就介紹到這了,更多相關python地牢迷宮生成內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家!

相關文章

  • Caffe均值文件mean.binaryproto轉mean.npy的方法

    Caffe均值文件mean.binaryproto轉mean.npy的方法

    今天小編就為大家分享一篇Caffe均值文件mean.binaryproto轉mean.npy的方法,具有很好的參考價值,希望對大家有所幫助。一起跟隨小編過來看看吧
    2018-07-07
  • 如何利用python處理原始音頻數(shù)據(jù)

    如何利用python處理原始音頻數(shù)據(jù)

    這篇文章主要介紹了如何利用python處理原始音頻數(shù)據(jù),文章以audioop的相關資料展開內容,audioop是python標準庫中用于處理原始音頻數(shù)據(jù)的模塊,封裝了一些便捷的編碼轉換函數(shù)。下文詳細內容,需要的朋友可以參考以下
    2022-01-01
  • python中getattr函數(shù)使用方法 getattr實現(xiàn)工廠模式

    python中getattr函數(shù)使用方法 getattr實現(xiàn)工廠模式

    這篇文章主要介紹了python中getattr()這個函數(shù)的一些用法,大家參考使用吧
    2014-01-01
  • 重命名批處理python腳本

    重命名批處理python腳本

    師兄采集的視網(wǎng)膜圖像放在一個文件夾下,由于分類十分混亂,因此出現(xiàn)了一個文件多次出現(xiàn)的情況,因此讓我寫了個腳本
    2013-04-04
  • 詳解pycharm自動import所需的庫的操作方法

    詳解pycharm自動import所需的庫的操作方法

    這篇文章主要介紹了pycharm自動import所需的庫的操作方法,本文通過圖文并茂的形式給大家介紹的非常詳細,對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下
    2020-11-11
  • pandas中query()用法小結

    pandas中query()用法小結

    query()方法是一個功能強大的函數(shù),允許用戶通過字符串表達式來篩選DataFrame中的數(shù)據(jù),本文就來介紹一下pandas中query()用法,感興趣的可以了解一下
    2024-03-03
  • Python使用CRC實現(xiàn)圖片去重

    Python使用CRC實現(xiàn)圖片去重

    這篇文章主要為大家詳細介紹了Python如何使用CRC實現(xiàn)圖片去重功能,文中的示例代碼講解詳細,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學習一下
    2023-10-10
  • python利用dlib獲取人臉的68個landmark

    python利用dlib獲取人臉的68個landmark

    這篇文章主要介紹了python利用dlib獲取人臉的68個landmark,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
    2019-11-11
  • python從gbff文件中直接提取cds序列

    python從gbff文件中直接提取cds序列

    這篇文章主要為大家介紹了python從gbff文件中直接提取cds序列示例詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪
    2022-07-07
  • Keras中 ImageDataGenerator函數(shù)的參數(shù)用法

    Keras中 ImageDataGenerator函數(shù)的參數(shù)用法

    這篇文章主要介紹了Keras中 ImageDataGenerator函數(shù)的參數(shù)用法,具有很好的參考價值,希望對大家有所幫助。一起跟隨小編過來看看吧
    2020-07-07

最新評論

贺兰县| 长泰县| 靖江市| 嵊州市| 阜新| 陆川县| 获嘉县| 漳平市| 九台市| 婺源县| 阜宁县| 锡林浩特市| 黄陵县| 双峰县| 本溪| 平度市| 炎陵县| 教育| 宜昌市| 探索| 安吉县| 娄烦县| 镇赉县| 卓尼县| 九江县| 昆明市| 开远市| 崇明县| 五华县| 祁东县| 娄底市| 莱芜市| 安庆市| 枣阳市| 东台市| 商河县| 虞城县| 仪征市| 满洲里市| 山东省| 阿巴嘎旗|