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 main(filename): with open(filename) as f: [unscrambled, scrambled] = parse([line.strip() for line in f.readlines()]) renderer = Renderer() renderer.singleFrame(scrambled.getArr()) renderer = Renderer() renderer.singleFrame(unscrambled.getArr())
def build(self): renderer = Renderer() controller = Controller(renderer=renderer) ui = UI(renderer=renderer, controller=controller) controller.setUI(ui) return ui
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
def main_loop(window): global sm width, height = sm.get_dimensions() # create projection matrix proj_matrix = glm.perspective(glm.radians(90), width / height, 0.1, 10000) glEnable(GL_MULTISAMPLE) renderer = Renderer() renderer.set_projection_matrix(proj_matrix) renderer.setup_hdr_buffer(sm) previous_time = 0.0 current_time = 0.0 while (glfw.get_key(window, glfw.KEY_ESCAPE) != glfw.PRESS and not glfw.window_should_close(window)): delta = current_time - previous_time previous_time = current_time sm.update(delta) current_time = glfw.get_time() # renderer.regular_render_scene(sm) renderer.render_scene_to_hdr(sm, exposure=1.0) glfw.swap_buffers(window) glfw.poll_events()
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): pygame.init() self.click = False self.renderer = Renderer() # self.game = Game() self.sound = Sound() self.main_menu()
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, 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 __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 run(spec: str, template_dir: str, output_path: str, pdf_output=False): """ Main function to compile `spec` with the templates located in `template_dir`. Args: spec (str): Name of the JSON specification file. template_dir (str): Path to the template dir. output_path (str): Path to the output file. pdf_output (bool): Boolean indicating wether to generate a pdf graph. """ input_file = json.load(open(spec)) module_list = input_file.get('modules', []) render = Renderer(module_list, template_dir) render.check_integrity() if pdf_output: render.render_pdf_graph() for mod in render.named_modules: print(mod, render.named_modules[mod].get_out_type()) modules, ext_modules = render.get_rendered() final_env = Environment(loader=FileSystemLoader(BASE_DIR)) final = final_env.get_template(TEMPLATE_NAME) object_name = output_path.split('/')[-1].split('.')[0] with open(output_path, 'w') as outfile: outfile.write(final.render(name=object_name, modules=modules, ext_modules=ext_modules))
def __init__(self, nt=4, stride_to_hidden=2, nf_to_hidden=64, nf_enc=128, stride_to_obs=2, nf_to_obs=128, nf_dec=64, nf_z=3, nf_v=1): super(JUMP, self).__init__() # The number of DRAW steps in the network. self.nt = nt # The kernel and stride size of the conv. layer mapping the input image to the LSTM input. self.stride_to_hidden = stride_to_hidden # The number of channels in the LSTM layer. self.nf_to_hidden = nf_to_hidden # The number of channels in the conv. layer mapping the input image to the LSTM input. self.nf_enc = nf_enc # The kernel and stride size of the transposed conv. layer mapping the LSTM state to the canvas. self.stride_to_obs = stride_to_obs # The number of channels in the hidden layer between LSTM states and the canvas self.nf_to_obs = nf_to_obs # The number of channels of the conv. layer mapping the canvas state to the LSTM input. self.nf_dec = nf_dec # The number of channels in the stochastic latent in each DRAW step. self.nf_z = nf_z # Encoder network self.m_theta = Encoder(nf_v=nf_v) # DRAW self.prior = Prior(stride_to_hidden, nf_to_hidden, nf_enc, nf_z) self.posterior = Posterior(stride_to_hidden, nf_to_hidden, nf_enc, nf_z) # Renderer self.m_gamma = Renderer(nf_to_hidden, stride_to_obs, nf_to_obs, nf_dec, nf_z, nf_v) self.transconv = nn.ConvTranspose2d(nf_to_obs, 3, kernel_size=4, stride=4)
def run(): # entities entity_manager = entity.EntityManager() entity_manager.generate_random(10000) entity_manager.set_dimension_values([(2, 0)]) # tasks task_manager = sim.taskmanager.TaskManager(entity_manager.get_ids()) tasks = [ sim.taskmanager.Task("Hunt", sim.taskmanager.TaskType.GATHER), sim.taskmanager.Task("Cook", sim.taskmanager.TaskType.ACTIVITY), sim.taskmanager.Task("Clean", sim.taskmanager.TaskType.ACTIVITY), sim.taskmanager.Task("Gather Water", sim.taskmanager.TaskType.GATHER), ] task_manager.randomly_assign(tasks) # terrain terrain = sim.world.Terrain([ sim.world.Resource("Hunt", 2, entity.Point(-55, -33, 0)), sim.world.Resource("Cook", 4, entity.Point(15, 25, 0)), sim.world.Resource("Clean", 2, entity.Point(0, 0, 0)), sim.world.Resource("Gather Water", 100, entity.Point(5, 5, 0)), ]) # renderer renderer = Renderer() event_processor = EventProcessor() # run sim world = sim.world.World(terrain, entity_manager, task_manager) while True: sim.world.run(world, renderer, event_processor) time.sleep(0.16)
def main(): import argparse parser = argparse.ArgumentParser( description='Show images directly on terminal.') parser.add_argument("Image", help="the directory of the image which will be opened") parser.add_argument("-w", "--width", help="image width on the terminal", type=int) parser.add_argument( "-i", "--interactive", default=False, action='store_true', help="open image in interactive mode", ) args = parser.parse_args() r = Renderer(args.Image, XTERM_PALLETTE, wsize=args.width) if r.error == None: r.render() r.show(interactive=args.interactive)
def __init__(self): # set up environment self.env = retro.make(game='SonicTheHedgehog-Genesis', state='LabyrinthZone.Act1') # initialize renderer self.renderer = Renderer()
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)
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 test_relative_import(self): "Ensure that we can import relatively" kwargs = self.get_args() kwargs["url:config"] = "tests/urlconf.py" self.renderer = self.extension_cls(Renderer(cwd="/tmp/"), **kwargs) urls = self.renderer.get_urls() self.assertEqual(urls, [("test", {}, "test")])
def test_prefix(self): "Ensure that the prefix parameter for config works" kwargs = self.get_args() kwargs["url:base_url"] = "http://google.com/" self.renderer = self.extension_cls(Renderer(cwd="/tmp/"), **kwargs) self.assertEqual(self.renderer.get_url("contact"), "http://google.com/contact")
def __init__(self) -> None: """Class constructor.""" # load version try: with open("version", "r") as file: version = file.readline().strip() except Exception: version = "1.0" # init pygame framework pygame.init() # define class vars self.__screen_size: Tuple[int, int] = (1000, 700) self.__screen: Surface = pygame.display.set_mode(self.__screen_size) self.__clock: Clock = Clock() self.__renderer: Renderer = Renderer(version, self.__screen_size, self.__screen, self.__clock) self.__matrix: Matrix = Matrix() self.__stats: GameStats = GameStats() self.__level_drop_intervals: List[float] = [] interval = 2.0 for _ in range(0, 10): interval *= 0.8 self.__level_drop_intervals.append(interval)
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)
def make_dataset(count=1000): from HER.envs import baxter_orient_left_cts_base env = baxter_orient_left_cts_base.BaxterEnv() renderer = Renderer(env) data = MujocoData(renderer) data.load_mujoco(count) data.prepare() return data
def main(args): if "filename" in args: parser = FileParser(args.filename) else: parser = NetParser(args.host, args.port) renderer = Renderer(args.pixels, args.mass, parser) window = Window(args.fps, renderer) window.mainloop()
def main(): rom = file_explorer() if rom is None: sys.exit() renderer = Renderer() keyboard = Keyboard() cpu = Cpu(renderer, keyboard) game_starter(rom, cpu, renderer, keyboard)
def test_render_fails_if_translation_cannot_be_found(self) -> None: with patch.object(TemplateProvider, 'get_template', return_value=etree.HTML('<p><fah-text>Unknown Text</fah-text></p>')) as template, \ patch.object(TranslationProvider, 'translate', return_value=None) as translate: renderer = Renderer(template_provider=TemplateProvider(), translation_provider=TranslationProvider()) self.assertRaises(MissingTranslationException, renderer.render, 'some_page', 'any') template.assert_called_with('some_page') translate.assert_called_with('any', 'Unknown Text')
def test_dead_human(self): dead_human = Character(LifeState.DEAD) world = World( width=3, height=1, positions=[(Point(1, 0), dead_human)], ) renderer = Renderer(world) assert renderer.lines == [". \U0001F480 . "]
def main(window): sys.excepthook = onexception logging.basicConfig(filename='app.log', format='%(name)s - %(levelname)s - %(message)s', level=logging.INFO) renderer = Renderer() gameloop = GameLoop(renderer) gameloop.start()