[PyGame] Common Tasks

[metulburr]

Color Surface
An example of 2 different methods to draw a new color over a surface within pygame

#no other libs requires other than pygame def colorize(image, newColor): """ Create a "colorized" copy of a surface (replaces RGB values with the given color, preserving the per-pixel alphas of original). :param image: Surface to create a colorized copy of :param newColor: RGB color to use (original alpha values are preserved) :return: New colorized Surface instance """ image = image.copy() # zero out RGB values image.fill((0, 0, 0, 255), None, pg.BLEND_RGBA_MULT) # add in new RGB values image.fill(newColor[0:3] + (0,), None, pg.BLEND_RGBA_ADD) return image #requires numpy module to be installed def color_surface(surface, red, green, blue): '''requires numpy module on users end''' arr = pg.surfarray.pixels3d(surface) arr[:,:,0] = red arr[:,:,1] = green arr[:,:,2] = blue

[metulburr]

Resizable Window
Go to the corner of the window and make it smaller

import pygame as pg import random class Ball: def __init__(self, screen_rect): self.screen_rect = screen_rect self.image = pg.Surface([50,50]).convert() self.image.fill((255,0,0)) self.rect = self.image.get_rect() self.speed_init = 10 self.speed = self.speed_init self.set_ball() def set_ball(self): self.vel = [random.choice([-1,1]), 0] self.rect.center = self.screen_rect.center self.true_pos = list(self.rect.center) self.speed = self.speed_init def move(self): if self.rect.left <= 0: self.vel[0] *= -1 elif self.rect.right >= self.screen_rect.right: self.vel[0] *= -1 self.true_pos[0] += self.vel[0] * self.speed #self.true_pos[1] += self.vel[1] * self.speed self.rect.center = self.true_pos def update(self, screen_rect): self.screen_rect = screen_rect self.move() def draw(self, surf): surf.blit(self.image, self.rect) class Control: def __init__(self): self.resolutions = [(300,200), (600,400),(800, 600), (928, 696)] self.render_size = self.resolutions[-1] #largest self.screen = pg.display.set_mode(self.resolutions[-1], pg.RESIZABLE) self.screen_rect = self.screen.get_rect() self.render_surf = pg.Surface(self.render_size).convert() #pg.event.clear(pg.VIDEORESIZE) self.clock = pg.time.Clock() self.done = False self.fps = 60 self.ball = Ball(self.screen_rect) def event_loop(self): for event in pg.event.get(): if event.type == pg.QUIT: self.done = True elif event.type == pg.VIDEORESIZE: self.on_resize(event.size) #pg.event.clear(pg.VIDEORESIZE) def on_resize(self, size): if size == self.screen_rect.size: return res_index = self.resolutions.index(self.screen_rect.size) adjust = 1 if size > self.screen_rect.size else -1 if 0 <= res_index+adjust < len(self.resolutions): new_size = self.resolutions[res_index+adjust] else: new_size = self.screen_rect.size self.screen = pg.display.set_mode(new_size, pg.RESIZABLE) self.screen_rect.size = new_size self.set_scale() def set_scale(self): w_ratio = self.render_size[0]/float(self.screen_rect.w) h_ratio = self.render_size[1]/float(self.screen_rect.h) self.scale = (w_ratio, h_ratio) def update(self): self.ball.update(self.render_surf.get_rect()) #give obj updated screen size def render(self): if self.render_size != self.screen_rect.size: scale_args = (self.render_surf, self.screen_rect.size, self.screen) pg.transform.smoothscale(*scale_args) else: self.screen.blit(self.render_surf, (0, 0)) self.render_surf.fill((255,255,255)) self.ball.draw(self.render_surf) def game_loop(self): while not self.done: self.event_loop() self.update() self.render() pg.display.update() self.clock.tick(self.fps) pg.init() app = Control() app.game_loop() pg.quit()

[metulburr]

Rotate Around a Point
LEFT or RIGHT / A or D keys to move around the point.

