Python Forum
My boiler plate for pygame
Thread Rating:
  • 0 Vote(s) - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
My boiler plate for pygame
#1
My boiler plate for pygame is a small project.
It contains scene flipping , tick timer builtin to scenes, and has widgets.
Only tested in python 3.6 on Antergos(Arch linux).

Any improvements suggestion are welcome.
Code on github
sample code.
#               *** *** Open a basic Screen with a Scene *** ***

# just import the basics
import pygame
from pyscene import Scene, Screen

# inherit Scene allows the class to interface with Screen
class MyScene(Scene):
    # where all draw commands go
    def blit(self, surface):
        surface.fill((0,0,40))

    # where all event go
    def event(self, event):
        if event.type == pygame.QUIT:
            Screen.close()

if __name__ == '__main__':
    # The Screen will handle pygame.init() and pygame.quit()
    # let create a Screen
    Screen.open('Basic Screen', (800, 600))
    # let add a scene to Screen
    Screen.scenes['MyScene'] = MyScene()
    # let the action begin
    Screen.loop('MyScene', 30) # start scene, frame per seceond
99 percent of computer problems exists between chair and keyboard.
Reply
#2
Here the bare bone of my project. Example above works with this code and my project.
pyscene.py
import os
import pygame
import tick_timer

class Screen:
	set_scene = None
	running = False
	scenes = {}

	@classmethod
	def add_scene(cls, scene, name=None):
		if name is None:
			name = type(scene).__name__
		cls.scenes[name] = scene

	@staticmethod
	def center():
		os.environ['SDL_VIDEO_CENTERED'] = '1'

	@classmethod
	def open(cls, caption, size, flags=0, depth=0):
		pygame.init()
		cls.size = size
		cls.current_scene = Scene()
		pygame.display.set_caption(caption)
		cls.surface = pygame.display.set_mode(size, flags, depth)
		cls.clock = pygame.time.Clock()
		cls.running = False

	@classmethod
	def close(cls):
		cls.running = False

	@classmethod
	def loop(cls, start_scene=None, fps=60):
		cls.fps = fps
		cls.running = True
		cls.set_scene = start_scene

		while cls.running:
			if cls.set_scene:
				cls.current_scene.screen_drop()
				cls.current_scene = cls.scenes[cls.set_scene]
				cls.current_scene.screen_entrance()
				cls.set_scene = None

			for event in pygame.event.get():
				cls.current_scene.screen_event(event)

			cls.current_scene.screen_blit(cls.surface)

			pygame.display.flip()
			cls.clock.tick(Screen.fps)

		pygame.quit()

class Font:
	pass

# Scene flipping
class Scene:
	font = Font()
	screen = Screen

	def __init__(self):
		# builtins
		self.font = Scene.font
		self.timer = tick_timer.TickTimer(pygame.time.get_ticks())

	def entrance(self):
		pass
	def drop(self):
		pass
    # pygame draw code here
	def blit(self, surface):
		pass
    # pygame events code here
	def event(self, event):
		pass

    # interface with screen
	def screen_entrance(self):
		self.entrance()
		self.timer._time_elaspe()

	def screen_drop(self):
		self.timer._stop()
		self.drop()

	def screen_event(self, event):
		self.event(event)

	def screen_blit(self, surface):
		self.timer._update(pygame.time.get_ticks())
		self.blit(surface)

	def get_screensize(self):
		return Scene.screen.size

	def get_screenrect(self):
		return pygame.Rect(0, 0, *Scene.screen.size)

	def get_screenmid(self):
		return Scene.screen.size[0] / 2, Scene.screen.size[1] / 2

	def add_scene(self, scene, name=None):
		Scene.screen.add_scene(scene, name)

	def close_screen(self):
		Scene.screen.running = False

	def set_scene(self, scene):
		Scene.screen.set_scene = scene

	def del_scene(self, scene):
		del Scene.screen.scenes[scene]
tick_timer.py
class TickTimerInfo:
    def __init__(self, interval, callback, pydata):
        self.next_tick = TickTimer.ticks + interval
        self.interval = interval
        self.callback = callback
        self.pydata = pydata
        self.stop = False

class TickTimer:
    ticks = 0

    def __init__(self, ticks):
        self.callbacks = {}
        self.tick_stop = 0
        TickTimer.ticks = ticks

    def __getitem__(self, key):
        return self.callbacks[key]

    def __setitem__(self, key, value):
        if isinstance(value, TickTimerInfo):
            self.callbacks[key] = value

    def add(self, key, interval, callback, pydata=None):
        self.callbacks[key] = TickTimerInfo(interval, callback, pydata)

    def reset(self, key, offset=None):
        if offset:
            self.callbacks[key].next_tick = TickTimer.ticks + offset
        else:
            self.callbacks[key].next_tick = TickTimer.ticks + self.callbacks[key].interval

    # pyscene.Scene use only
    def _stop(self):
        self.tick_stop = TickTimer.ticks

    def stop(self, key):
        self.callbacks[key].stop = True

    def start(self, key):
        self.callbacks[key].stop = False
        self.callbacks[key].next_tick = TickTimer.ticks + self.callbacks[key].interval

    # pyscene.Scene use only
    def _time_elaspe(self):
        if self.tick_stop > 0:
            elaspe = TickTimer.ticks - self.tick_stop
            for info in self.callbacks.values():
                info.next_tick += elaspe

    # pyscene.Scene use only
    def _update(self, ticks):
        TickTimer.ticks = ticks
        for key, item in self.callbacks.items():
            if item.stop is False:
                if ticks > item.next_tick:
                    item.interval = item.callback(item)
                    item.next_tick += item.interval

    def pop(self, key):
        self.callbacks.pop(key)
99 percent of computer problems exists between chair and keyboard.
Reply
#3
screenshot of pyscene so far.
[Image: pyscene.jpg]
99 percent of computer problems exists between chair and keyboard.
Reply


Forum Jump:

User Panel Messages

Announcements
Announcement #1 8/1/2020
Announcement #2 8/2/2020
Announcement #3 8/6/2020