def render(template, context=None, **kwargs): """ Return the given template string rendered using the given context. """ renderer = Renderer() return renderer.render(template, context, **kwargs)
class RendererTest(unittest.TestCase): "Tests to ensure our Renderer work" def setUp(self): self.uuid = str(uuid.uuid4()) self.file = open("/tmp/" + self.uuid, "w+") self.file.write(FILE_CONTENT) self.file.seek(0) self.renderer = Renderer(cwd="/tmp/") def test_context_data(self): "Test that the renderer can return context data" self.assertIsNotNone(self.renderer.get_context_data()) def test_loader(self): "Test that the renderer can return a loader" self.assertIsNotNone(self.renderer.get_loader()) def test_environment(self): "Test that the renderer can return an environment" self.assertIsNotNone(self.renderer.get_environment()) def test_render_fn(self): "Test that the renderer can return a rendering function" self.assertIsNotNone(self.renderer.get_render_fn()) def test_render(self): "Test that the renderer can render a simple jinja 2 file" self.assertEqual(self.renderer(self.uuid), "2") def tearDown(self): self.file.close() os.remove("/tmp/" + self.uuid)
def test_draw_action_method(): renderer = Renderer() cmd = {"action": "draw", "magnitude": "100", "direction": "bd"} x, y = 230, 230 renderer.draw_action(cmd, x, y) assert renderer.position == QPoint(230, 330) assert renderer.paths[-1].path_type == "line"
def __init__(self): pygame.init() self.click = False self.renderer = Renderer() # self.game = Game() self.sound = Sound() self.main_menu()
def main(): if not os.path.exists(os.path.join(config['data_dir'], 'tile.pal')): if not os.path.exists(config['data_dir']): os.makedirs(config['data_dir']) tile_dats = glob.glob(os.path.join(config['nexus_data_dir'], 'tile*.dat')) extract_dats(dats=tile_dats) tile_pal = PALHandler(os.path.join(config['data_dir'], 'tile.pal')) tile_tbl = TBLHandler(os.path.join(config['data_dir'], 'tile.tbl')) tilec_pal = PALHandler(os.path.join(config['data_dir'], 'TileC.pal')) tilec_tbl = TBLHandler(os.path.join(config['data_dir'], 'TILEC.TBL')) sobj_tbl = SObjTBLHandler(os.path.join(config['data_dir'], 'SObj.tbl')) tile_epf_files = glob.glob(os.path.join(config['data_dir'], 'tile*.epf')) tilec_epf_files = glob.glob(os.path.join(config['data_dir'], 'tilec*.epf')) tile_epfs = [] for i in range(len(tile_epf_files)): if 'tilec' not in tile_epf_files[i]: epf = EPFHandler(os.path.join(config['data_dir'], 'tile{}.epf'.format(i))) tile_epfs.append(epf) tilec_epfs = [] for i in range(len(tilec_epf_files)): epf = EPFHandler(os.path.join(config['data_dir'], 'tilec{}.epf'.format(i))) tilec_epfs.append(epf) tile_renderer = Renderer(epfs=tile_epfs, pals=tile_pal.pals, tbl=tile_tbl) sobj_renderer = Renderer(epfs=tilec_epfs, pals=tilec_pal.pals, tbl=tilec_tbl, sobj_tbl=sobj_tbl) root = tkinter.Tk() ex = TKViewer(root, tile_renderer=tile_renderer, sobj_renderer=sobj_renderer) root.geometry("640x480") root.iconbitmap(config['viewer_icon']) root.mainloop()
def __init__(self): # set up environment self.env = retro.make(game='SonicTheHedgehog-Genesis', state='LabyrinthZone.Act1') # initialize renderer self.renderer = Renderer()
def __init__(self, max_depth: int, num_human: int, random_players: int, smart_players: List[int]) -> None: """Initialize this game, as described in the Assignment 2 handout. Each player has a random target colour, and all players share the same goal(Players might have same target colour.) Precondition: 2 <= max_depth <= 5 """ self.board = random_init(0, max_depth) self.board.update_block_locations((0, 0), BOARD_WIDTH) num_player = num_human + random_players + len(smart_players) self.renderer = Renderer(num_player) self.players = [] random_num = random.randint(0, 1) for i in range(num_player): if random_num == 0: goal = BlobGoal(COLOUR_LIST[random.randint(0, 3)]) else: goal = PerimeterGoal(COLOUR_LIST[random.randint(0, 3)]) if i < num_human: self.players.append(HumanPlayer(self.renderer, i, goal)) elif num_human <= i < num_human + random_players: self.players.append(RandomPlayer(self.renderer, i, goal)) else: self.players.append( SmartPlayer( self.renderer, i, goal, smart_players[i - (num_human + random_players)])) # Display each player's goal before starting game. for i in range(num_player): self.renderer.display_goal(self.players[i])
def __init__(self): """Intialize App, starting the game.""" # Load game options game_options_path = os.path.join(os.path.dirname(__file__), "options.json") game_options_file = open(game_options_path, 'r') self._options = json_loads_str(game_options_file.read()) game_options_file.close() # Load renderer options renderer_options_path = os.path.join(os.path.dirname(__file__), "renderer", "options.json") renderer_options_file = open(renderer_options_path, 'r') renderer_options = json_loads_str(renderer_options_file.read()) renderer_options_file.close() # Initialize variables self._is_running = False self._game = Game(self, self._options) self._renderer = Renderer(self, renderer_options) # Start curses for I/O self._screen = curses.initscr() curses.noecho() curses.cbreak() curses.curs_set(0) self._screen.nodelay(1) self._screen.keypad(1)
def __init__(self, pd): """Creates a new renderer based on a QPaintDevice pd """ self._defpose = Pose() # The pose in the bottom-left corner self._zoom = 1 # The zooming factor self._zoom_c = False # Whether the scaling is done from center Renderer.__init__(self, (pd.width(), pd.height()), pd)
class Game(): def __init__(self): SDL_Init(SDL_INIT_VIDEO) self.evtMngr = EventManager() self.scene = Scene(self.evtMngr) self.renderer = Renderer(self.evtMngr, 1000, 800) self.evtMngr.attachHandler(E_SDL_EVENT, self.onSDLEvent) def run(self): self.running = True while self.running: self.queueSDLEvents() self.evtMngr.handleEvents() self.scene.update() self.renderer.draw(self.scene) return 0 def onSDLEvent(self, eType, e): if eType == SDL_QUIT: self.running = False if eType == SDL_KEYDOWN and e.key.keysym.sym == SDLK_ESCAPE: self.running = False def queueSDLEvents(self): events = sdl2ext.get_events() newEvents = dict() for event in events: self.evtMngr.queueEvent(E_SDL_EVENT, event.type, event)
def __init__(self, *arg, **kwargs): super().__init__(*arg, **kwargs) self.canvas = myGLCanvas(self, id=wx.ID_ANY, size=(500, 500)) self.GLinitialized = False self.angle_x = 0 self.angle_y = 0 self.trans_x = 0 self.trans_y = 0 self.zoom = 0 self.renderer = Renderer(self.TopLevelParent.manager) # Event handlers self.canvas.Bind(wx.EVT_ERASE_BACKGROUND, self.processEraseBackgroundEvent) self.canvas.Bind(wx.EVT_SIZE, self.processSizeEvent) self.canvas.Bind(wx.EVT_PAINT, self.processPaintEvent) # Mouse events self.mouse_handler = MouseEventHandler(self) self.canvas.Bind(wx.EVT_MOTION, self.mouse_handler.on_mouse_motion) self.canvas.Bind(wx.EVT_MOUSEWHEEL, self.mouse_handler.on_mouse_wheel) sizer = wx.BoxSizer(wx.VERTICAL) sizer.Add(self.canvas, -1, wx.ALL | wx.EXPAND) self.SetSizer(sizer) sizer.Fit(self) self.Layout()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--setting_file', type=str, default='setting.yaml') args = parser.parse_args() params = settings.SharedSettings('global', args) simulator = Simulator().start() renderer = Renderer() window_name = 'EV3 Simulator' cv2.namedWindow(window_name) def canvas2world(canvas_x, canvas_y): scale_w = params.world_w / params.canvas_w scale_h = params.world_h / params.canvas_h return Point(canvas_x * scale_w, canvas_y * scale_h) def on_mouse(event, x, y, flag, params): env = params[0] if event == cv2.EVENT_LBUTTONDOWN: if flag & cv2.EVENT_FLAG_SHIFTKEY: delta = math.radians(10) env.increment_ev3_angle(delta) elif flag & cv2.EVENT_FLAG_ALTKEY: delta = math.radians(10) env.increment_ev3_angle(-delta) else: new_pos = canvas2world(x, y) env.force_ev3_pos(new_pos) cv2.setMouseCallback(window_name, on_mouse, [simulator.env]) try: while True: canvas = renderer.render_env(simulator.env) cv2.imshow(window_name, canvas) key = cv2.waitKey(5) if key == ord('q'): # Quit simulator break if key == ord('r'): # Reset simulator simulator.env.reset() if key == ord('t'): # Push touch sensor simulator.env.set_touch_sensor_state(is_pressed=True) if key == ord('1'): simulator.env.set_left_button_state(is_pressed=True) if key == ord('2'): simulator.env.set_right_button_state(is_pressed=True) if key == ord('3'): simulator.env.set_up_button_state(is_pressed=True) if key == ord('4'): simulator.env.set_down_button_state(is_pressed=True) if key == ord('0'): simulator.env.set_enter_button_state(is_pressed=True) time.sleep(0.01) except: simulator.stop() import traceback traceback.print_exc() simulator.stop()
def __init__(self, p1_search_strategy, p2_search_strategy, max_turns=50, p1_ai=True, p2_ai=True, board=None, board_size=4, render=False, renderSize=512, *args, **kwargs): ''' Set up the game Pre-condition: max_turns >= 0, board_size >0 Post-condition: attributes updated ''' self.max_turns = max_turns self.player1_is_ai = p1_ai self.player2_is_ai = p2_ai if board is not None: self.b = board else: self.b = Board(board_size) self.p1_search_strategy = p1_search_strategy self.p2_search_strategy = p2_search_strategy self.render = render if render: self.r = Renderer(renderSize)
def main1(): world = World() camera = Camera(Vec3(2, 1, 3), Vec3(0, 0, 0), Vec3(0, 0, 1), Vec3(0, 1, 0), 60, 400, 400) sphereB = Sphere(Vec3(0, 0.5, 0), Vec3(0, 0, 0), 0.3, Vec3(0, 0, 255)) sphereR = Sphere(Vec3(0, 0, 1), Vec3(0, 0, 0), 0.3, Vec3(255, 0, 0)) sphereG = Sphere(Vec3(1, 0, 1), Vec3(0, 0, 0), 0.3, Vec3(0, 255, 0)) light1 = Light(Vec3(3, 2, 5), Vec3(0, 0, 0)) light2 = Light(Vec3(-2, 1, 1), Vec3(0, 0, 0)) world.add_camera(camera) world.add_element(sphereB) world.add_element(sphereR) world.add_element(sphereG) world.add_light(light1) # world.add_light(light2) r = Renderer(world) picture = r.render(0) d = Displayer() d.display(picture)
class WorldEnv: def __init__(self, model): self.model = model self.steps = 0 self.renderer = Renderer() def render(self): self.renderer.render(self.pose) def reset(self): theta = 0.05 #random.uniform(-0.05, 0.05) self.pose = [theta, 0, 0, 0] self.steps = 0 return self.pose def step(self, action): self.steps += 1 self._calculate_next_pose(action) return self.pose, self._reward(), self._done(), 0 def _calculate_next_pose(self, action): state = np.concatenate([self.pose, action]) state = state.reshape((1, -1)) self.pose = self.model.predict(state)[0] def _reward(self): return 1 def _done(self): theta = self.pose[0] return self.steps > 200 or abs(theta) > 0.25
def run(world: World, renderer: Renderer, event_processor): entity_resource = world.get_task_data() entity_deltas = world.process_paths(entity_resource) for event in world.process_events(entity_deltas): if event.type == events.EventType.MOVE: renderer.parse_event(event) event_processor.process(event)
def render_led(self, led, color): # as a very basic quad for now! glPushMatrix() glTranslatef(led['x'], led['y'], self.config['size']['thickness']/2.0 + 0.1) # 0.1mm in front of front face Renderer.quad(color, led['w'], led['h']) glPopMatrix()
def main(): config = multiconfigparser.ConfigParserMultiOpt() stocks_config = multiconfigparser.ConfigParserMultiOpt() args = parse_args() portfolio = port.Portfolio() # read config files config.read(args.config) stocks_config.read(args.portfolio_config) # verify that config file is correct # merge options from cli and config verify_stock_keys(stocks_config) merge_config(config, args) portfolio.populate(stocks_config, args) portfolio.gen_graphs(args.independent_graphs, args.width, args.height, args.timezone) # print to the screen render_engine = Renderer(args.rounding_mode, portfolio) render_engine.render() return
def __init__(self, model, cmd_queue, resp_queue, playlist_params, params=None, server=None): self.opc = FastOPC(server) self.model = model self.params = params or EffectParameters() self.cmd_queue = cmd_queue self.resp_queue = resp_queue self.running = True self.image_dir = 'images/' # XXX pass this in from above... # Set up the first playlist. The architecture here is sort of f****d # for what I'm trying to do, but ... fixup_effects_map(model) first_playlist = self.create_first_playlist(*playlist_params) # the renderer manages a playlist (or dict of multiple playlists), as well as transitions # and gamma correction self.renderer = Renderer(playlists={'primary': first_playlist}, gamma=2.2) self._fpsFrames = 0 self._fpsTime = 0 self._fpsLogPeriod = 1 # How often to log frame rate
class GymRunner: def __init__(self): # set up environment self.env = retro.make(game='SonicTheHedgehog-Genesis', state='LabyrinthZone.Act1') # initialize renderer self.renderer = Renderer() def run(self, num_steps): # initialize environment obs = self.env.reset() aud_frame = self.env.em.get_audio() start = time.time() for i in range(num_steps): s = time.time() # obs is the video frame time.sleep(0.005) obs, rew, done, info = self.env.step( self.env.action_space.sample()) vid_frame = obs aud_frame = self.env.em.get_audio() print(info) self.renderer.render(vid_frame, aud_frame, smooth_audio=True) if done: break print(f"total time {time.time()-start}s") self.renderer.close()
def __init__(self): """Initializes game variables then begins game loop.""" self.game_map = GameMap() self.console = self.create_console() self.entities = self.create_entities() self.player = self.entities[0] self.renderer = Renderer(self.console, self.game_map) self.game_loop()
def __init__(self, max_humans=2, max_zombies=3, randomness=True, render_delay=0.05): self._max_humans = max_humans self._max_zombies = max_zombies self._randomness = randomness self._env = Environment() self._render_delay = render_delay self._renderer = Renderer(two_player=True)
def __init__(self): self.network = Network() self.mouse_pos = (0, 0) self.focus = None self.mouse_down = False self.keypresses = [] self.renderer = Renderer(flags=pg.DOUBLEBUF | pg.HWSURFACE)
class PhysicsGame(Widget): def __init__(self, **kwargs): super(PhysicsGame, self).__init__(**kwargs) self.renderer = Renderer(self) self.game_state = RUNNING self.renderer.init_physics() self.bind(size=self.renderer.update_bounds, pos=self.renderer.update_bounds) self.tools = {} for t in all_tools: self.tools[t.name] = t(self) self.current_tool = self.tools["Circle"] self.help_scheduled = False Clock.schedule_once(self.remove_help_text, HELP_MESSAGE_TIME) Clock.schedule_interval(self.step, 1 / 30.) def step(self, dt): if self.game_state == RUNNING: self.renderer.space.step(1 / 30.) self.renderer.update_objects() def on_touch_down(self, touch): self.current_tool.on_touch_down(touch) def on_touch_up(self, touch): self.current_tool.on_touch_up(touch) def on_touch_move(self, touch): self.current_tool.on_touch_move(touch) def set_tool(self, tool_name): self.current_tool = self.tools[tool_name] def toggle_game_state(self): self.game_state = RUNNING if self.game_state == PAUSED else PAUSED def game_paused(self): return self.game_state def get_space(self): return self.renderer.space def remove_help_text(self, dt, *args): self.parent.ids.help_text_label.opacity = 0 self.help_scheduled = False def show_help_text(self, text): self.parent.ids.help_text_label.text = text self.parent.ids.help_text_label.opacity = 1 if self.help_scheduled: Clock.unschedule(self.remove_help_text) self.help_scheduled = True Clock.schedule_once(self.remove_help_text, HELP_MESSAGE_TIME)
class PhysicsGame(Widget): def __init__(self, **kwargs): super(PhysicsGame, self).__init__(**kwargs) self.renderer = Renderer(self) self.game_state = RUNNING self.renderer.init_physics() self.bind(size=self.renderer.update_bounds, pos=self.renderer.update_bounds) self.tools = {} for t in all_tools: self.tools[t.name] = t(self) self.current_tool = self.tools["Circle"] self.help_scheduled = False Clock.schedule_once(self.remove_help_text, HELP_MESSAGE_TIME) Clock.schedule_interval(self.step, 1 / 30.0) def step(self, dt): if self.game_state == RUNNING: self.renderer.space.step(1 / 30.0) self.renderer.update_objects() def on_touch_down(self, touch): self.current_tool.on_touch_down(touch) def on_touch_up(self, touch): self.current_tool.on_touch_up(touch) def on_touch_move(self, touch): self.current_tool.on_touch_move(touch) def set_tool(self, tool_name): self.current_tool = self.tools[tool_name] def toggle_game_state(self): self.game_state = RUNNING if self.game_state == PAUSED else PAUSED def game_paused(self): return self.game_state def get_space(self): return self.renderer.space def remove_help_text(self, dt, *args): self.parent.ids.help_text_label.opacity = 0 self.help_scheduled = False def show_help_text(self, text): self.parent.ids.help_text_label.text = text self.parent.ids.help_text_label.opacity = 1 if self.help_scheduled: Clock.unschedule(self.remove_help_text) self.help_scheduled = True Clock.schedule_once(self.remove_help_text, HELP_MESSAGE_TIME)
class Argon(object): def __init__(self, width, height): self.width = width self.height = height self.load = ImageCache([in_module('assets'), os.getcwd(), '.']) self.default_font = self.load.font('AnonymousPro_17') self.running = False self.flags = HWSURFACE | OPENGL | DOUBLEBUF self.listeners = {} self.frame_latency = [] pygame.display.set_mode((self.width, self.height), self.flags) glEnable(GL_TEXTURE_2D) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) self.render = Renderer(self, self.default_font) def listen(self, fn): self.listeners[fn.__name__] = fn return fn def run(self): self.running = True while self.running: now = time.time() self.listeners["on_frame"](now) pygame.display.flip() self.frame_latency.append(time.time() - now) while len(self.frame_latency) > 100: self.frame_latency.pop(0) for event in pygame.event.get(): if event.type == QUIT: self.running = False event_dispatch(event, self.listeners) def clear(self, color): r, g, b, a = color glClearColor(r/255.0, g/255.0, b/255.0, a/255.0) glClear(GL_COLOR_BUFFER_BIT) def bind(self): glBindFramebuffer(GL_FRAMEBUFFER, 0) def unbind(self): pass def show_performance_log(self): latency = self.frame_latency font = self.default_font if len(latency) > 0: avg = sum(latency) / len(latency) high = max(latency) text = "avg=%.2fms high=%.2fms" % (avg * 1000, high * 1000) self.render.text((0, self.height - font.height + font.baseline), text)
def __init__(self): # 初始化 pygame pygame.init() # 初始化時間,遊戲幀數為每秒60幀 self.mainClock = pygame.time.Clock() self.mainClock.tick(60) self.tick = 0 # 初始化「繪圖」、「聲音」、「主角」 self.renderer = Renderer() self.character = Character() self.sound = Sound() self.bgm = Sound() '''遊戲參數初始化設定''' self.pause = False # 可控制遊戲暫停 self.quit = False # 可退出當前遊戲 self.pause_button = 0 # 遊戲暫停選單按鍵 self.game_over_button = 0 # 遊戲死亡選單按鍵 '''遊戲參數初始化設定結束''' '''遊戲精靈群組初始化''' self.allsprite = pygame.sprite.Group() # 精靈群組的總群組 self.bulletsprite = pygame.sprite.Group() # 子彈群組 self.bricksprite = pygame.sprite.Group() # 子彈邊界群組 self.bosssprite = pygame.sprite.Group() # 魔王群組 self.score_sprite = pygame.sprite.Group() self.shoes_sprite = pygame.sprite.Group() self.heart_sprite = pygame.sprite.Group() self.bonus_lst = [ self.score_sprite, self.shoes_sprite, self.heart_sprite ] # 突發class清單 self.direction = 0 self.num = 0 self.speed_adjust = 0 self.map_changex = 0 self.map_changey = 0 self.speed_up = False self.speed_up_time = 0 # 魔王加群組 self.boss = Boss() # boss = Boss(const.screen_width // 2 + self.map_changex, const.screen_height // 2 + self.map_changey) self.bosssprite.add(self.boss) '''遊戲精靈群組初始化結束''' self.volume_dct = { "v_0": pygame.image.load("images/volume/volume.png"), "v_1": pygame.image.load("images/volume/volume5.png"), "v_2": pygame.image.load("images/volume/volume4.png"), "v_3": pygame.image.load("images/volume/volume3.png"), "v_4": pygame.image.load("images/volume/volume2.png"), "v_5": pygame.image.load("images/volume/volume1.png"), "v_6": pygame.image.load("images/volume/volume0.png") } self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
def __init__(self, grid): self.grid = grid self.n_rows = len(grid) self.n_cols = len(grid[0]) self.positions = self._positions() self.starting_positions = [ p for p in self.positions if not self.is_terminal_state(p) ] self.renderer = Renderer(self.grid)
def __render(self): if not Renderer.render_begin(self.__field.renderer): return for game_object in self.__game_objects.values(): assert isinstance(game_object, GameObject) game_object.render() Renderer.render_end()
def clear_screen(self): """Erases the current screen with a white brush""" self._painter.save() self._painter.resetTransform() self.set_pen(0xFFFFFF) self.set_brush(0xFFFFFF) self.draw_rectangle(0, 0, self.size[0], self.size[1]) self._painter.restore() Renderer.clear_screen(self)
def clear_screen(self): """Erases the current screen with a white brush""" self._painter.save() self._painter.resetTransform() self.set_pen(0xFFFFFF) self.set_brush(0xFFFFFF) self.draw_rectangle(0,0,self.size[0],self.size[1]) self._painter.restore() Renderer.clear_screen(self)
def main(): WIDTH_SCREEN, HEIGHT_SCREEN = 800, 800 pygame.init() screen = pygame.display.set_mode((WIDTH_SCREEN, HEIGHT_SCREEN)) pygame.display.set_caption("A* Pathfinding") pygame.font.init() screen.fill((150, 150, 150)) renderer = Renderer(WIDTH_SCREEN, HEIGHT_SCREEN) # Initial call data = MapManager.load_map_from_file(1) # Main Loop while True: for event in pygame.event.get(): if event.type == pygame.QUIT: return elif event.type == pygame.MOUSEBUTTONUP: pos = pygame.mouse.get_pos() if event.button == 1: data = MapManager.write_map_with_mouse_click( data, pos, constants.STATUS_BLOCK) elif event.button == 3: data = MapManager.write_map_with_mouse_click( data, pos, constants.STATUS_DEFAULT) steps = Finder.find_path_with_astar(data) data = MapManager.draw_path_with_steps(data, steps) elif event.type == pygame.KEYDOWN: if event.key == pygame.K_KP1: data = MapManager.load_map_from_file(1) elif event.key == pygame.K_KP2: data = MapManager.load_map_from_file(2) elif event.key == pygame.K_KP3: data = MapManager.load_map_from_file(3) elif event.key == pygame.K_KP4: data = MapManager.load_map_from_file(4) elif event.key == pygame.K_KP5: data = MapManager.load_map_from_file(5) elif event.key == pygame.K_KP6: data = MapManager.load_map_from_file(6) elif event.key == pygame.K_KP7: data = MapManager.load_map_from_file(7) elif event.key == pygame.K_KP8: data = MapManager.load_map_from_file(8) elif event.key == pygame.K_KP9: data = MapManager.load_map_from_file(9) elif event.key == pygame.K_KP0: data = MapManager.load_map_from_file(0) elif event.key == pygame.K_f: steps = Finder.find_path_with_astar(data) data = MapManager.draw_path_with_steps(data, steps) renderer.render(screen, data) pygame.display.flip()
def __init__(self): self.moves = List() self.board = Board(variant="standard") self.lineup = "".join( [PIECE_TO_LETTER[piece]["white"] for piece in self.board.LINEUP]) self.white = [] self.black = [] self.output = "" self.total_moves = [[self.get_fen()]] self.renderer = Renderer()
def main(): app = Application() renderer = Renderer() renderer.register_with_app(app) #app.request_update_on_draw(Test(renderer).update) mainWindow = ui.Window(renderer, 50, 50, 300, 400) mainWindow.addWidget(ui.Button, x=20, y=20, width=50, height=60, color=(1, 0, 1, 1), text="Example Text") app.run()
def render_rectangle(renderer: Renderer, rect: Rectangle): for s in [ Point(rect.x, rect.y), Point(rect.x + rect.width, rect.y + rect.height) ]: for e in [ Point(rect.x + rect.width, rect.y), Point(rect.x, rect.y + rect.height) ]: renderer.draw_line(s, e)
def __init__(self, pos, world): world_width = world.FLOOR_WIDTH world_height = world.FLOOR_HEIGHT symbol = Symbol('@', blt.color_from_name("dark white")) super().__init__(pos[0], pos[1], symbol, 10, Faction.PLAYER) self.camera = Camera(self.x, self.y, world_width, world_height) self.world_renderer = Renderer() self.memory_map = [[None for x in range(world_width)] for y in range(world_height)] self.fov_map = [] self.update_memory_map(world)
def __init__(self, name, id): self.id = id self.name = name with file("boards/%s.yaml" % name) as config_file: self.config = yaml.load(config_file) # Load textures self.front = Renderer.load_image("boards/"+self.config['front'])[0] self.back = Renderer.load_image("boards/"+self.config['back'])[0]
def render(self): logger = self.logger if logger: logger.renderStart() Renderer.begin(self) for m in self.managers: m.render() Renderer.end(self) if logger: logger.renderEnd()
def __init__(self, game_name): self.game_name = game_name self.public_components = [] self.hidden_areas = {} self.client_mice = {} self.holding_something = {} self.renderer = Renderer() self.load_game()
def render(self, r: Renderer) -> None: c = self.get_center_point() a = GeometryUtil.distance_from_point(c, self.get_right_point()) b = GeometryUtil.distance_from_point(c, self.get_bottom_point()) points = [] n_points = 72 for x in range(n_points + 1): points.append( Point(c.x + a * math.cos(x * 2 * math.pi / n_points), c.y + b * math.sin(x * 2 * math.pi / n_points))) r.fill_polygon(points)
def main_menu(): img = libtcod.image_load('img/menu_background1.png') while not libtcod.console_is_window_closed(): Renderer.render_main_screen(img) choice = Renderer.menu('', ['Play a new game', 'Continue current game', 'Quit'], 24, 0) if choice == 0: Renderer.render_main_screen(img) races = race_decoder.decode_all_races() race = Renderer.menu('Pick a race', races, 15, 0) if race is None: continue Renderer.render_main_screen(img) jobs = job_decoder.decode_all_jobs() job = Renderer.menu('Pick a job', jobs, 15, 0) if job is None: continue Game.new_game(races[race].lower(), jobs[job].lower()) Game.run() elif choice == 1: try: Game.run() except: Game.msgbox('\n No saved game to load.\n', 24) continue elif choice == 2: break
def get(self): """Handle a GET request for the page.""" if IS_CACHING_ON and self.is_cached: with open(self.cached_name) as cachefile: page = cachefile.read() else: renderer = Renderer(view=self) page = renderer.render() if IS_CACHING_ON: self.write_page_to_cache(page) print "Content-type:text/html\n", page
def main(): app = Application() renderer = Renderer() renderer.register_with_app(app) app.request_update_on_draw(Test(renderer).update) r = Renderer.Rectangle(1, 2, 20, 30, renderer=renderer) try: r = Renderer.Rectangle(40, 40, 20, 30) except: pass app.run()
def next_level(): Game.message('You take a moment to rest, and recover your strength.', libtcod.light_violet) Game.player.fighter.heal(.5) Game.player.job.regen_mana(.5) Game.message('You descend deeper into the heart of the dungeon...', libtcod.red) Game.dungeon_level += 1 Game.map = Map(Game.MAP_WIDTH, Game.MAP_HEIGHT) Game.player.x = Game.map.origin[0] Game.player.y = Game.map.origin[1] Game.map.add_object(Game.player) Renderer.clear_console() Game.renderer.map = Game.map
def set_canvas(self, DC): # Reset cached brushes & pens self._pens = {} self._brushes = {} # Set dc self._dc = DC self._gc = wx.GraphicsContext.Create(self._dc) w, h = self._get_canvas_size(DC) # Set correct x & y axes directions self._gc.Scale(1,-1) self._gc.Translate(0, -h) self._grid_pen = self._gc.CreatePen(self._dc_grid_pen) Renderer.set_canvas(self,DC)
def main(): win = Window(fullscreen=True, visible=False) camera = Camera(win.width, win.height, (0, 0), 100) renderer = Renderer() maze = Maze() maze.create(50, 30, 300) keyboard = Keyboard() keyboard.key_handlers[key.ESCAPE] = win.close keyboard.key_handlers.update(camera.key_handlers) clock.schedule(maze.update) win.on_draw = lambda: renderer.on_draw(maze, camera, win.width, win.height) win.on_key_press = keyboard.on_key_press keyboard.print_handlers() win.set_visible() app.run()
def run(self, rhoNo=1, phiNo=1, tfNo=1): dataset = Dataset(rhoNo, phiNo, tfNo) self.numFiles = 0 renderer = Renderer(self.eye, self.screen) numTextures = self.numTextures rho = dataset.rho phi = dataset.phi tf = dataset.tf phiPlane = SplinePlane(phi, self.splineInterval, 1e-5) boundingBox = phiPlane.createBoundingBox() refSplineModel = SplineModel(tf, phiPlane, rho, self.refTolerance) voxelModels = np.empty(numTextures, dtype=object) for i in range(numTextures): texDimSize = self.texDimSizes[i] if voxelio.exist(dataset, texDimSize, texDimSize): samplingScalars = voxelio.read(dataset, texDimSize, texDimSize) print "Read {}x{} texture data from file".format(texDimSize, texDimSize) else: samplingScalars = refSplineModel.generateScalarMatrix(boundingBox, texDimSize, texDimSize, self.voxelizationTolerance) voxelio.write(dataset, samplingScalars) print "Wrote {}x{} texture data to file".format(texDimSize, texDimSize) scalarTexture = Texture2D(samplingScalars) voxelModels[i] = VoxelModel(tf, scalarTexture, boundingBox) printflush("Rendering reference... ") renderData = RenderData(ModelType.REFERENCE, self.viewRayDelta) renderData.renderResult = renderer.render(refSplineModel, self.viewRayDelta) self.save(dataset, renderData) print "Done!" for i, texSize in enumerate(self.texDimSizes): delta = self.viewRayDelta printflush("Rendering voxelized ({0}x{0})...".format(texSize)) renderData = RenderData(ModelType.VOXEL, delta=delta, texSize=texSize) renderData.renderResult = renderer.render(voxelModels[i], delta) self.save(dataset, renderData) print "Done!"
class ProcessHandler(webapp.RequestHandler): def __init__(self): self.template_renderer = Renderer('process.html') self.user_handler = UserHandler() self.user_obj = None def setUser(self): self.user_obj = self.user_handler.handleUser() def get(self, step): self.setUser() #self.response.out.write('in step %s' % step) if step == PROCESS_STEP_1_START: return self.ProcessStep1() elif step == PROCESS_STEP_2_EXECUTE: return self.ProcessStep2() else: pass def ProcessStep1(self): self.template_renderer.template_values['process_step'] = '1' self.template_renderer.template_values['next_step'] = PROCESS_STEP_2_EXECUTE self.render() def ProcessStep2(self): self.template_renderer.template_values['process_step'] = '2' self.render() def render(self): self.template_renderer.template_values['token'] = self.user_obj.spreadsheet_session_token self.response.out.write(self.template_renderer.render())
def check_level_up(): level_up_exp = Game.get_exp_to_level() while Game.player.fighter.xp >= level_up_exp: Game.player.level += 1 Game.player.fighter.xp -= level_up_exp Game.message('Your battle skills grow stronger! You reached level ' + str(Game.player.level) + '!', libtcod.yellow) choice = None while choice is None: choice = Renderer.menu('Level up! Choose a stat to raise:\n', ['+20 HP, from (' + str(Game.player.fighter.max_hp) + ')', '+10 MP, from (' + str(Game.player.job.max_mp) + ')', '+1 attack, from (' + str(Game.player.fighter.power) + ')', '+1 dexterity, from (' + str(Game.player.fighter.dexterity) + ')'], Renderer.LEVEL_SCREEN_WIDTH) if choice == 0: Game.player.fighter.base_max_hp += 20 Game.player.fighter.hp += 20 elif choice == 1: Game.player.job.base_max_mp += 10 Game.player.job.mp += 10 elif choice == 2: Game.player.fighter.base_power += 1 elif choice == 3: Game.player.fighter.base_dexterity += 1 Game.renderer.render_all()
def __init__(self): self.update({ 'theme': Config.get('global', 'theme'), 'template': 'page', 'menus': Menus }) self.renderer = Renderer()
def set_canvas(self, canvas): """Tell the renderer to draw on canvas The type of canvas is implementation-dependent""" if self._painter is not None: self._painter.restore() self._painter.restore() self._painter.end() self._paintdevice = canvas self._painter = QPainter(canvas) self._painter.setRenderHint(QPainter.Antialiasing) # invert the y axis self._painter.scale(1,-1) self._painter.translate(0,-canvas.height()) Renderer.set_canvas(self,canvas)
def __init__(self): SDL_Init(SDL_INIT_VIDEO) self.evtMngr = EventManager() self.scene = Scene(self.evtMngr) self.renderer = Renderer(self.evtMngr, 1000, 800) self.evtMngr.attachHandler(E_SDL_EVENT, self.onSDLEvent)
def render(self): """Renders the contents of this post to be viewed in the browser""" # title output = ['\n', '<h1><a href="?post=%s">%s</a></h1>' % (self.metadata.timestamp, self.metadata.title), '\n'] # content renderer = Renderer(self.metadata.location) content = self.read_content() output.append(renderer.render(content)) # categories output.append('<p><small>Posted on ') [output.append('<a href="?category=%s">%s</a> ' % (category, category)) for category in self.metadata.categories] output.append('</small></p>') return ''.join(output)
def start(options, imageFinder): pygame.init() screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN | pygame.DOUBLEBUF | pygame.HWSURFACE) if not options.debug: pygame.mouse.set_visible(0) process = psutil.Process(os.getpid()) slideLoader = SlideLoader(process, screen, imageFinder, options.minimumBufferLength, options.maxMemoryUsage) slideLoader.start() renderer = Renderer(process, screen, slideLoader, options.fps, options.debug) renderer.start() clock = pygame.time.Clock() quit = False while not quit: clock.tick(5) for event in pygame.event.get(): if event.type == pygame.QUIT: quit = True elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE: quit = True slideLoader.stop() renderer.stop() slideLoader.join() renderer.join()
def job_menu(header): options = [] abilities = [ability for ability in Game.player.job.abilities if ability['level'] <= Game.player.level] for ability in abilities: text = ability['name'] + ' (' + str(ability['cost']) + ')' options.append(text) index = Renderer.menu(header, options, Renderer.INVENTORY_WIDTH) if index is None: return None return Game.player.job.abilities[index]
def __init__(self): global inputHandlers inputHandlers = dict((k, types.MethodType(v, self, Game)) for k, v in inputHandlers.items()) self.renderer = Renderer(self) self.size = self.renderer.size self.hsize = self.renderer.hsize self.level = Level.spawn(self, 0) self.player = Player(self) self.worldOff = self.player.pos self.enemies = [] self.bullets = [] self.keys = {}
def __init__(self, title): pygame.init() pygame.display.set_caption(title) self.running = False self.clock = pygame.time.Clock() self.renderer = Renderer() self.world = b2World(gravity=(0,-10), doSleep=True) self.renderer.setupDebugDraw(self.world) self.gameObjects = [] body = self.world.CreateDynamicBody(position=(10,-10)) box = body.CreatePolygonFixture(box=(1,1), density=1, friction=0.3) self.player = self.createObject(physics=box)
class Game: FRAMES_PER_SECOND = 60 def __init__(self, title): pygame.init() pygame.display.set_caption(title) self.running = False self.clock = pygame.time.Clock() self.renderer = Renderer() self.world = b2World(gravity=(0,-10), doSleep=True) self.renderer.setupDebugDraw(self.world) self.gameObjects = [] body = self.world.CreateDynamicBody(position=(10,-10)) box = body.CreatePolygonFixture(box=(1,1), density=1, friction=0.3) self.player = self.createObject(physics=box) def run(self): self.running = True while self.running: self.loop() pygame.quit() sys.exit() def loop(self): time = self.clock.tick(self.FRAMES_PER_SECOND) self.processEvents(pygame_sdl2.event.get()) self.world.Step(1.0/self.FRAMES_PER_SECOND, 6, 2) self.update() self.renderer.gameWillRender() self.render() self.world.DrawDebugData() self.renderer.gameDidRender() def processEvents(self, events): for event in events: if event.type == QUIT: self.running = False def update(self): for obj in self.gameObjects: obj.update() def render(self): for obj in self.gameObjects: obj.render(self.renderer) def createObject(self, physics=None, renderable=None): gameObject = GameObject(game=self, physics=physics, renderable=renderable) self.gameObjects.append(gameObject) return gameObject
def inventory_menu(header): if len(Game.player.inventory) == 0: options = ['Inventory is empty.'] else: options = [] for item in Game.player.inventory: text = item.name if item.equipment and item.equipment.is_equipped: text = text + ' (on ' + item.equipment.slot + ')' options.append(text) index = Renderer.menu(header, options, Renderer.INVENTORY_WIDTH) if index is None or len(Game.player.inventory) == 0: return None return Game.player.inventory[index].item