import pygame as pg import math class Rotator: def __init__(self, screen_rect): self.radar = screen_rect.center self.radar_len = 100 self.angle = 0 self.image = pg.Surface([25,25]).convert() self.get_pos() self.rect = self.image.get_rect(center=(self.x, self.y)) self.image.fill((255,0,0)) self.speed = 200 def render(self, screen): screen.blit(self.image, self.rect) pg.draw.line(screen, (255,255,255), self.radar, (self.x,self.y), 1) def update(self, seconds): keys = pg.key.get_pressed() self.get_pos() self.rect.center = (self.x, self.y) if keys[pg.K_RIGHT] or keys[pg.K_d]: self.angle -= self.speed * seconds elif keys[pg.K_LEFT] or keys[pg.K_a]: self.angle += self.speed * seconds def get_pos(self): self.x = self.radar[0] + math.cos(math.radians(self.angle)) * self.radar_len self.y = self.radar[1] + math.sin(math.radians(self.angle)) * self.radar_len if __name__ == '__main__': running = True pg.init() screen = pg.display.set_mode((600,400)) screen_rect = screen.get_rect() rotator = Rotator(screen_rect) clock = pg.time.Clock() seconds = 0 while running: screen.fill((0,0,0)) for event in pg.event.get(): if event.type == pg.QUIT: running = False elif event.type == pg.MOUSEBUTTONDOWN: rotator.radar = pg.mouse.get_pos() rotator.update(seconds) rotator.render(screen) pg.display.set_caption('x,y:{} {}'.format(rotator.x, rotator.y)) pg.display.update() milli = clock.tick(60) seconds = milli / 1000.0

[metulburr]

Draw Shape to Surface
Here is an example of a pygame rect drawn to a custom surface. You can only see the half circle because its positioned at the bottom of that surface. As for the surface not showing, it has disappeared in the background because its color is set as the color key to hide. This can be useful to create odd shapes. An example would be trying to follow a clickable or mouse highlight pattern from a background for example.

import pygame pygame.init() screen = pygame.display.set_mode((800,600)) screen_rect = screen.get_rect() circle = pygame.Surface([500,300]).convert() circle.fill((255,0,255)) #make abnormal bg color circle.set_colorkey((255,0,255)) #hide bg pygame.draw.circle(circle, (200,200,0), screen_rect.center, 25, 0) circle_rect = circle.get_rect() running = True while running: screen.fill((255,255,255)) for event in pygame.event.get(): if event.type == pygame.QUIT: running = False keys = pygame.key.get_pressed() if keys[pygame.K_RIGHT]: circle_rect.x += 1 elif keys[pygame.K_LEFT]: circle_rect.x -= 1 screen.blit(circle, circle_rect) pygame.display.update()

[metulburr]

Basic button class example

import pygame as pg pg.init() def flip_color(): global bg_white bg_white = not bg_white class Button: def __init__(self, rect, command): self.color = (255,0,0) self.rect = pg.Rect(rect) self.image = pg.Surface(self.rect.size) self.image.fill(self.color) self.command = command def render(self, screen): screen.blit(self.image, self.rect) def get_event(self, event): if event.type == pg.MOUSEBUTTONDOWN and event.button == 1: if self.rect.collidepoint(pg.mouse.get_pos()): self.command() screen = pg.display.set_mode((800,600)) screen_rect = screen.get_rect() running = True bg_white = False btn = Button((10,10,105,25), flip_color) while running: for event in pg.event.get(): if event.type == pg.QUIT: running = False btn.get_event(event) if bg_white: screen.fill((255,255,255)) else: screen.fill((0,0,0)) btn.render(screen) pg.display.update()

[metulburr]

Separate objects apart sequentailly

import pygame as pg class Field: width = 100 height = 100 buffer_right = 10 bugger_top = 10 def __init__(self, position): self.color = (255,0,0) self.image = pg.Surface([self.width, self.height]).convert() self.image.fill(self.color) self.rect = self.image.get_rect(topleft=position) def draw(self, screen): screen.blit(self.image, self.rect) def set_fields(): fields = [] for row in range(4): for col in range(4): #number in row * its width + (buffer), number in col * its hieght + (buffer) field = Field((row*Field.width+(row*Field.buffer_right), col*Field.height+(col*Field.bugger_top))) fields.append(field) return fields pg.init() screen = pg.display.set_mode((800,600)) screen_rect = screen.get_rect() done = False fields = set_fields() while not done: screen.fill((0,0,0)) for event in pg.event.get(): if event.type == pg.QUIT: done = True for field in fields: field.draw(screen) pg.display.update()

