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