我不能把我的柏林噪声贴图生成器变成我的游戏的pygame tilemap

Question

我首先使用以下方法生成tilemap：

for rw in range(tilesettings.mapheight):
    for cl in range(tilesettings.mapwidth):
        randomNumber = random.randint(0,15)
        if randomNumber == 0:
            tile = tilesettings.COAL
        elif randomNumber == 1 or randomNumber == 2:
            tile = tilesettings.WATER
        elif randomNumber >= 3 and randomNumber <= 14:
            tile = tilesettings.GRASS
        else:
            tile = tilesettings.DIRT
        tilesettings.tilemap[rw][cl] = tile

问题是它只生成了一个随机选择的图块，而没有生成一个类似于真实岛屿形状的图块。你知道吗

所以我决定用柏林噪声来生成随机的岛屿形状，像这样： A randomly generated island with Perlin noise

这是产生噪声的代码部分：

import pygame, sys
import noise
import numpy as np
from scipy.misc import toimage
from settings import Settings
from tilemap import Tilemap
from player import Player
from cursor import Cursor
from biome import Biome
from axe import Axe
import game_functions as gf
import random

def run_game():
    tilesettings = Tilemap()

    colours = {
        tilesettings.DIRT: tilesettings.BROWN,
        tilesettings.GRASS: tilesettings.GREEN,
        tilesettings.WATER: tilesettings.BLUE,
        tilesettings.COAL: tilesettings.BLACK,
        tilesettings.SAND : tilesettings.SAND,
        tilesettings.STONE: tilesettings.GREY,
        tilesettings.SNOW: tilesettings.WHITE,
    }

    resources = [tilesettings.DIRT, tilesettings.GRASS, 
tilesettings.WATER, tilesettings.COAL]
    shape = (500, 500)
    scale = 300
    octaves = 6
    persistence = 0.5
    lacunarity = 2.0
    seed = np.random.randint(0, 100)
    world = np.zeros(shape)
    for i in range(shape[0]):
        for j in range(shape[1]):
            world[i][j] = noise.pnoise2(i / scale,
                                        j / scale,
                                        octaves=octaves,
                                        persistence=persistence,
                                        lacunarity=lacunarity,
                                        repeatx=1024,
                                        repeaty=1024,
                                        base=seed)

    blue = [65, 105, 225]
    green = [34, 139, 34]
    beach = [238, 214, 175]
    snow = [255, 250, 250]
    mountain = [139, 137, 137]
    def add_color(world):
        color_world = np.zeros(world.shape + (3,))
        for i in range(shape[0]):
            for j in range(shape[1]):
                if world[i][j] < -0.05:
                    color_world[i][j] = blue
                elif world[i][j] < 0:
                    color_world[i][j] = beach
                elif world[i][j] < .20:
                    color_world[i][j] = green
                elif world[i][j] < 0.35:
                    color_world[i][j] = mountain
                elif world[i][j] < 1.0:
                    color_world[i][j] = snow

        return color_world

    color_world = add_color(world)
    a, b = shape[0] / 2, shape[1] / 2
    n = 1024
    r = 125
    y, x = np.ogrid[-a:n - a, -b:n - b]
    # creates a mask with True False values
    # at indices
    mask = x ** 2 + y ** 2 <= r ** 2

    black = [0, 0, 0]
    island_world = np.zeros_like(color_world)

    for i in range(shape[0]):
        for j in range(shape[1]):
            if mask[i][j]:
                island_world[i][j] = color_world[i][j]
            else:
                island_world[i][j] = black
    import math
    center_x, center_y = shape[1] // 2, shape[0] // 2
    circle_grad = np.zeros_like(world)
    for y in range(world.shape[0]):
        for x in range(world.shape[1]):
            distx = abs(x - center_x)
            disty = abs(y - center_y)
            dist = math.sqrt(distx * distx + disty * disty)
            circle_grad[y][x] = dist
    # get it between -1 and 1
    max_grad = np.max(circle_grad)
    circle_grad = circle_grad / max_grad
    circle_grad -= 0.5
    circle_grad *= 2.0
    circle_grad = -circle_grad

    # shrink gradient
    for y in range(world.shape[0]):
        for x in range(world.shape[1]):
            if circle_grad[y][x] > 0:
                circle_grad[y][x] *= 20

    # get it between 0 and 1
    max_grad = np.max(circle_grad)
    circle_grad = circle_grad / max_grad

    world_noise = np.zeros_like(world)

    for i in range(shape[0]):
        for j in range(shape[1]):
            world_noise[i][j] = (world[i][j] * circle_grad[i][j])
            if world_noise[i][j] > 0:
                world_noise[i][j] *= 20

    # get it between 0 and 1
    max_grad = np.max(world_noise)
    world_noise = world_noise / max_grad

    lightblue = [0, 191, 255]
    blue = [65, 105, 225]
    green = [34, 139, 34]
    darkgreen = [0, 100, 0]
    sandy = [210, 180, 140]
    beach = [238, 214, 175]
    snow = [255, 250, 250]
    mountain = [139, 137, 137]

