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