def calculate_image(triangles, colors, render_to_window=False):
renderer = Renderer() # should be trivial assignment from locally stored instance
renderer.data(
triangles,
np.tile(colors, (1, 3)).reshape((-1, 4))
)
return renderer.render(render_to_window=render_to_window)
def render_document():
request_data = json.loads(request.data)
template_name = request_data['template_name']
CWD = os.getcwd()
data_path = '{0}/{1}'.format(CWD, 'data.json')
file = open(data_path, 'r')
data_string = file.read()
file.close()
data = json.loads(data_string)
renderer = Renderer(template_name, data)
rendered_html_document = renderer.render_html()
rendered_pdf_document = renderer.render_pdf(rendered_html_document)
html_file_path = '{0}/output/{1}'.format(
CWD, 'Rendered_{0}.html'.format(template_name))
html_file = open(html_file_path, 'w')
html_file.write(rendered_html_document)
html_file.close()
pdf_file_path = '{0}/output/{1}'.format(
CWD, 'Rendered_{0}.pdf'.format(template_name))
pdf_file = open(pdf_file_path, 'wb')
pdf_file.write(rendered_pdf_document)
pdf_file.close()
return 'Documents Rendered!'
def get(self):
items_q = Items.all()
template_values = {
'items' : items_q
}
page = Renderer(self, 'ediciones.html')
page.render(template_values)
class Test(unittest.TestCase):
def setUp(self):
pygame.init() # @UndefinedVariable
screen = pygame.display.set_mode((PRAM.DISPLAY_WIDTH, PRAM.DISPLAY_HEIGHT))
buttonMap = ButtonMap()
actor = SimpleBox()
musicPlayer, soundPlayer = soundPlayerFactory()
self.renderer = Renderer(screen)
player = playerFactory(actor)
self.game = Game(player, musicPlayer, soundPlayer, self.renderer)
self.inputHandler = InputHandler(self.game, player, buttonMap)
self.eventHandler = EventHandler(self.game)
self.game.eventHandler = self.eventHandler
self.game.inputHandler = self.inputHandler
def test_renderScenery(self):
self.game.gameStartup()
self.eventHandler.handleEvents()
self.renderer.renderScenery(self.game.gameScene.sceneryWrapper)
pygame.display.flip()
def test_renderActors(self):
self.game.gameStartup()
self.game.addEvent(EventLoadLevel(PRAM.LEV_TEST1))
self.eventHandler.handleEvents()
self.renderer.renderActors(self.game.gameScene.actorsWrapper)
pygame.display.flip()
def render(self):
Renderer.rect(0, 0, self.width, self.height,
color='#F1E7DC') # background
grid_gap = min(self.width / self.grid.cols,
self.height / self.grid.rows)
self.grid.render(self.width, self.height, grid_gap)
for cell in self.grid.cells:
if cell.is_alive:
cell.render(grid_gap)
def get(self):
blogPosts_query = blogPost.all().order('-date')
blogPosts = blogPosts_query.fetch(10)
template_values = {
'blogPosts' : blogPosts
}
page = Renderer(self, 'news.html')
page.render(template_values)
def __init__(self, grid):
# fill in missing cells
max_width = max(len(row) for row in grid)
for row in grid:
row += [None for _ in range(max_width - len(row))]
self.grid = grid
self.n_rows = len(grid)
self.n_cols = len(grid[0])
self.positions = self._positions()
self.renderer = Renderer(self.grid)
def __init__(self):
self.main_window = Window(100, 100)
self.game = Game(self.main_window.width, self.main_window.height)
self.canvas = tk.Canvas(self.main_window,
width=self.game.width,
height=self.game.height,
bg='#EEE',
highlightthickness=0)
self.canvas.pack()
self.bind_keys()
Renderer.set_canvas(self.canvas)
def setUp(self):
pygame.init() # @UndefinedVariable
screen = pygame.display.set_mode((PRAM.DISPLAY_WIDTH, PRAM.DISPLAY_HEIGHT))
buttonMap = ButtonMap()
actor = SimpleBox()
musicPlayer, soundPlayer = soundPlayerFactory()
self.renderer = Renderer(screen)
player = playerFactory(actor)
self.game = Game(player, musicPlayer, soundPlayer, self.renderer)
self.inputHandler = InputHandler(self.game, player, buttonMap)
self.eventHandler = EventHandler(self.game)
self.game.eventHandler = self.eventHandler
self.game.inputHandler = self.inputHandler
def get_renderer(self):
renderer = Renderer()
for item in self._get_all_items():
if item.data(CustomDataRole.ITEMTYPE) == TreeWidgetType.ALBUM:
renderer.add_render_album_job(item)
elif item.data(CustomDataRole.ITEMTYPE) == TreeWidgetType.SONG:
renderer.add_render_song_job(item)
return renderer
def __init__(self):
from ambry.library import Library
from render import Renderer
from ambry.run import get_runconfig
rc = get_runconfig()
self.library = Library(rc, read_only=True, echo = False)
self.renderer = Renderer(self.library)
import logging
path = self.library.filesystem.logs()
logging.basicConfig(filename=path, level=logging.DEBUG)
def __init__(self, rendererPath='./data', loadingTarget=True):
self.crane_list = []
self.target_list = []
self.data = loadData()
self.loadingTarget = loadingTarget
if loadingTarget:
self.target_data0 = loadTargetData()
self.target_data = None
for line in self.data:
crane = Crane()
crane.ID = line[0]
crane.x = line[1]
crane.y = line[2]
crane.R1 = line[3]
crane.R2 = line[4]
self.crane_list.append(crane)
for crane in self.crane_list:
target = Target(crane)
self.target_list.append(target)
self.observation_space = 4 * len(
self.crane_list
) # (arm_theta, delta_theta, arm_omega) * of other cranes
self.action_space = 3
self.reward_sharing_ratio = 0.1
self.collision_pairs = [(0, 1), (0, 2), (2, 3), (1, 3)]
self.t = 0
self.max_t = 720
self.score = 0
self.collision = False
self.renderer = Renderer(rendererPath)
self.reset()
def main(args):
sdl2.ext.init()
ip = args[1]
port = int(args[2])
num = args[3]
num_windows = int(args[4])
client = Client(ip, port, num)
events = Events()
renderer = Renderer('looongpooong', (800, 600), num_windows)
game = Game(client, events, renderer)
game.start()
return 0
class AmbryAppContext(object):
"""Ambry specific objects for the application context"""
def __init__(self):
from ambry.library import Library
from render import Renderer
from ambry.run import get_runconfig
rc = get_runconfig()
self.library = Library(rc, read_only=True, echo = False)
self.renderer = Renderer(self.library)
import logging
path = self.library.filesystem.logs()
logging.basicConfig(filename=path, level=logging.DEBUG)
def render(self, template, *args, **kwargs):
return self.renderer.render(template, *args, **kwargs)
class Environment():
def __init__(self, grid):
# fill in missing cells
max_width = max(len(row) for row in grid)
for row in grid:
row += [None for _ in range(max_width - len(row))]
self.grid = grid
self.n_rows = len(grid)
self.n_cols = len(grid[0])
self.positions = self._positions()
self.renderer = Renderer(self.grid)
def actions(self, pos):
"""possible actions for a state (position)"""
r, c = pos
actions = ['stay']
if r > 0 and self.grid[r - 1][c] is not None:
actions.append('up')
if r < self.n_rows - 1 and self.grid[r + 1][c] is not None:
actions.append('down')
if c > 0 and self.grid[r][c - 1] is not None:
actions.append('left')
if c < self.n_cols - 1 and self.grid[r][c + 1] is not None:
actions.append('right')
return actions
def value(self, pos):
r, c = pos
return self.grid[r][c]
def render(self, pos=None):
return self.renderer.render(pos)
def _positions(self):
"""all valid positions"""
positions = []
for r, row in enumerate(self.grid):
for c, _ in enumerate(row):
if self.grid[r][c] is not None:
positions.append((r, c))
return positions
def __init__(self):
self.layout = Layout().init_layout()
self.border = self.layout.field["border"]
self.field = Point(x=self.border.x, y=self.border.y-1)
self.screen = self.create_window(x=self.border.x, y=self.border.y)
#utils.
self.renderer = Renderer()
self.spaceship = Spaceship(self.layout.field["spaceship"], self.field, self)
self.renderer.add_object(self.spaceship)
#gui
self.hbar = Bar("Hull", self.layout.gui["hbar"], self.spaceship.get_hinfo, self.spaceship.max_hull)
self.sbar = Bar("Shield", self.layout.gui["sbar"], self.spaceship.get_sinfo, self.spaceship.max_shield)
#temp... or not?
self.sbar.status_style["good"] = curses.color_pair(Color.sh_ok) | curses.A_BOLD
self.sbar.status_style["dmgd"] = curses.color_pair(Color.sh_mid) | curses.A_BOLD
self.renderer.add_object(self.hbar)
self.renderer.add_object(self.sbar)
def main(*args):
if (not args) or '--help' in args:
return usage()
cache_main, *args = list(args)
cache_add = tiles_path = world_name = worlds_json_path = batch_key = ''
only_worlds = set()
ignored_worlds = ['spawn', 'ulca']
flags = ''
while len(args) > 0 and '-' == args[0][0]:
new_flags, *args = args
if 'd' in new_flags or 'm' in new_flags:
cache_add, *args = args
if 't' in new_flags or 'z' in new_flags:
tiles_path, *args = args
if 'b' in new_flags:
world_name, tiles_json_path, *args = args
if 'k' in new_flags:
batch_key, *args = args
if 'o' in new_flags:
new_only, *args = args
only_worlds = only_worlds.union(new_only.split(','))
if 'i' in new_flags:
new_ignored, *args = args
ignored_worlds += new_ignored.split(',')
flags += new_flags
if args:
print('Leftover args:', *args)
return usage()
print('Ignored worlds:', ','.join(ignored_worlds))
if only_worlds: print('and all except', ','.join(only_worlds))
batch_id = str(time.time()) + batch_key
world_names = set(os.listdir(cache_main))
if cache_add:
world_names = world_names.union(shard_names[w]
for w in os.listdir(cache_add)
if w in shard_names)
for world_name in world_names:
if only_worlds and world_name not in only_worlds:
continue
if world_name in ignored_worlds:
continue
if world_name not in shard_ids:
print('Unknown world', world_name)
continue
world_id = shard_ids[world_name]
print('Processing world', world_name, world_id)
world_main = cache_main + '/' + world_name
world_tiles = tiles_path + '/' + world_name
if 'd' in flags or 'm' in flags:
try:
world_add = get_cache_path(cache_add + '/' + world_id)
except FileNotFoundError as e:
print('ERROR', e.__class__.__name__, e)
continue
if 'd' in flags:
diff_img = 'diffs/diff-%s/diff-%s.png' % (batch_id, world_name)
print('Creating diff image at', diff_img)
os.makedirs('diffs/diff-%s' % batch_id, exist_ok=True)
try:
diff_worlds(diff_img, world_main, world_add)
except FileNotFoundError as e:
print('ERROR', e.__class__.__name__, e)
continue
if 'm' in flags:
print('Merging from', world_add)
try:
merge_worlds(world_main, world_main, world_add, by_time=True)
except FileNotFoundError as e:
print('ERROR', e.__class__.__name__, e)
continue
if 't' in flags:
r = Renderer(world_main, get_simple_block_color)
r.render_tiles(world_tiles)
print_missing_blocks()
if 'z' in flags:
try:
for i in range(3):
print('Creating zoomed-out tiles, level', -i - 1)
stitch_all('%s/z%i' % (world_tiles, -i - 1),
'%s/z%i' % (world_tiles, -i))
except (FileNotFoundError, IndexError) as e:
print('ERROR', e.__class__.__name__, e)
if 'b' in flags:
print('Writing bounds to', tiles_json_path)
write_bounds(world_name, world_main, tiles_json_path)
environment = Environment(preset.lasers, obstacles, preset.max_laser_length,
preset.safe_vel, preset.safe_angle)
# Initialise None lists in environment and drone
environment.update(drone, False)
drone.recieveLaserDistances(environment.laser_distances)
# Initialise Renderer and Plots
#Render Window limits
draw_scene = True # Flag to draw live simulation
draw_graphs = False # Flag to draw live data stream
draw_final_graph = True # Flag to show data at the end of simulation
xlims = [-11, 11]
ylims = [0, 40]
renderer = Renderer(obstacles, drone, xlims, ylims, draw_scene)
data_stream = DataStream(preset.input_limit, draw_graphs)
#Simulation
collision = False
total_t = 0
def loadStabiliser(N):
# Load stabiliser network
local_dir = os.path.dirname(__file__)
folder_paths = [
'first_stabiliser', 'second_stabiliser', 'third_stabiliser',
'fourth_stabiliser', 'fifth_stabiliser'
]
from render import Renderer
SPEED = 16
INPUT = {
pygame.K_UP: 'up',
pygame.K_DOWN: 'down',
pygame.K_RIGHT: 'right',
pygame.K_LEFT: 'left'
}
done = False
clock = pygame.time.Clock()
direction = 'none'
frame = 1
tetris = Game()
drawer = Renderer()
while not done:
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
elif event.type == pygame.KEYDOWN:
if tetris.game_over:
if event.key == pygame.K_SPACE:
tetris.__init__()
tetris.game_over = False
else:
try:
direction = INPUT[event.key]
except:
pass
elif event.type == pygame.KEYUP:
import ctypes
import random
import time
from render import Window, SDL_SetWindowIcon, IMG_Load, Renderer, SpriteFactory, SDL_SetRenderDrawColor, \
SDL_RenderClear, SDL_SetTextureAlphaMod, SDL_RenderPresent, SDL_Event, SDL_QUIT, SDL_PollEvent, SDL_Delay, \
SDL_Color, TTF_OpenFont, TTF_RenderUTF8_Blended_Wrapped, SDL_FreeSurface, SDL_BLENDMODE_ADD, \
SDL_SetTextureBlendMode, SDL_CreateTextureFromSurface, SDL_RenderCopy, SDL_Rect, SDL_QueryTexture, TTF_Init, \
Mix_OpenAudio, MIX_DEFAULT_FORMAT, Mix_VolumeMusic, Mix_PlayMusic, Mix_LoadMUS, SDL_TEXTINPUT, SDL_TEXTEDITING, \
SDL_SetTextureColorMod, SDL_RenderDrawLine, SDL_RenderDrawPoint, SDL_KEYUP, SDL_GetKeyName
if __name__ == "__main__":
window = Window("🐍 贪吃蛇 🐍 🐕 🐱 🐻 🐏", size=(960, 640))
renderer = Renderer(window)
factory = SpriteFactory(renderer)
bg = factory.create("./data/block.png")
body = factory.create("./data/body.png")
head = factory.create("./data/head.png")
h1 = factory.create("./data/1.png")
tri = factory.create("./data/tri.png")
water_drop = factory.create("./data/water_drop.png")
circle = factory.create("./data/circle.png")
TTF_Init()
font = TTF_OpenFont('data/b.ttf'.encode("utf8"), 30)
text = "🐍 贪吃蛇 🐍 🐕 🐱 🐻 🐏"
text_surface = TTF_RenderUTF8_Blended_Wrapped(
font,
text.replace(" ", "\n").encode("utf8"), SDL_Color(255, 0, 0, 255), 255)
text_texture = SDL_CreateTextureFromSurface(renderer.renderer,
def renderer(content_type='html'):
from render import Renderer
return Renderer(content_type=content_type)
class App(object):
def __init__(self):
self.layout = Layout().init_layout()
self.border = self.layout.field["border"]
self.field = Point(x=self.border.x, y=self.border.y-1)
self.screen = self.create_window(x=self.border.x, y=self.border.y)
#utils.
self.renderer = Renderer()
self.spaceship = Spaceship(self.layout.field["spaceship"], self.field, self)
self.renderer.add_object(self.spaceship)
#gui
self.hbar = Bar("Hull", self.layout.gui["hbar"], self.spaceship.get_hinfo, self.spaceship.max_hull)
self.sbar = Bar("Shield", self.layout.gui["sbar"], self.spaceship.get_sinfo, self.spaceship.max_shield)
#temp... or not?
self.sbar.status_style["good"] = curses.color_pair(Color.sh_ok) | curses.A_BOLD
self.sbar.status_style["dmgd"] = curses.color_pair(Color.sh_mid) | curses.A_BOLD
self.renderer.add_object(self.hbar)
self.renderer.add_object(self.sbar)
def create_window(self, x, y, a=0, b=0):
curses.initscr()
curses.start_color()
#user interface
curses.init_pair(Color.ui_norm, curses.COLOR_WHITE, curses.COLOR_BLACK)
curses.init_pair(Color.ui_yellow, curses.COLOR_YELLOW, curses.COLOR_BLACK)
#damage panel
curses.init_pair(Color.dp_blank, curses.COLOR_BLACK, curses.COLOR_BLACK)
curses.init_pair(Color.dp_ok, curses.COLOR_WHITE, curses.COLOR_GREEN)
curses.init_pair(Color.dp_middle, curses.COLOR_WHITE, curses.COLOR_YELLOW)
curses.init_pair(Color.dp_critical, curses.COLOR_WHITE, curses.COLOR_RED)
curses.init_pair(Color.sh_ok, curses.COLOR_WHITE, curses.COLOR_BLUE)
curses.init_pair(Color.sh_mid, curses.COLOR_WHITE, curses.COLOR_CYAN)
#weapons
curses.init_pair(Color.blaster, curses.COLOR_GREEN, curses.COLOR_BLACK)
curses.init_pair(Color.laser, curses.COLOR_BLACK, curses.COLOR_RED)
curses.init_pair(Color.um, curses.COLOR_MAGENTA, curses.COLOR_BLACK)
screen = curses.newwin(y, x, a, b)
screen.keypad(1)
screen.nodelay(1)
curses.noecho()
curses.cbreak()
curses.curs_set(0)
return screen
def deinit(self):
self.screen.nodelay(0)
self.screen.keypad(0)
curses.nocbreak()
curses.echo()
curses.curs_set(1)
curses.endwin()
def events(self):
c = self.screen.getch()
if c == K_ESCAPE:
self.deinit()
sys.exit(1)
elif c == K_A:
self.spaceship.move_left()
elif c == K_D:
self.spaceship.move_right()
elif c == K_E:
self.spaceship.next_weapon()
elif c == K_Q:
self.spaceship.prev_weapon()
elif c == K_SPACE:
self.spaceship.fire()
def update(self):
self.spaceship.update()
self.hbar.update()
self.sbar.update()
def render(self):
self.screen.erase()
self.screen.border(0)
self.screen.addstr(0, 2, "Score: {} ".format(0))
self.screen.addstr(0, self.field.x // 2 - 4, "XOInvader", curses.A_BOLD)
weapon_info = self.spaceship.get_weapon_info()
self.screen.addstr(self.field.y, self.field.x - len(weapon_info) - 2, weapon_info,
(curses.color_pair(Color.ui_yellow) | curses.A_BOLD))
self.renderer.render_all(self.screen)
self.screen.refresh()
def loop(self):
while True:
start_time = time.perf_counter()
self.events()
self.update()
self.render()
finish_time = time.perf_counter()
delta = finish_time - start_time
if delta <= MILLISECONDS_PER_FRAME:
time.sleep((MILLISECONDS_PER_FRAME - delta) / 1000.0)
else:
message = '''
Main loop iteration took longer than expected!
Took: {0}
Expected: {1}'''.format(delta, MILLISECONDS_PER_FRAME)
log.warning(message)
def render(self, grid_gap):
Renderer.rect(self.x * grid_gap,
self.y * grid_gap,
grid_gap,
grid_gap,
color='#aaa')
import pygame
from model import Game
from render import Renderer
INPUT = {
pygame.K_UP: 'up',
pygame.K_RIGHT: 'right',
pygame.K_LEFT: 'left',
pygame.K_SPACE: 'space'
}
FPS = 60
done = False
clock = pygame.time.Clock()
game = Game()
drawer = Renderer(game)
direction = 'none'
while not done:
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
elif event.type == pygame.KEYDOWN:
try:
input = INPUT[event.key]
except:
pass
elif event.type == pygame.KEYUP:
input = 'none'
game.read_input(input)
game.integrate()
drawer.draw_game(game)
print 'time_elapsed:', total_elapsed
print 'updates/render:', updates/float(renders)
print 'updates/second:', updates/total_elapsed
print 'fps:', renders/total_elapsed
print 'actors:', actor_count
if __name__ == "__main__":
updates = 0
input_processes = 0
renders = 0
start = time()
previous = time()
lag = 0.0
state = State()
renderer = Renderer()
t = handle_input(None, renderer.screen)
drawable = []
state.active_things = [actors.Ball() for x in range(100)]
try:
while updates < 1000:
current = time()
elapsed = current - previous
previous = current
lag += elapsed
t = handle_input(t, renderer.screen)
while lag >= MS_PER_UPDATE:
drawable = update(state.active_things, renderer.screen)
updates += 1
lag -= MS_PER_UPDATE
renderer.render(drawable)
def render(self, width, height, grid_gap):
for x in range(self.cols):
Renderer.line(x * grid_gap, 0, x * grid_gap, height, color='#aaa')
for y in range(self.rows):
Renderer.line(0, y * grid_gap, width, y * grid_gap, color='#aaa')
try:
targ = utils.sort_array(i.get_target(40),2)[0]
i.move(-targ[3],i.get_speed())
pygame.draw.line(sc,[255,0,0],i.pos,targ[1])
except IndexError:
i.move_random()
su = pygame.Surface([10,10])
su.fill((255,0,0))
sc.blit(su,[int(x)-5 for x in i.pos])
pygame.display.flip()
pygame.event.pump()'''
#render tests
wld = utils.World(cfg, 300)
r = Renderer(wld, [500, 500])
pygame.key.set_repeat(100)
screen = pygame.display.set_mode([500, 500])
pos = [0, 0]
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit(0)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
pos[1] -= 1
if event.key == pygame.K_DOWN:
pos[1] += 1
if event.key == pygame.K_LEFT:
pos[0] -= 1
class World(object):
def __init__(self, rendererPath='./data', loadingTarget=True):
self.crane_list = []
self.target_list = []
self.data = loadData()
self.loadingTarget = loadingTarget
if loadingTarget:
self.target_data0 = loadTargetData()
self.target_data = None
for line in self.data:
crane = Crane()
crane.ID = line[0]
crane.x = line[1]
crane.y = line[2]
crane.R1 = line[3]
crane.R2 = line[4]
self.crane_list.append(crane)
for crane in self.crane_list:
target = Target(crane)
self.target_list.append(target)
self.observation_space = 4 * len(
self.crane_list
) # (arm_theta, delta_theta, arm_omega) * of other cranes
self.action_space = 3
self.reward_sharing_ratio = 0.1
self.collision_pairs = [(0, 1), (0, 2), (2, 3), (1, 3)]
self.t = 0
self.max_t = 720
self.score = 0
self.collision = False
self.renderer = Renderer(rendererPath)
self.reset()
def reset(self):
self.t = 0
self.score = 0
self.collision = False
if self.loadingTarget:
self.target_data = copyTargetData(self.target_data0)
for target in self.target_list:
target_state = None
if self.loadingTarget and not self.target_data[target.ID].empty():
target_state = self.target_data[target.ID].get()
target.reset(target_state)
clear = False
while not clear:
clear = True
for crane in self.crane_list:
crane.reset()
for pair in [(0, 1), (0, 2), (2, 3), (1, 3)]:
clear = clear and not self.checkCollision(pair[0], pair[1])
if not clear:
break
return self.getState()
def step(self, action):
"""
paras:
action(list of int): index of each agent's action, 0 to 2
"""
r = [-1 for crane in self.crane_list]
for crane in self.crane_list:
ID = crane.ID
target = self.target_list[ID]
car_power = 0
hook_power = 0
if target.done:
r[ID] += 1
if crane.car_pos > target.x:
car_power = -1
elif crane.car_pos < target.x:
car_power = 1
if crane.hook_height > target.h:
hook_power = -1
elif crane.hook_height < target.h:
hook_power = 1
rotate_power = 0
if action[ID] == 1:
rotate_power = 1
if target.done:
r[ID] -= 0.05
elif action[ID] == 2:
rotate_power = -1
if target.done:
r[ID] -= 0.05
crane.rotate(rotate_power)
crane.moveCar(car_power)
crane.moveHook(hook_power)
if crane.arm_theta == target.theta and not target.done:
r[ID] += 200 - abs(crane.arm_omega) * 10
target.done = True
if self.loadingTarget and not self.target_data[
crane.ID].empty():
target_state = self.target_data[crane.ID].get()
target.reset(target_state)
# share reward
s = sum(r)
for crane in self.crane_list:
r[crane.ID] += s * self.reward_sharing_ratio
done = True
for target in self.target_list:
done = done and target.done
# 碰撞检测，手动写一下哪些有必要检测的
for pair in [(0, 1), (0, 2), (2, 3), (1, 3)]:
if self.checkCollision(pair[0], pair[1]):
r[pair[0]] -= 1000
r[pair[1]] -= 1000
done = True
self.collision = True
if self.t > self.max_t:
done = True
for ID in range(len(self.crane_list)):
if not self.target_list[ID].done:
r[ID] -= 200
for i in range(len(self.crane_list)):
r[i] -= 200
# return state, r, done, _
self.score += sum(r)
# print(r,"Target0: ", self.target_list[0].done," Target1: ", self.target_list[1].done)
self.renderer.collision = self.collision
return (self.getState(), r, done, {
'score': self.score,
'collision': self.collision
})
def getState(self):
"""
get the state of n * (arm_theta, delta_theta, arm_omega)
"""
state = []
for crane in self.crane_list:
delta_theta = crane.arm_theta - self.target_list[crane.ID].theta
if delta_theta >= 360:
delta_theta -= 360
if delta_theta < 0:
delta_theta += 360
state.append(crane.arm_theta)
state.append(delta_theta)
state.append(crane.arm_omega)
state.append(self.target_list[crane.ID].done)
return np.array(state)
def render(self):
"""
render the visualization
"""
return self.renderer.render(self.crane_list, self.target_list, {
'score': self.score,
'time': self.t
})
# print(self.crane.arm_theta, " ", self.crane.car_pos)
# time.sleep(0.2)
def getAgentNum(self):
"""
return the number of the agents
"""
return len(self.data)
def checkCollision(self, craneID1, craneID2):
"""
check collision of two cranes
"""
crane = self.crane_list[craneID1]
l1 = Line(crane.x - math.cos(crane.arm_theta / 180 * pi) * crane.R2,
crane.y - math.sin(crane.arm_theta / 180 * pi) * crane.R2,
crane.x + math.cos(crane.arm_theta / 180 * pi) * crane.R1,
crane.y + math.sin(crane.arm_theta / 180 * pi) * crane.R1)
crane = self.crane_list[craneID2]
l2 = Line(crane.x - math.cos(crane.arm_theta / 180 * pi) * crane.R2,
crane.y - math.sin(crane.arm_theta / 180 * pi) * crane.R2,
crane.x + math.cos(crane.arm_theta / 180 * pi) * crane.R1,
crane.y + math.sin(crane.arm_theta / 180 * pi) * crane.R1)
# 快速排斥实验
if max(l1.x1, l1.x2) < min(l2.x1, l2.x2) or\
max(l1.y1, l1.y2) < min(l2.y1, l2.y2) or\
max(l2.x1, l2.x2) < min(l1.x1, l1.x2) or\
max(l2.y1, l2.y2) < min(l1.y1, l1.y2):
return False
# 跨越实验
if (((l1.x1 - l2.x1)*(l2.y2 - l2.y1) - (l1.y1 - l2.y1)*(l2.x2 - l2.x1))*\
((l1.x2 - l2.x1)*(l2.y2 - l2.y1) - (l1.y2 - l2.y1)*(l2.x2 - l2.x1))) > 0 or\
(((l2.x1 - l1.x1)*(l1.y2 - l1.y1) - (l2.y1 - l1.y1)*(l1.x2 - l1.x1))*\
((l2.x2 - l1.x1)*(l1.y2 - l1.y1) - (l2.y2 - l1.y1)*(l1.x2 - l1.x1))) > 0:
return False
else:
return True
sys.path.append(os.path.join(os.path.dirname(__file__), os.pardir))
from render import Renderer
if __name__ == '__main__':
template_name = 'Menu'
CWD = os.getcwd()
data_path = '{0}/{1}'.format(CWD, 'data.json')
file = open(data_path, 'r')
data_string = file.read()
file.close()
data = json.loads(data_string)
renderer = Renderer(template_name, data)
rendered_html_document = renderer.render_html()
rendered_pdf_document = renderer.render_pdf(rendered_html_document)
html_file_path = '{0}/output/{1}'.format(CWD, 'Rendered_{0}.html'.format(template_name))
html_file = open(html_file_path, 'w')
html_file.write(rendered_html_document)
html_file.close()
pdf_file_path = '{0}/output/{1}'.format(CWD, 'Rendered_{0}.pdf'.format(template_name))
pdf_file = open(pdf_file_path, 'wb')
pdf_file.write(rendered_pdf_document)
pdf_file.close()
print('Document Rendered!')
def get(self): page = Renderer(self, 'admin.html') page.render()
def get(self): page = Renderer(self, 'notfound.html') page.render()
def get(self): page = Renderer(self, 'index.html') page.render()
class App:
def __init__(self):
self.cube = c.Cube(radius=2)
self.distance = 13
self.renderer = Renderer(width, height + 60, self.distance)
self.color_bg = (150, 150, 150)
self.x_color = (150, 50, 50)
self.y_color = (50, 150, 50)
self.z_color = (50, 50, 150)
self.space = [ # ejes
[c.Point3d(-self.distance, 0, 0),
c.Point3d(self.distance, 0, 0)],
[c.Point3d(0, 0, -self.distance),
c.Point3d(0, 0, self.distance)],
[c.Point3d(0, -self.distance, 0),
c.Point3d(0, self.distance, 0)],
# lines de referencia segun 'distace'
[
c.Point3d(-self.distance, -self.distance, -self.distance),
c.Point3d(-self.distance, self.distance, -self.distance)
],
[
c.Point3d(-self.distance, -self.distance, -self.distance),
c.Point3d(self.distance, -self.distance, -self.distance)
],
[
c.Point3d(-self.distance, -self.distance, self.distance),
c.Point3d(-self.distance, self.distance, self.distance)
],
[
c.Point3d(-self.distance, -self.distance, self.distance),
c.Point3d(self.distance, -self.distance, self.distance)
],
[
c.Point3d(-self.distance, self.distance, self.distance),
c.Point3d(-self.distance, self.distance, -self.distance)
],
[
c.Point3d(-self.distance, -self.distance, self.distance),
c.Point3d(-self.distance, -self.distance, -self.distance)
],
[
c.Point3d(self.distance, -self.distance, self.distance),
c.Point3d(self.distance, -self.distance, -self.distance)
],
[
c.Point3d(-self.distance, self.distance, -self.distance),
c.Point3d(self.distance, self.distance, -self.distance)
],
[
c.Point3d(self.distance, self.distance, -self.distance),
c.Point3d(self.distance, -self.distance, -self.distance)
]
]
self.space_shapes = [ # planos de referencia
[
self.space[3][0], self.space[3][1], self.space[5][1],
self.space[8][0]
],
[
self.space[3][0], self.space[5][0], self.space[6][1],
self.space[9][1]
],
[
self.space[3][0], self.space[9][1], self.space[11][0],
self.space[7][1]
]
]
self.x_state = 0
self.y_state = 0
self.z_state = 0
def init(self):
pass
def _order_faces(self):
p = c.Point3d(self.distance, self.distance, self.distance)
faces = self.cube.faces
faces = sorted(faces,
key=lambda x: x.dist_center_to_mid(p),
reverse=True)
return faces
def update(self, x_state, y_state, z_state):
self.cube.rotate('x', PI * 2 / 100 * (x_state - self.x_state))
self.x_state = x_state
self.cube.rotate('y', PI * 2 / 100 * (y_state - self.y_state))
self.y_state = y_state
self.cube.rotate('z', PI * 2 / 100 * (z_state - self.z_state))
self.z_state = z_state
def draw(self):
pg.draw.rect(screen, self.color_bg, pg.Rect(0, 60, width, height - 60))
self.renderer.render_shape(screen, self.space_shapes[0],
(200, 200, 200))
self.renderer.render_shape(screen, self.space_shapes[1],
(200, 200, 200))
self.renderer.render_shape(screen, self.space_shapes[2],
(200, 200, 200))
for line in self.space:
self.renderer.render_line(screen, line)
for point in self.cube.vertex:
self.renderer.render_point(screen, point)
grey = 100
for f in self._order_faces():
self.renderer.render_shape(screen, f.vertex, (grey, grey, grey))
for line in f.edges:
self.renderer.render_line(screen, line)
for v in self.cube.vertex:
# proyect x
point = c.Point3d(-self.distance, v.cords[1], v.cords[2])
self.renderer.render_point(screen, point, self.x_color)
# proyect y
point = c.Point3d(v.cords[0], -self.distance, v.cords[2])
self.renderer.render_point(screen, point, self.y_color)
# proyect z
point = c.Point3d(v.cords[0], v.cords[1], -self.distance)
self.renderer.render_point(screen, point, self.z_color)
import os import threading from render import Renderer from client import Client # Configurable constants c = Client() r = Renderer(c) r.main()
import pygame
import parameters as PRAM
from setup import soundPlayerFactory, playerFactory, eventHandlerFactory
from render import Renderer
from game import Game
from input import InputHandler, ButtonMap
from camera import GameCamera
### SETUP ###
pygame.init() # @UndefinedVariable
screen = pygame.display.set_mode((PRAM.DISPLAY_WIDTH, PRAM.DISPLAY_HEIGHT))
CLOCK = pygame.time.Clock()
DONE = False
### GAME ENGINE ###
musicPlayer, soundPlayer = soundPlayerFactory()
renderer = Renderer(screen)
gameCamera = GameCamera()
player = playerFactory()
game = Game(player, musicPlayer, soundPlayer, renderer, gameCamera)
inputHandler = InputHandler(game, player, ButtonMap())
eventHandler = eventHandlerFactory(game)
game.inputHandler = inputHandler
game.gameStartup()
while not DONE:
for event in pygame.event.get():
if event.type == pygame.QUIT: # @UndefinedVariable
DONE = True #TODO make this an input that creates a quit event?
if event.type == pygame.KEYDOWN: # @UndefinedVariable
game.keydownEvents.append(event)
#TODO can tell pygame to only check fro specific events
def get(self): page = Renderer(self, 'posteador.html') page.render()
def __init__(self):
self.cube = c.Cube(radius=2)
self.distance = 13
self.renderer = Renderer(width, height + 60, self.distance)
self.color_bg = (150, 150, 150)
self.x_color = (150, 50, 50)
self.y_color = (50, 150, 50)
self.z_color = (50, 50, 150)
self.space = [ # ejes
[c.Point3d(-self.distance, 0, 0),
c.Point3d(self.distance, 0, 0)],
[c.Point3d(0, 0, -self.distance),
c.Point3d(0, 0, self.distance)],
[c.Point3d(0, -self.distance, 0),
c.Point3d(0, self.distance, 0)],
# lines de referencia segun 'distace'
[
c.Point3d(-self.distance, -self.distance, -self.distance),
c.Point3d(-self.distance, self.distance, -self.distance)
],
[
c.Point3d(-self.distance, -self.distance, -self.distance),
c.Point3d(self.distance, -self.distance, -self.distance)
],
[
c.Point3d(-self.distance, -self.distance, self.distance),
c.Point3d(-self.distance, self.distance, self.distance)
],
[
c.Point3d(-self.distance, -self.distance, self.distance),
c.Point3d(self.distance, -self.distance, self.distance)
],
[
c.Point3d(-self.distance, self.distance, self.distance),
c.Point3d(-self.distance, self.distance, -self.distance)
],
[
c.Point3d(-self.distance, -self.distance, self.distance),
c.Point3d(-self.distance, -self.distance, -self.distance)
],
[
c.Point3d(self.distance, -self.distance, self.distance),
c.Point3d(self.distance, -self.distance, -self.distance)
],
[
c.Point3d(-self.distance, self.distance, -self.distance),
c.Point3d(self.distance, self.distance, -self.distance)
],
[
c.Point3d(self.distance, self.distance, -self.distance),
c.Point3d(self.distance, -self.distance, -self.distance)
]
]
self.space_shapes = [ # planos de referencia
[
self.space[3][0], self.space[3][1], self.space[5][1],
self.space[8][0]
],
[
self.space[3][0], self.space[5][0], self.space[6][1],
self.space[9][1]
],
[
self.space[3][0], self.space[9][1], self.space[11][0],
self.space[7][1]
]
]
self.x_state = 0
self.y_state = 0
self.z_state = 0