[metulburr]

Particle Effects
simple particle effects

fire particle effect

import pygame as pg import traceback from random import uniform, choice vec = pg.math.Vector2 vec3 = pg.math.Vector3 BLACK = (0, 0, 0) WHITE = (255, 255, 255) class Custom_color(pg.Color): ''' This is an attempt of creating an object that can be used as a pygame.Color, but also has vector operations. ''' def __init__(self, color): self.vec = vec3(color[0:3]) super().__init__(int(color[0]), int(color[1]), int(color[2])) def update(self): self.r = int(self.vec.x) self.g = int(self.vec.y) self.b = int(self.vec.z) class Game: def __init__(self): pg.init() self.clock = pg.time.Clock() self.screen = pg.display.set_mode((800, 600)) self.screen_rect = self.screen.get_rect() self.fps = 60 self.all_sprites = pg.sprite.Group() try: p_image_strip = pg.image.load('fire_particles_strip.png' ).convert_alpha() self.p_images = [p_image_strip.subsurface(((i * 40, 0), (40, 40))) for i in range(4)] except: # if loading the image fails, create some dummy images self.p_images = [] for i in range(4): surf = pg.Surface((40, 40), pg.SRCALPHA) surf.fill(WHITE) self.p_images.append(surf) def create_particle(self, pos): # create a list of colors for a gradient over time # this looks something like a fire: colors = [ (255, 255, 255), (255, 200, 0), (200, 50, 0), (60, 60, 80) ] # instantiate a paticle with a reference to the particle images # and the list of colors Particle(self, pos, self.p_images, colors) def update(self): # create particles every frame self.create_particle((self.screen_rect.w / 4, self.screen_rect.h - 30)) self.create_particle((self.screen_rect.w / 4 * 3, self.screen_rect.h - 30)) self.all_sprites.update() def draw(self): self.screen.fill(BLACK) for s in self.all_sprites: s.draw(self.screen) pg.display.update() def run(self): self.running = True while self.running: self.clock.tick(self.fps) caption = 'FPS: {} | number of particles: {}'.format( int(self.clock.get_fps()), len(self.all_sprites)) pg.display.set_caption(caption) for event in pg.event.get(): if event.type == pg.QUIT: self.running = False self.update() self.draw() pg.quit() class Particle(pg.sprite.Sprite): def __init__(self, game, pos, images=None, colors=[]): super().__init__() self.game = game self.game.all_sprites.add(self) if images: # if initialized with a list of images, choose one at random self.original_image = choice(self.game.p_images).copy() self.image = self.original_image.copy() self.rect = self.image.get_rect() else: # if not initialized with images, draw a circle self.image = pg.Surface((20, 20)) self.image.set_colorkey((0, 0, 0)) self.rect = self.image.get_rect() pg.draw.ellipse(self.image, (255, 255, 255), self.rect) # make a self.colors = [vec3(x) for x in colors] self.color = Custom_color(self.colors[0]) self.alpha = 255 if len(self.colors) > 1: self.prev_color = vec3(self.colors[0]) self.target_color = vec3(self.colors[1]) self.target_index = 1 self.lerp_dist = 0 self.lerp_speed = 0.05 self.pos = vec(pos) self.rect.topleft = self.pos # set random velocity vector self.vel = vec(uniform(-1, 1), uniform(-5, -1)) def update(self): # add velocity to position self.pos += self.vel # update rect self.rect.topleft = self.pos # reduce alpha gradually self.alpha -= 2 if self.alpha < 0: self.kill() else: self.color.a = int(self.alpha) def draw(self, screen): self.blend_colors() self.image = self.original_image.copy() self.image.fill(self.color, None, pg.BLEND_RGBA_MULT) screen.blit(self.image, self.pos) def blend_colors(self): if len(self.colors) > 1: if self.lerp_dist < 1: # linear interpolation between previous and target color self.color.vec = self.prev_color.lerp(self.target_color, self.lerp_dist) self.color.update() self.lerp_dist += self.lerp_speed else: # if lerp distance reached 1, set the next target color self.target_index += 1 if self.target_index < len(self.colors): self.prev_color = self.target_color self.target_color = self.colors[self.target_index] self.lerp_dist = 0 if __name__ == '__main__': try: g = Game() g.run() except Exception: traceback.print_exc() pg.quit()

