title: I can't turn my perlin noise map generator into a pygame tilemap for my game
body: <p>I started off by generating a tilemap using this method:</p>
  
  <pre><code>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 &gt;= 3 and randomNumber &lt;= 14:
              tile = tilesettings.GRASS
          else:
              tile = tilesettings.DIRT
          tilesettings.tilemap[rw][cl] = tile
  </code></pre>
  
  <p>The problem with this is that it merely generated a map that was just randomly chosen tiles, and didn't generate a map that resembled a realistic island shape. </p>
  
  <p>So I then decided to use Perlin noise to generate random island shapes like this:
  <a href="https://i.stack.imgur.com/UEo7l.png" rel="nofollow noreferrer">A randomly generated island with Perlin noise</a>           </p>
  
  <p>This is the section of code which generates the noise:</p>
  
  <pre><code>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] &lt; -0.05:
                      color_world[i][j] = blue
                  elif world[i][j] &lt; 0:
                      color_world[i][j] = beach
                  elif world[i][j] &lt; .20:
                      color_world[i][j] = green
                  elif world[i][j] &lt; 0.35:
                      color_world[i][j] = mountain
                  elif world[i][j] &lt; 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 &lt;= 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] &gt; 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] &gt; 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]
  </code></pre>
  
  <p>This is the part of the code which I tried to make it so that it set the tiles in the tilemap to the right tiles.  </p>
  
  <pre><code>    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] &lt; threshold + 0.05:
                      color_world[i][j] = blue
                      tile = tilesettings.WATER
                  elif world[i][j] &lt; threshold + 0.055:
                      color_world[i][j] = sandy
                      tile = tilesettings.SAND
                  elif world[i][j] &lt; threshold + 0.1:
                      color_world[i][j] = beach
                      tile = tilesettings.SAND
                  elif world[i][j] &lt; threshold + 0.25:
                      color_world[i][j] = green
                      tile = tilesettings.GRASS
                  elif world[i][j] &lt; threshold + 0.6:
                      color_world[i][j] = darkgreen
                      tile = tilesettings.GRASS
                  elif world[i][j] &lt; threshold + 0.7:
                      color_world[i][j] = mountain
                      tile = tilesettings.GRASS
                  elif world[i][j] &lt; 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()
  </code></pre>
  
  <p>The problem I have is that when I run the code, it is extremely laggy, and just displays my character over a screen of water tiles. I did try doing a separate code to set the tiles:</p>
  
  <pre><code>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
  </code></pre>
  
  <p>When I did this though, I got a strange error:</p>
  
  <pre><code>if color_world == blue:
  </code></pre>
  
  <p>ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()</p>
  
  <p>I've been messing around with my code for ages and I can't see what I've done wrong - someone please help it would be greatly appreciated :) </p>
  
  <p>Just a quick update, turns out it isn't rendering just a blue screen because I saw a sand tile rendered so it must be to do with the placement of the player, but it is extremely laggy and unplayable.  </p>