Tiles

Tiles are small squares to compose an image. Below is an image which has 6 x 8 tiles. Each tile has 32 x 32 pixels.

../_images/tmw_desert_spacing.png

The tiles with a 1 pixel separation

import pygame

file = 'tmw_desert_spacing.png'
image = pygame.image.load(file)
rect = image.get_rect()
print(image)

pygame.init()
screen = pygame.display.set_mode(rect.size)

screen.blit(image, rect)
pygame.display.update()

while True:
   for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()

tiles0.py

The code displays the image and writes this to the output console:

<Surface(265x199x32 SW)>

The margin around the image and the separation line is 1 pixel.

  • 8 x 33 + 1 = 265 pixel wide
  • 6 x 33 + 1 = 199 pixel high

tiles1.py

import pygame
from pygame.locals import *

file = 'tmw_desert_spacing.png'

class Game:
    W = 640
    H = 240
    SIZE = W, H

    def __init__(self):
        pygame.init()
        self.screen = pygame.display.set_mode(Game.SIZE)
        pygame.display.set_caption("Pygame Tiled Demo")
        self.running = True

    def run(self):
        while self.running:
            for event in pygame.event.get():
                if event.type == QUIT:
                    self.running = False

                elif event.type == KEYDOWN:
                    if event.key == K_l:
                        self.load_image(file)

        pygame.quit()

    def load_image(self, file):
        self.file = file
        self.image = pygame.image.load(file)
        self.rect = self.image.get_rect()

        self.screen = pygame.display.set_mode(self.rect.size)
        pygame.display.set_caption(f'size:{self.rect.size}')
        self.screen.blit(self.image, self.rect)
        pygame.display.update()

game = Game()
game.run()

Create a Tileset

class Tileset:
    def __init__(self, file, size=(32, 32), margin=1, spacing=1):
        self.file = file
        self.size = size
        self.margin = margin
        self.spacing = spacing
        self.image = pygame.image.load(file)
        self.rect = self.image.get_rect()
        self.tiles = []
        self.load()


    def load(self):

        self.tiles = []
        x0 = y0 = self.margin
        w, h = self.rect.size
        dx = self.size[0] + self.spacing
        dy = self.size[1] + self.spacing
        
        for x in range(x0, w, dx):
            for y in range(y0, h, dy):
                tile = pygame.Surface(self.size)
                tile.blit(self.image, (0, 0), (x, y, *self.size))
                self.tiles.append(tile)

    def __str__(self):
        return f'{self.__class__.__name__} file:{self.file} tile:{self.size}'

Create a Tilemap

class Tilemap:
    def __init__(self, tileset, size=(10, 20), rect=None):
        self.size = size
        self.tileset = tileset
        self.map = np.zeros(size, dtype=int)

        h, w = self.size
        self.image = pygame.Surface((32*w, 32*h))
        if rect:
            self.rect = pygame.Rect(rect)
        else:
            self.rect = self.image.get_rect()

    def render(self):
        m, n = self.map.shape
        for i in range(m):
            for j in range(n):
                tile = self.tileset.tiles[self.map[i, j]]
                self.image.blit(tile, (j*32, i*32))

    def set_zero(self):
        self.map = np.zeros(self.size, dtype=int)
        print(self.map)
        print(self.map.shape)
        self.render()

    def set_random(self):
        n = len(self.tileset.tiles)
        self.map = np.random.randint(n, size=self.size)
        print(self.map)
        self.render()

    def __str__(self):
        return f'{self.__class__.__name__} {self.size}'      

The R key fills the map with random tiles.

../_images/tiles2b.png

The Z key fills the map with zero-index tiles.

../_images/tiles2.png