from framebase import frame import framebase, logger globals().update(logger.build_module_logger(__name__)) @frame.register_this("event_logger") class EventLogger(framebase.Observer): def handle_event(s, e, *a, **k): pass#debug("Event '"+e+"' : "+str(a)+" "+str(k))
from framebase import frame import logger, framebase globals().update(logger.build_module_logger("entities")) class Entity(framebase.Observer): def __init__(self, components): self.components=components self.kill=0 for v in self.components.values(): v.bind(self) @classmethod def from_dict(cls, data): # debug("Creating entity from "+str(data)) components={} for k, v in data.items(): components[k]=frame.entities.component_collection[k].from_dict(v) return cls(components) def __getattr__(self, k): if k in self.__dict__: return object.__getattr__(self, k) else: return self.components[k] def handle_event(self, e, *a, **k): for v in self.components.values(): v.handle_event(e, *a, **k) class Component(framebase.Observer): def bind(self, parent):
from framebase import frame import logger, pygame, framebase globals().update(logger.build_module_logger("tmx_loader")) frame.loader.require_library("pygame", "pytmx") debug("Requesting pytmx load") try: frame.load_library_as_module("pytmx") except ImportError: error("pytmx not availible, failing") frame.loader.abort_module_load("pytmx not availible") debug("Success!") class TMXMap: def __init__(self, fn): self.map=frame.pytmx.util_pygame.load_pygame(fn) self.surf=pygame.Surface((self.map.width*self.map.tilewidth, self.map.height*self.map.tileheight)) self.named_contained_entites={} self.contained_entities=[] self._process_map() def _process_map(self): for layer in self.map.visible_layers: debug("Loading layer: "+str(layer)) if isinstance(layer, frame.pytmx.TiledTileLayer): # debug(str(layer)) for x, y, image in layer.tiles(): # debug((x,y,image)) self.surf.blit(image, (x*self.map.tilewidth, y*self.map.tileheight))
from framebase import frame import logger, framebase globals().update(logger.build_module_logger("pygame")) try: frame.load_library_as_module("pygame") except ImportError: error("Pygame not availible, PygameCore will fail!") @frame.register_this("pygamecore") class PygameCore(framebase.Observer): def __init__(self): pass def preinit(self): info("Initilizing PygameCore base") frame.pygame.init() frame.screen=frame.pygame.display.set_mode((10,10)) frame.pygame.display.set_caption("Loading") def run_main(self): info("Initializing PygameCore") frame.pygame.init() frame.screen=frame.pygame.display.set_mode((800,600)) frame.pygame.display.set_caption(frame.loader["window_title"]) self.clock=frame.pygame.time.Clock() running=True debug("Creating a PyConsole (enabled ="+str(frame.loader["enable_pyconsole"])+")") self.pyconsole=frame._pyconsole_Console(frame.screen, (0,0,800,200), localsx={"frame":frame}) frame.send_event("core_loaded")
from framebase import frame import logger, framebase, random globals().update(logger.build_module_logger("particles")) @frame.register_this("particlemanager") class ParticleManager(framebase.Observer): def __init__(self): self.particles=[] def add_sq_particle(self, x, y, vx, vy, color, size, time): s=frame.pygame.Surface(size) s.fill(color) self.add_particle(x, y, vx, vy, s, time) def add_particle(self, x, y, vx, vy, surf, time): self.particles.append([x, y, vx, vy, surf, time]) def add_particles(self, particles): self.particles.extend(particles) def handle_event_render(self, dt): for p in self.particles: p[5]-=dt frame.screen.blit(p[4], (p[0], p[1])) p[0]+=p[2]*dt p[1]+=p[3]*dt if p[5]<0: self.particles.remove(p) def add_particles_from_style(self, name, ox, oy): s=frame.loader[name]
from framebase import frame import logger, framebase globals().update(logger.build_module_logger("states")) class StateData: def __init__(self): self.initilized = False @frame.register_this("statemanager") class StateManager: def __init__(self): self.stack = [] # [[name, statedata],...] @property def current(self): return self.stack[-1][0] if self.stack else None @property def current_data(self): return self.stack[-1][1] if self.stack else None def push(self, state): debug("Entering state " + state) if self.current: frame.send_event("state_suspending", self.current) self.stack.append([state, StateData()]) frame.send_event("state_starting", self.current)
from framebase import frame import logger globals().update(logger.build_module_logger("dummycore")) @frame.register_this("dummycore") class DummyCore: def run_main(self): print("DummyCore Invoked") info("DummyCore started!") frame.send_event("core_loaded") while 1: try: frame.send_event("render", 0) except BaseException as e: exception("Error in render call")
from framebase import frame import logger, framebase globals().update(logger.build_module_logger("fpsgraph")) @frame.register_this("fpsgraph_controller") class FPSGraphController(framebase.Observer): def handle_event_core_loaded(self): frame.load_library_as_module("fpsgraph") def handle_event_pygame_batch_events(self, events): frame.fpsgraph.event(events) def handle_event_render(self, dt): frame.fpsgraph.update({"frame":frame}) frame.fpsgraph.render(frame.screen)
from framebase import frame import logger, json globals().update(logger.build_module_logger("run")) debug("Starting...") with open("engine.cfg", 'r') as fd: engine_config=json.load(fd) debug("engine_config = "+str(engine_config)) info("Preloading core "+engine_config["main_provider"]) frame.loader._selected.append(engine_config["main_provider_path"]) frame.loader.load_selected() info("Running preinit on core "+engine_config["main_provider"]) frame.modules[engine_config["main_provider"]].preinit() for item in engine_config["load_order"]: debug("Adding directory "+item) frame.loader.add_directory(item) debug("Loading...") frame.loader.load_selected() info("Starting core "+engine_config["main_provider"]) frame.modules[engine_config["main_provider"]].run_main()