def __init__(self, width=640, height=480, title='Serge', backcolour=(0, 0, 0), icon=None, fullscreen=False): """Initialise the engine :param width: width of the screen :param height: height of the screen """ self.title = title self.fullscreen = fullscreen self.addLogger() self.initEvents() self.log.info('Starting serge engine (v%s)' % common.version) SetCurrentEngine(self) super(Engine, self).__init__() self.clearWorlds() self.renderer = render.Renderer(width, height, title, backcolour, icon, fullscreen) self.sprites = visual.Register self._stop_requested = False self._current_world_name = '' self._builder = None self._keyboard = input.Keyboard() self._mouse = input.Mouse(self) self._stats = EngineStats() self._recent_worlds = [] self._profiler = profiler.NullProfiler()
def set_size(self, cw, ch): self._cw = cw self._ch = ch self.reset() if self.do_render: del self.r self.r = render.Renderer(self._cw * self._cc, self._ch * self._cc, self._cc)
def __init__(self, m): self.model = m self.units = [unit.Unit(self.model, x, y) for x, y in self.model.conf.units] self.all_effects = pygame.sprite.Group() self.individual_effects = defaultdict(pygame.sprite.Group) self.all_walkers = pygame.sprite.Group() self.renderer = render.Renderer() self.renderer.draw(self.model) self.clock = pygame.time.Clock() # Win conditions self.win_duration_sec = self.model.conf.game["duration"] self.win_duration_frames = self.model.conf.game["duration"] * FRAMES_PER_SECOND self.win_living_min_threshold = self.model.conf.game["living_min_threshold"] self.font = bont.Tiny() self.news_font = data.load_font(*NEWS_FONT) self.over_font = data.load_font(*OVER_FONT) self.selection = None self.last_selection = None self.need_destination = False self.pending_cmd = None self.buttons = buttons.ButtonRegistry() self.buttons.add_sprite_button("Cleanse", self.send_reap, 150, 160) self.buttons.add_sprite_button("Burn", self.send_burn, 150, 180) self.buttons.add_sprite_button("Block", self.send_block, 205, 160) self.buttons.add_sprite_button("Cancel", self.cancel_selection, 205, 180) self.advisor_face = data.load_image("faces/6p.png") self.frame = 0 self.newsflash = None # don't fire a newsflash right away self.next_newsflash = 5 * FRAMES_PER_SECOND self.hover_info = hover_info.HoverInfo() self.over = None self.paused = False self.final_click = False self.voice_chan = None self.select_voice_iter = itertools.cycle(self.select_voices) music.enqueue("minor1")
def main(): pygame.init() pygame.font.init() background = pygame.display.set_mode((constants.X_RES, constants.Y_RES)) pygame.display.set_caption("Circulatory Diagram") clock = pygame.time.Clock() person = circulatory.Organism() renderer = render.Renderer(background, person) should_exit = False frame_time = 7 # TODO: this is a hack used for initial flow cycle frame = 0 while not should_exit: for event in pygame.event.get(): if event.type == pygame.QUIT: should_exit = True if event.type == pygame.MOUSEBUTTONDOWN: for renderable in [ x for x in renderer.renderables if x.rect.collidepoint(pygame.mouse.get_pos()) ]: if renderable.type == "button": if renderable.data == "reset": renderer.notify("Resetting Model", constants.NOTIFICATION_DURATION) person.reset() elif renderable.data == "heal": renderer.notify("Healing", constants.NOTIFICATION_DURATION) person.heal() elif renderable.type == "bloodsource": print(renderable.data) if not renderable.data.broken: person.bleeding = True person.circulatory_system.destroy_vessel( renderable.data) person.tick(frame_time) renderer.draw_frame(frame) pygame.display.update() clock.tick(constants.FRAMERATE) frame_time = clock.get_time() frame += 1
def run_replay_monitor(renderer_process_connection, combined_level_bounds): class IpcReplayClient: def __init__(self, connection): self._connection = connection # replay data self.tile_data = None self.current_replays = None # end of game data self.end_of_game_stats = None self.training_level_medal = None self.diamond_medal = None def try_get_next_replay(self): renderer_process_connection.send((REQUEST_REPLAY,)) event = renderer_process_connection.recv() if event[0] is NEW_REPLAY: self.tile_data = event[1] self.current_replays = event[2] return True elif event[0] is END_OF_GAME_EVENT: self.end_of_game_stats = event[1] self.training_level_medal = event[2] self.diamond_medal = event[3] return False return False ipc_replay_client = IpcReplayClient(renderer_process_connection) renderer = render.Renderer(combined_level_bounds) while ipc_replay_client.try_get_next_replay(): action_sources = [ReplayActionSource(replay) for replay in ipc_replay_client.current_replays] renderer.render_main(ipc_replay_client.tile_data, action_sources) end_of_game_renderer.render_end_of_game_stats( ipc_replay_client.end_of_game_stats.games_attempted, ipc_replay_client.end_of_game_stats.games_won, ipc_replay_client.end_of_game_stats.training_level_count, ipc_replay_client.training_level_medal, ipc_replay_client.end_of_game_stats.diamond_count, ipc_replay_client.diamond_medal )
def __init__(self, width=640, height=480, title='Serge', backcolour=(0, 0, 0), icon=None): """Initialise the engine""" self.addLogger() self.log.info('Starting serge engine (v%s)' % common.version) SetCurrentEngine(self) super(Engine, self).__init__() self.clearWorlds() self.renderer = render.Renderer(width, height, title, backcolour, icon) self.sprites = visual.Register self._stop_requested = False self._current_world_name = '' self._builder = None self._keyboard = input.Keyboard() self._mouse = input.Mouse(self) self._stats = EngineStats()
def start(self): r = render.Renderer(self._cw * self._cc, self._ch * self._cc, self._cc) while self.running: # process all events self.process_events() # move snake self.move_snake() self.update_score() if not self.suppressed: r.render(self.get_items(), self.score) if self.discrete: while not self.moved and self.running: self.process_events() self.moved = False else: self.fps_clock.tick(FPS) if self.score > self.high_score: self.high_score = self.score if not self.suppressed: print 'Game over. Score: {0}. High score: {1}.'.format( self.score, self.high_score)
def __init__(self, tk_master, opengl_context): tkinter.Frame.__init__(self, tk_master) self.tk_master = tk_master self.renderer = render.Renderer(opengl_context) self.tools = [ (Camera_Pan_Tool(), 'Pan'), (Axis_Aligned_Scaling_Tool(), 'AA-Scale'), (Axis_Aligned_Rotation_Tool(), 'AA-Rot'), (Mask_Editing_Tool(), 'Masking'), ] self.setup_interface() self.current_scene_fname = None self.selected_m2_tool = self.tools[0][0] self.selected_m1_tool = self.tools[1][0] self.selected_axis = 0 self.selected_objects = [] self.show_vanishing_points = True
def __init__(self, do_render=True): self._cc = 20 self._cw = 32 self._ch = 24 self.do_render = do_render if self.do_render: # BIG RED NOTICE HERE global pygame # ----------------------- global render # Only import into global import pygame # namespace if the import render # render flag is set! pygame.init() self.score = 0 self.trap = (0, 0) self.mouse = (0, 0) self.cheese = (0, 0) self.force_kill = False self.cat = False self.move_chance = 0.07 self.easy = False self.reset() if self.do_render: self.r = render.Renderer(self._cw * self._cc, self._ch * self._cc, self._cc)
def __init__(self): self.title = data.load_image("title.png") self.next_mode = self self.model = sim.Map("level1") self.renderer = render.Renderer() self.renderer.draw(self.model) def play_level(n): def build_level(): self.new_mode = game.Game(sim.Map("level" + str(n))) return build_level self.buttons = buttons.ButtonRegistry() self.buttons.add_sprite_button("Level 1", play_level(1), 96, 160) self.buttons.add_sprite_button("Level 2", play_level(2), 150, 160) self.buttons.add_sprite_button("Level 3", play_level(3), 205, 160) self.buttons.add_sprite_button("Tutorial", self.new_tutorial, 150, 180) self.buttons.add_sprite_button("Quit", self.quit_game, 205, 180) self.new_mode = self music.enqueue("major")
def enter(self): self.r = render.Renderer(gRootConsole, gWidth, gHeight) self.help_statusbar = menu.HelpStatusBar(gRootConsole, gWidth, gHeight) #clears the status bar after 10 seconds self.help_statusbar_timer = None self.inventory = menu.Inventory(gRootConsole, gWidth, gHeight) self.lm = level.LevelManager() self.lm.inventory = self.inventory if self.fsm.game_continue: print("LOADING") self.lm.load_save("save.json") self.player = self.lm.player else: print("NEW LEVEL") self.lm.new_level() # self.lm.load_level("basic_starter_level.json") self.player = self.lm.player self.lm.level.objects.append(self.player) self.interaction_state = GameState.Game.ControlState.ROAM self.controls = control.MainControls(self.player, self.r, self.lm.level) self.interaction_controls = control.InteractionControls(self.player, self.lm.level) self.controls.emitter.bind(interaction=self.on_interaction) self.controls.emitter.bind(inventory_open=self.on_inventory_open) self.controls.emitter.bind(in_game_menu=self.on_in_game_menu_open) self.controls.emitter.bind(pickup_item=self.on_item_pickup) self.controls.emitter.bind(simple_crafting_menu=self.on_simple_crafting_menu) self.interaction_controls.emitter.bind(interaction_direction=self.on_interaction_direction) self.conversation_controls = control.ConversationControls() #we need a handle for the text window to be persitent or else the function will not be called so we need this textwindow variable self.text_window = None #inventory self.inventory_controls = control.InventoryControls() self.inventory_controls.emitter.bind(move_down=self.inventory.move_down) self.inventory_controls.emitter.bind(move_up=self.inventory.move_up) self.inventory_controls.emitter.bind(select=self.inventory.select) self.inventory_controls.emitter.bind(cancel=self.on_inventory_close) self.inventory_controls.emitter.bind(drop=self.inventory.drop_item) #tools self.tool_controls = control.ToolControls(self.player, self.lm.level) self.tool_controls.emitter.bind(direction=self.on_tool_use_direction) #non-tools self.nontool_controls = control.NonToolsControls(self.player, self.lm.level) self.nontool_controls.emitter.bind(direction=self.on_nontool_use_direction) self.nontool_handler = item.NonToolHandler(self.player, self.lm.level) #in game menu self.menu_controls = control.MenuControls() self.in_game_menu = None # needs to be none just like for the text window #crafting menu self.simple_crafting_controls = control.SimpleCraftingControls() self.simple_crafting_menu = None self.simple_crafting_submenu_controls = control.SimpleCraftingSubmenuControls() self.simple_crafting_submenu = None #global events self.tool_handler = item.ToolHandler(self.player, self.lm.level) # gEventHandler.bind("inventory_item_close", self.on_inventory_close) self._last_used = None gEventHandler.bind("use_tool", self.on_use_tool) gEventHandler.bind("drop_item", self.on_drop_item) gEventHandler.bind("use_non_tool", self.on_nontool_use) gEventHandler.bind("interact_description", self.interact_description) gEventHandler.bind("interact_npc", self.interact_npc) gEventHandler.bind("interact_door", self.interact_door) # Crafting submenu gEventHandler.bind("simple_crafting_submenu_open", self.on_simple_crafting_submenu_open) gEventHandler.bind("simple_crafting_craft", self.on_simple_crafting_craft)
def __init__(self, parent=None): super().__init__(parent) self.renderer = render.Renderer()
if __name__ == '__main__': window = pyglet.window.Window(width=1600, height=800) simulation = Simulation() #for i in range(20): # for j in range(30): # simulation.add_device_to_world(devices.ConnectorDevice((i*50,j*50))) theme = { 'background_color': c_blue, 'gui_frame_color': c_orange, 'node_selection': c_red, 'wire_color': c_orange } gui = GUI(window, simulation, theme) renderer = render.Renderer(window, theme) @window.event def on_mouse_motion(x, y, dx, dy): gui.update_mouse_position(x, y) #@window.event #def on_key_release(symbol, modifiers): # if symbol == 32: # simulation.current_mode += 1 # simulation.current_mode %= len(MODES) # print('mode: ', MODES[simulation.current_mode]) @window.event def on_mouse_release(x, y, button, modifiers): if not gui.on_mouse_release_event(x, y, button, modifiers):
# Copyright (c) Microsoft Corporation. # Licensed under the MIT License. import render from actionsource import KeyboardActionSource from level_loader import load_level_filepath import os.path if __name__ == '__main__': level_data = load_level_filepath(os.path.join('Data', 'Test', 'goal_advanced.json')) action_source = KeyboardActionSource() renderer = render.Renderer((len(level_data[0]), len(level_data))) renderer.render_main(level_data, [action_source])
import pygame import render import config renderer = render.Renderer(config.SCREEN_SIZE, config.ROOM_SIZE) import mouse import keyboard import event import loop import scene pygame.init() mouse = mouse.Mouse() keyboard = keyboard.Keyboard() handler = event.Handler(mouse, keyboard) scene = scene.Scene(mouse, keyboard) loop = loop.Loop(renderer, handler, scene) while not loop.update(): pass pygame.quit()
import lib import model import render if __name__ == '__main__': mebel = model.Calosc() renderer = render.Renderer() print(model.podsumuj()) if renderer.init_graphics(): renderer.render(mebel) else: print("Renderer init error")
def renderer(i, name): ren = render.Renderer(i, name) ren.render_loop() print "render process ending." return True
# Copyright (c) Microsoft Corporation. # Licensed under the MIT License. import render from actionsource import ReplayActionSource from gamelogic import ActionTypes import argparse import json if __name__ == '__main__': parser = argparse.ArgumentParser(description='Visualise a replay.') parser.add_argument('replay_file_name', type=str, help='the name of the replay file to load') parser.add_argument('--replay_index', type=int, default=0, help='which replay in the file to run') args = parser.parse_args() with open(args.replay_file_name) as f: data = json.load(f) tile_data = data["tile_data"] replays = data["replays"] action_source = ReplayActionSource(replays[args.replay_index]) renderer = render.Renderer((len(tile_data[0]), len(tile_data))) renderer.render_main(tile_data, [action_source])
#draw the player renderer.render_object( renderer.surfaces.left_paddle, (self.left_paddle.x, self.left_paddle.y)) #draw the ai renderer.render_object( renderer.surfaces.right_paddle, (self.right_paddle.x, self.right_paddle.y)) #draw the ball renderer.render_object(renderer.surfaces.ball, (self.ball.x, self.ball.y)) elif self.game_state == constants.GAMESTATE_MENU: renderer.render_object(renderer.surfaces.main_menu, (0, 0)) elif self.game_state == constants.GAMESTATE_OPTIONS: renderer.render_object(renderer.surfaces.options_menu, (0, 0)) elif self.game_state == constants.GAMESTATE_EXIT_PROMPT: pass pygame.display.update() self.clock.tick(self.tick) if __name__ == "__main__": game = Game() renderer = render.Renderer(game.gameDisplay) game.main_loop() pygame.quit() quit()