def set_rgba_masks(): """ This rebuilds the sample surfaces, to ones that use the given masks. """ # Annoyingly, the value for the big mask seems to vary from # platform to platform. So we read it out of a surface. global sample_alpha global sample_noalpha # Create a sample surface. s = pygame.Surface((10, 10), 0, 32) sample_alpha = s.convert_alpha() # Sort the components by absolute value. masks = list(sample_alpha.get_masks()) masks.sort(key=abs) # Choose the masks. if sys.byteorder == 'big': masks = (masks[3], masks[2], masks[1], masks[0]) else: masks = (masks[0], masks[1], masks[2], masks[3]) # Create the sample surface. sample_alpha = pygame.Surface((10, 10), 0, 32, masks) sample_noalpha = pygame.Surface((10, 10), 0, 32, masks[:3] + (0, )) renpy.audio.audio.sample_surfaces(sample_noalpha, sample_alpha)
def __init__(self, size, offset, border=1, border_color='#FFFFFF', color='#111111', protected=False): super().__init__() self.protected = protected self.is_active = False self.text = '' self.font = pygame.font.Font('./fonts/space_invaders.ttf', 24) self.text_label = self.font.render(self.text, 1, (255, 255, 255)) self.border = border self.bottom_image = pygame.Surface(size) self.bottom_image.fill(pygame.Color(border_color)) width, height = size self.top_image = pygame.Surface( (width - 2 * border, height - 2 * border)) self.top_image.fill(pygame.Color(color)) self.rect = pygame.Rect(*offset, *size)
def surface(w, h, alpha): """ Creates a surface that shares a pixel format with the screen. The created surface will """ if alpha: rv = pygame.Surface((w + 4, h + 4), pygame.SRCALPHA) else: rv = pygame.Surface((w + 4, h + 4), 0) return rv.subsurface((2, 2, w, h))
def __init__(self, foreground, background): super(ProgressBar, self).__init__() self.foreground = pygame_sdl2.image.load(foreground) self.background = pygame_sdl2.image.load(background) self.width, self.height = self.background.get_size() self.image = pygame_sdl2.Surface((self.width, self.height)) self.counter = 0.0
def write_cache(self, filename): if filename in cached: return cached.add(filename) if renpy.loader.loadable(filename): return fn = os.path.join(renpy.config.gamedir, filename) dir = os.path.dirname(fn) #@ReservedAssignment if not os.path.exists(dir): os.makedirs(dir) cache = pygame.Surface((self.cache_width, self.cache_height), pygame.SRCALPHA, 32) for i, (d, rect) in enumerate(self.imagerect): x, y, _w, _h = self.cache_rect[i] surf = renpy.display.im.cache.get(d).subsurface(rect) cache.blit(surf, (x, y)) pygame.image.save(cache, renpy.exports.fsencode(fn))
def generate_icon(self): icon_fn = os.path.join(config.renpy_base, "launcher", "game", "gui7", "icon.png") icon = pygame_sdl2.image.load(icon_fn) width, height = icon.get_size() surf = pygame_sdl2.Surface((width, height), pygame_sdl2.SRCALPHA) ro, go, bo, _ao = tuple(self.accent_color) ro -= 23 go -= 23 bo -= 23 for y in range(height): for x in range(width): r, g, b, a = icon.get_at((x, y)) r = max(0, min(r + ro, 255)) g = max(0, min(g + go, 255)) b = max(0, min(b + bo, 255)) surf.set_at((x, y), (r, g, b, a)) self.save(surf, "window_icon", overwrite=False)
def run(self): pygame.init() pygame.display.set_caption('Space Invaders') self.screen = pygame.display.set_mode(GAME_CONFIG['DISPLAY_SIZE'], pygame.DOUBLEBUF, 32) flags = pygame.SRCALPHA if USING_SDL2 else 0 self.background = pygame.Surface(GAME_CONFIG['DISPLAY_SIZE'], flags) self.background.fill(pygame.Color(GAME_CONFIG['BACKGROUND_COLOR']))
def __init__(self, size, offset, color=None): super().__init__() self.health = None # If color exists - create Surface if color is not None: self.image = pygame.Surface(size) self.image.fill(pygame.Color(color)) else: self.image = None self.rect = pygame.Rect(*offset, *size)
def __init__(self, websocket): self.websocket = websocket pygame.init() pygame.font.init() self.screen = pygame.display.set_mode((600, 480)) self.background = pygame.Surface((600, 480)) self.background.fill(pygame.Color('#111111')) pygame.display.set_caption('Authorization') self.create_objects()
def read_dump(): global init surf = pygame.Surface(SIZE) dump = open(DUMP_PATH, "rb").read(0x6000) base_x, base_y = sym["wVertArrayX"], sym["wVertArrayY"] vert_tab = [(dump[i + base_x], dump[i + base_y]) for i in range(256)] # verts for i in vert_tab: if 0 <= i[0] < 128 and 0 <= i[1] < 128: surf.set_at(i, 0x7f7f7f) # expected face cnt = dump[sym["wVertCount"]] base = sym["hVertTabX"] verts = [(dump[i+base], dump[i+base+16]) for i in range(cnt)] prevs = [surf.get_at(i) for i in verts] pygame.draw.polygon(surf, (255, 255, 255), verts) for i in range(cnt): pos = verts[i] ref = prevs[i] col = 0x00ff00 if ref == col: col = 0xff0000 elif ref == 0: col = 0x0000ff surf.set_at(pos, col) # render buffer base = sym["sRenderBuf"] cur_col = dump[sym["wCurColor"]] addr = 0 for i in range(16): for j in range(128): base2 = base + i*256 + j*2 bits = int.from_bytes(dump[base2:base2+2]+dump[base2+0x1000:base2+0x1002], "little", signed=False) delta = 0 if init else render_buf[addr] ^ bits render_buf[addr] = bits for k in range(8): sh = 7 - k pix = bits >> sh pix = (pix & 1) | ((pix & 0x100) >> 7) | ((pix & 0x10000) >> 14) | ((pix & 0x1000000) >> 21) col = (pix*0x11, pix*0x11, pix*0x11) if (delta >> sh) & 0x01010101 != 0: col = COL_NEW if pix == cur_col else COL_NOT surf.set_at((i*8+k, j+128), col) addr += 1 pygame.transform.scale(surf, (WIDTH*SCALE, HEIGHT*SCALE), screen) # screen.blit(surf, (0, 0)) init = False
def write_cache(self, filename): if filename in cached: return cached.add(filename) if renpy.loader.loadable(filename): return fn = renpy.loader.get_path(filename) cache = pygame.Surface((self.cache_width, self.cache_height), pygame.SRCALPHA, 32) for i, (d, rect) in enumerate(self.imagerect): x, y, _w, _h = self.cache_rect[i] surf = renpy.display.im.cache.get(d).subsurface(rect) cache.blit(surf, (x, y)) pygame.image.save(cache, renpy.exports.fsencode(fn))
def write_cache(self, filename): if filename in cached: return cached.add(filename) # If all of our dependencies are of the same age or less, # we don't need to rebuild the cache. if renpy.loader.loadable(filename): d_set = set() mtime = 0 for i, rect in self.imagerect: if i in d_set: continue d_set.add(i) mtime = max(i.get_mtime(), mtime) if renpy.loader.get_mtime(filename) >= mtime: return fn = os.path.join(renpy.config.gamedir, filename) dir = os.path.dirname(fn) #@ReservedAssignment if not os.path.exists(dir): os.makedirs(dir) cache = pygame.Surface((self.cache_width, self.cache_height), pygame.SRCALPHA, 32) for i, (d, rect) in enumerate(self.imagerect): x, y, _w, _h = self.cache_rect[i] surf = renpy.display.im.cache.get(d).subsurface(rect) cache.blit(surf, (x, y)) pygame.image.save(cache, renpy.exports.fsencode(fn))
def surface(rect, alpha): """ Constructs a new surface. The allocated surface is actually a subsurface of a surface that has a 2 pixel border in all directions. `alpha` - True if the new surface should have an alpha channel. """ (width, height) = rect if isinstance(alpha, pygame.Surface): alpha = alpha.get_masks()[3] if alpha: sample = sample_alpha else: sample = sample_noalpha # We might not have initialized properly yet. This is enough # to get us underway. if sample is None: sample = pygame.Surface((4, 4), pygame.SRCALPHA, 32) surf = Surface((width + 4, height + 4), 0, sample) return surf.subsurface((2, 2, width, height)) # E1101
def go(self): '''This is the main game method''' self.load_map() self.load_sprites() # Define keystroke event delay and interval # pygame.key.set_repeat(500, 30) # Create the background self.background = pygame.Surface(self.screen.get_size()) self.background = self.background.convert() self.background.fill((0, 0, 0)) # Define font if pygame.font: font = pygame.font.Font(None, 36) # The main game loop contains all in-game actions while True: # Event handling for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() # Keyboard input handling pressed = pygame.key.get_pressed() pressed_move_keys = [key for key in MOVE_KEYS if pressed[key]] if pressed_move_keys: self.snake.move(pressed_move_keys) # Collision handling self.handle_collisions() # Rendering self.render(font)
def make_surface(self, width, height): return pygame_sdl2.Surface((width, height), pygame_sdl2.SRCALPHA)
def cropSurface(self, surface, rect): cropped = pygame.Surface((rect[2], rect[3]), 0, surface) cropped.blit(surface, (0, 0), rect) return cropped
`alpha` - True if the new surface should have an alpha channel. """ if isinstance(alpha, pygame.Surface): alpha = alpha.get_masks()[3] if alpha: sample = sample_alpha else: sample = sample_noalpha # We might not have initialized properly yet. This is enough # to get us underway. if sample is None: sample = pygame.Surface((4, 4), pygame.SRCALPHA, 32) surf = Surface((width + 4, height + 4), 0, sample) return surf.subsurface((2, 2, width, height)) # E1101 surface_unscaled = surface def copy_surface(surf, alpha=True): """ Creates a copy of the surface. """ rv = surface_unscaled(surf.get_size(), alpha) renpy.display.accelerator.nogil_copy(surf, rv) # @UndefinedVariable