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()