[metulburr]

RPG map making and loading
Orthogonal map (top-down) loading from spritesheet. This repo shows a small example of using PyTMX to load tmx files generated from Tiled Editor.

Tiled is a map editor to easily place your sprites by hand and allocated collision positions, etc. PyTMX loads these maps. The repo provided includes PyTMX with it and has a predefined tmx map. It shows a small simple example of these libraries combined together to make a map and a character colliding with it.

main.py is file to run in this directory. It is the main game loop and loads the level created and player to move around. As coded: the player is colored red in grass, and blue when a collision is detected when it would be out of bounds.

[metulburr]

Basic multiline text

import pygame as pg import pygame.freetype def main(): pg.init() screen = pg.display.set_mode((400, 600)) clock = pg.time.Clock() # define the font size and spacing fontsize = 36 margin_x = 10 # pixels from the left margin_y = 10 # pixels from the top spacing_y = 4 # pixels between lines # initialize a font (Arial) font = pygame.freetype.SysFont('Arial', fontsize) # a sample string with line breaks sample_text = ('This is the first line.\n' + 'This is the second line.\n' + 'This is the third line.\n\n' + 'This is the fifth line.') # create a list from the string and render it to surfaces rendered_fonts =[] for i, line in enumerate(sample_text.split('\n')): txt_surf, txt_rect = font.render(line, pg.Color('black')) # set the text rect to a position based on the line number and # spacing parameters txt_rect.topleft = (margin_x, margin_y + i * (fontsize + spacing_y)) rendered_fonts.append((txt_surf, txt_rect)) # main loop running = True while running: for event in pg.event.get(): if event.type == pg.QUIT: running = False # draw the text screen.fill(pg.Color('white')) for txt_surf, txt_rect in rendered_fonts: screen.blit(txt_surf, txt_rect) clock.tick(60) pg.display.flip() pg.quit() if __name__ == '__main__': main()

[metulburr]

Space Invaders (player and player's shots)

import pygame as pg pg.init() class Laser: def __init__(self, loc): self.image = pg.Surface((5,40)).convert() self.image.fill((255,255,0)) self.rect = self.image.get_rect(center=loc) self.speed = 5 def update(self): self.rect.y -= self.speed def render(self, surf): surf.blit(self.image, self.rect) class Player: def __init__(self, screen_rect): self.screen_rect = screen_rect #self.image = pg.image.load('spaceship.png').convert() self.image = pg.Surface([50,50]) #to avoid loading an image self.image.fill((0,0,255)) #to avoid loading an image #self.image.set_colorkey((255,0,255)) #if loading an image, settings colorkey for it self.transformed_image = pg.transform.rotate(self.image, 180) #if image, rotate it start_buffer = 300 self.rect = self.image.get_rect( center=(screen_rect.centerx, screen_rect.centery + start_buffer) ) self.dx = 300 self.lasers = [] def get_event(self, event): if event.type == pg.KEYDOWN: if event.key == pg.K_SPACE: self.lasers.append(Laser(self.rect.center)) def update(self, keys, dt): self.rect.clamp_ip(self.screen_rect) if keys[pg.K_LEFT]: self.rect.x -= self.dx * dt elif keys[pg.K_RIGHT]: self.rect.x += self.dx * dt for laser in self.lasers: laser.update() def draw(self, surf): for laser in self.lasers: laser.render(surf) surf.blit(self.transformed_image, self.rect) screen = pg.display.set_mode((800,600)) screen_rect = screen.get_rect() player = Player(screen_rect) clock = pg.time.Clock() done = False while not done: keys = pg.key.get_pressed() for event in pg.event.get(): if event.type == pg.QUIT: done = True player.get_event(event) screen.fill((0,0,0)) delta_time = clock.tick(60)/1000.0 player.update(keys, delta_time) player.draw(screen) pg.display.update()