def getCavernTileMap(self):
TileMap = []
#chance = 0.6
map, caverns = CellularAutomata.generateMap(self.cellwidth,
self.cellheight,
chance=0.6,
steps=6,
birthLimit=3,
deathLimit=4)
for rows in range(0, len(map)):
row = []
for columns in range(0, len(map[0])):
if not map[rows][columns]:
row.append(
Tiles.Tile((columns, rows),
self.tileSheet.returnTile(0, 0), False))
else:
#row.append(Tiles.AnimTile((columns,rows), self.animTileSheet,True,0,3,10))
row.append(
Tiles.Tile((columns, rows),
self.tileSheet.returnTile(2, 0), True))
TileMap.append(row)
#Adds the tile that goes to next level
EndLocation = choice(caverns[-2])
TileMap[EndLocation[0]][EndLocation[1]] = Tiles.LevelTile(
(EndLocation[1], EndLocation[0]), self.tileSheet.returnTile(3, 0),
False)
return TileMap, caverns
def __getTileMap(self, map):
tiles = []
#Could probably do this using map or filter or replace, one of those functions
for y in range(len(map)):
row = []
for x in range(len(map[0])):
if map[y][x]:
row.append(
Tiles.Tile(gridPos=(x, y),
collision=False,
sprite=self.spritesheet.returnSprite(0, 0)))
else:
row.append(
Tiles.Tile(gridPos=(x, y),
collision=True,
sprite=self.spritesheet.returnSprite(1, 0)))
tiles.append(row)
return tiles
def generateCellularAutomata(width: int = 40,
height: int = 30,
chance: float = 0.65,
steps: int = 2,
birthLimit: int = 3,
deathLimit: int = 4) -> list:
'''Returns a tilemap from the CellularAutomata method'''
arr, caverns = CellularAutomata.driver(width, height, chance, steps,
birthLimit, deathLimit)
tileMap = []
# Iterates over the 2D list returned by the cellauto algorithm
# and places a non collidable tile at a true value, and a collidable
# tile at the false values
for y in range(0, len(arr)):
row = []
for x in range(0, len(arr[0])):
if arr[y][x] == True:
row.append(
Tiles.Tile(gridPos=(x, y),
collision=False,
sprite=spritesheet.returnSprite(0, 0)))
elif arr[y][x] == False:
row.append(
Tiles.Tile(gridPos=(x, y),
collision=True,
sprite=spritesheet.returnSprite(1, 0)))
'''
elif arr[y][x] == 'corridoor':
row.append(Tiles.Tile(gridPos=(x, y),
collision=False,
sprite=spritesheet.returnSprite(0, 2)))
'''
tileMap.append(row)
y, x = choice(caverns[-1])
tileMap[y][x] = Tiles.LevelTile(gridPos=(x, y),
sprite=spritesheet.returnSprite(0, 2))
return tileMap, caverns
def create_map():
#Create The Map
#Global Variables Created
global continent_map
continent_map = [[Tiles.Tile("Ocean") for y in range(MAP_HEIGHT)]
for x in range(MAP_WIDTH)]
global cities
cities = []
#Generate Contents in Map
generate_land()
generate_cities()
def create_tiles(self):
"""
Create tiles from the good sized of image.
Return with a Tiles object, which has a list of the image tiles - Tile object.
"""
tiles = Tiles.Tiles(grid=self.grid)
for row in range(self.grid):
for col in range(self.grid):
x0 = col * self.tile_size
y0 = row * self.tile_size
x1 = x0 + self.tile_size
y1 = y0 + self.tile_size
tile_image = ImageTk.PhotoImage(
self.image.crop((x0, y0, x1, y1)))
tile = Tiles.Tile(self, tile_image, (row, col))
tiles.add(tile)
tiles.set_gap(-1)
return tiles
def render(self, screen):
left = self.left
top = self.top
self.max_width = len(self.board[0])
self.max_height = len(self.board)
for y in range(self.max_height):
for x in range(self.max_width):
if (x != self.max_width - 1 or y != 0) and (
x != 0 or y != self.max_height - 1) and self.no_tiles:
Tiles.Tile(left, top, self.tile_sprites)
pygame.draw.rect(screen, color('brown'),
(left, top, self.cell_size, self.cell_size),
1)
left += self.cell_size
top += self.cell_size
left = self.left
pygame.draw.rect(screen, color('brown'),
(self.left, self.top, self.cell_size * self.width,
self.cell_size * self.height), 2)
self.no_tiles = False
def render(self, screen):
left = self.left
top = self.top
self.max_width = len(self.board[0])
self.max_height = len(self.board)
for y in range(self.max_height):
for x in range(self.max_width):
if (x != self.max_width - 1 or y != 0) and (
x != 0 or y != self.max_height - 1) and self.no_tiles:
Tiles.Tile(left, top, self.tile_sprites)
elif x == self.max_width - 1 and y == 0:
pygame.draw.rect(
screen, color('orange'),
(left, top, self.cell_size, self.cell_size), 0)
if not game.orange_moved:
screen.blit(
GetImage("janitor_orange1.png", (76, 76),
colorkey=-1).load_image(), (left, top))
elif x == 0 and y == self.max_height - 1:
pygame.draw.rect(
screen, color('aquamarine3'),
(left, top, self.cell_size, self.cell_size), 0)
if not game.blue_moved:
screen.blit(
GetImage("janitor_blue1.png", (76, 76),
colorkey=-1).load_image(), (left, top))
pygame.draw.rect(screen, color('brown'),
(left, top, self.cell_size, self.cell_size),
1)
left += self.cell_size
top += self.cell_size
left = self.left
pygame.draw.rect(screen, color('brown'),
(self.left, self.top, self.cell_size * self.width,
self.cell_size * self.height), 2)
self.no_tiles = False
Anyone can buy rights to use the source code in any commercial products by messaging the author;
"""
#Import section
import Tiles
from time import sleep
from random import choice
from random import randrange
#global variables:
#Tiles:
player=Tiles.PlayerTile('8')
grass=Tiles.Tile(True)
grass.setGraphic('"')
wall=Tiles.Tile(False)
wall.setGraphic('[]')
water=Tiles.Tile(False)
water.setGraphic('~')
road=Tiles.Tile(True)
road.setGraphic('::')
start=Tiles.EventTile(True)
start.setGraphic('E')
end=Tiles.EventTile(False)
end.setGraphic('|=|')
tree=Tiles.Tile(False)
tree.setGraphic(chr(134))
grate=Tiles.Tile(False)
grate.setGraphic('#')
def getTileMap(self):
mapPath = Main.getPath(self.path)
self.map = Img.open(mapPath)
#Gets a list of all the pixel data in the img in a 1 dimensional list
self.map = self.map.convert("RGB")
pixels = list(self.map.getdata())
#Sets the size so that the pixel list can be turned into a 2 dimensional array like a grid
width, height = self.map.size
pixels = [pixels[i * width:(i + 1) * width] for i in range(height)]
self.pixels = pixels
self.map.close()
TileMap = []
#columns then rows for 2D lists
for y in range(0, len(self.pixels)):
row = []
for x in range(0, len(self.pixels[0])):
#Tile format (Position, sprite, collision)
#AnimTile format (gridPos, spritesheet,collision, animRow, NoOfFrames, timePeriod)
#DamageTile format (gridPos, spritesheet, collision, animRow, NoOfFrames, timePeriod, damageValue)
#TransportTile format (gridPos, sprite, collision, destination)
#BLACK : Stone
if self.pixels[y][x] == (0, 0, 0):
row.append(
Tiles.Tile((x, y), self.tileSheet.returnTile(2, 0),
True))
#RED : lava or generic damageTile
elif self.pixels[y][x] == (255, 0, 0):
row.append(
Tiles.DangerTileAnim((x, y),
self.animTileSheet,
False,
1,
3,
20,
1,
cost=100))
#GREEN : grass
elif self.pixels[y][x] == (0, 255, 0):
row.append(
Tiles.Tile((x, y), self.tileSheet.returnTile(0, 0),
False))
#BLUE : water
elif self.pixels[y][x] == (0, 0, 255):
row.append(
Tiles.AnimTile((x, y), self.animTileSheet, True, 0, 3,
10))
#YELLOW : Flowers
elif self.pixels[y][x] == (255, 255, 0):
row.append(
Tiles.Tile((x, y), self.tileSheet.returnTile(1, 0),
False))
#MAGENTA : Transport
elif self.pixels[y][x] == (255, 0, 255):
path = Main.getPath("res/map1.png")
row.append(
Tiles.TransportTile((x, y),
self.tileSheet.returnTile(3, 0),
False, path))
#CYAN : ?
elif self.pixels[y][x] == (0, 255, 255):
path = Main.getPath("res/map2.png")
row.append(
Tiles.TransportTile((x, y),
self.tileSheet.returnTile(3, 0),
False, path))
#WHITE : ?
elif self.pixels[y][x] == (255, 255, 255):
pass
else:
print("Colour, ", self.pixels[x][y],
"has no defining Tile")
TileMap.append(row)
return TileMap