这是代码的一部分，我试图使它，使它设置在tilemap瓷砖到正确的瓷砖。你知道吗

    threshold = 0.005
    def add_color2(world):
        color_world = np.zeros(world.shape + (3,))
        for i in range(shape[0]):
            for j in range(shape[1]):
                if world[i][j] < threshold + 0.05:
                    color_world[i][j] = blue
                    tile = tilesettings.WATER
                elif world[i][j] < threshold + 0.055:
                    color_world[i][j] = sandy
                    tile = tilesettings.SAND
                elif world[i][j] < threshold + 0.1:
                    color_world[i][j] = beach
                    tile = tilesettings.SAND
                elif world[i][j] < threshold + 0.25:
                    color_world[i][j] = green
                    tile = tilesettings.GRASS
                elif world[i][j] < threshold + 0.6:
                    color_world[i][j] = darkgreen
                    tile = tilesettings.GRASS
                elif world[i][j] < threshold + 0.7:
                    color_world[i][j] = mountain
                    tile = tilesettings.GRASS
                elif world[i][j] < threshold + 1.0:
                    color_world[i][j] = snow
                    tile = tilesettings.SNOW
                tilesettings.tilemap[i][j] = tile

        return color_world
    island_world_grad = add_color2(world_noise)
    toimage(island_world_grad).show()

    pygame.init()
    ai_settings = Settings()
    screen = pygame.display.set_mode((ai_settings.screen_width, 
    ai_settings.screen_height))
    pygame.mouse.set_visible(True)

    player = Player(ai_settings, screen, tilesettings)
    cursor = Cursor(ai_settings, screen, tilesettings, player)

    axe = Axe(ai_settings, screen, tilesettings, cursor)
    while True:
        gf.check_events(ai_settings, screen, player, cursor, axe)
        player.update()
        cursor.update()
        gf.update_screen(ai_settings, screen, player)
        for row in range (tilesettings.mapheight):
            for column in range(tilesettings.mapwidth):
                pygame.draw.rect(screen, 
colours[tilesettings.tilemap[row][column]],(column* 
tilesettings.tilesize, row* tilesettings.tilesize, 
tilesettings.tilesize, tilesettings.tilesize))

        biome.update(screen)
        player.blitme()
        axe.changeimage()
        axe.blitme()
        pygame.display.update()

run_game()

我遇到的问题是，当我运行代码时，它非常滞后，只在一个水砖屏幕上显示我的角色。我试过用一个单独的代码来设置瓷砖：

color_world = np.zeros(world.shape + (3,))
for rw in range (shape[0]):
    for cl in range(shape[1]):
        if color_world == blue:
            tile = tilesettings.WATER
        elif color_world == sandy:
            tile = tilesettings.SAND
        elif color_world == beach:
            tile = tilesettings.SAND
        elif color_world == green:
            tile = tilesettings.GREEN
        elif color_world == darkgreen:
            tile = tilesettings.GRASS
        elif color_world == mountain:
            tile = tilesettings.STONE
        elif color_world == snow:
            tile = tilesettings.SNOW
        tilesettings.tilemap[rw][cl] = tile

当我这么做的时候，我犯了一个奇怪的错误：

if color_world == blue:

ValueError:包含多个元素的数组的真值不明确。使用a.any（）或a.all（）

我一直在乱搞我的代码多年，我看不出我做错了什么-有人请帮助它将不胜感激：）

只是一个快速更新，原来它不是渲染只是一个蓝屏，因为我看到了一个沙瓦渲染，所以它必须与球员的位置，但它是非常滞后和无法播放。你知道吗

Answer 1

很难回答，因为你的答案缺乏一个可运行的例子，但有两件事：

if color_world == blue:

你在这里出错并不奇怪。错误消息会告诉您发生了什么问题：

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

您尝试检查color_world是否等于blue，但是color_world是一个多维列表，而blue是一个整数列表，因此基本上Python现在知道要做什么了。我想这条线应该是

if color_world[i][j] == blue

---

此外，请删除此部分：

 for row in range (tilesettings.mapheight):
            for column in range(tilesettings.mapwidth):
                pygame.draw.rect(screen, 
colours[tilesettings.tilemap[row][column]],(column* 
tilesettings.tilesize, row* tilesettings.tilesize, 
tilesettings.tilesize, tilesettings.tilesize))

离开你的主回路。你知道吗

在此之前运行一次并将背景绘制到新的Surface，然后在主循环中使用新的Surface，如下所示：

...
background = pygame.Surface((tilesettings.mapwidth*tilesettings.tilesize, tilesettings.mapheight*tilesettings.tilesize))
 for row in range (tilesettings.mapheight):
            for column in range(tilesettings.mapwidth):
                pygame.draw.rect(background , 
                    colours[tilesettings.tilemap[row][column]],(column* 
                    tilesettings.tilesize, row* tilesettings.tilesize, 
                    tilesettings.tilesize, tilesettings.tilesize))
...
while True:
    gf.check_events(ai_settings, screen, player, cursor, axe)
    player.update()
    cursor.update()
    gf.update_screen(ai_settings, screen, player)
    screen.blit(background, (0, 0))
    biome.update(screen)
    player.blitme()
    axe.changeimage()
    axe.blitme()
    pygame.display.update()

因此，您不必每秒多次循环tilesettings.tilemap中的每一行和每一列。你会明白的。你知道吗

这将有助于提高性能。你知道吗