def get_lines(self):
"""Returns edges of rectangle as a list of 4 barriers"""
c = self.get_corners()
return [Barrier(c[0][0], c[0][1], c[1][0], c[1][1]),
Barrier(c[1][0], c[1][1], c[2][0], c[2][1]),
Barrier(c[2][0], c[2][1], c[3][0], c[3][1]),
Barrier(c[3][0], c[3][1], c[0][0], c[0][1])]
def run_game():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Space Invaders")
music = pygame.mixer.Sound("Sounds/space_music.wav")
play_button = Button(ai_settings, screen, "Play", (600, 50))
barrier = Barrier(ai_settings, screen)
ship = Ship(ai_settings, screen)
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
bullets = Group()
aliens = Group()
gm.create_fleet(ai_settings, screen, ship, aliens)
gm.create_barriers(ai_settings, screen)
while True:
music.play()
gm.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets)
bullets.update()
ship.update()
barrier.update()
gm.update_aliens(ai_settings, screen, stats, sb, ship, aliens, bullets)
gm.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets)
gm.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets)
pygame.display.flip()
def __init__(self,
model,
target_dist,
weights=None,
horizon=100,
num_basis=5,
capacity=100000,
batch_size=20):
self.model = model
self.target_dist = target_dist
self.horizon = horizon
self.replay_buffer = ReplayBuffer(capacity)
self.batch_size = batch_size
self.basis = Basis(self.model.explr_space, num_basis=num_basis)
# self.lamk = 1.0/(np.linalg.norm(self.basis.k, axis=1) + 1)**(3.0/2.0)
self.lamk = np.exp(-0.8 * np.linalg.norm(self.basis.k, axis=1))
self.barr = Barrier(self.model.explr_space)
# initialize the control sequence
# self.u_seq = [np.zeros(self.model.action_space.shape)
# for _ in range(horizon)]
self.u_seq = [
0.0 * self.model.action_space.sample() for _ in range(horizon)
]
if weights is None:
weights = {'R': np.eye(self.model.action_space.shape[0])}
self.Rinv = np.linalg.inv(weights['R'])
self._phik = None
self.ck = None
def __init__(self, agent_name, model,
weights=None, t_horizon=10, num_basis=5,
capacity=100000, batch_size=20):
self._agent_name = agent_name
self._model = model
self._t_horizon = t_horizon
self._replay_buffer = ReplayBuffer(capacity)
self._batch_size = batch_size
self._basis = Basis(self._model.explr_space, num_basis=num_basis)
self._lamk = np.exp(-0.8*np.linalg.norm(self._basis.k, axis=1))
self._barr = Barrier(self._model.explr_space)
self._targ_dist = TargetDist(basis=self._basis)
self._u = [0.0*np.zeros(self._model.action_space.shape[0])
for _ in range(t_horizon)]
# TODO: implement more weights
if weights is None:
weights = {'R' : np.eye(self._model.action_space.shape[0])}
self._Rinv = np.linalg.inv(weights['R'])
self._phik = None
self._ck_mean = None
self._ck_msg = Ck()
self._ck_msg.name = self._agent_name
self._ck_dict = {}
self.pred_path = []
# set up the eos stuff last
rospy.Subscriber('ck_link', Ck, self._ck_link_callback)
self._ck_pub = rospy.Publisher('ck_link', Ck, queue_size=1)
def __init__(self, duration=0, distance=None):
object.__init__(self)
self.duration = duration
self.curr_val = None
self.barrier = Barrier()
self.distance = distance
self.schmitt_low = None
self.schmitt_high = None
def create_barriers(ai_settings, screen, ship, barriers):
barrier = Barrier(ai_settings, screen)
number_of_barriers = math.floor(ai_settings.screen_width / 240)
for barrier_number in range(number_of_barriers):
barrier = Barrier(ai_settings, screen)
barrier.rect.top = ship.rect.top - 50
barrier.rect.left = barrier_number * 240 + 80
barriers.add(barrier)
def __init__(self, walls, people, extra_barriers = None, name = None,
transm_prob = 1, death_rate = 0.1, recovery_time = 2):
x1, x2, y1, y2 = walls
self._barriers = 4*[None]
self._barriers[0] = Barrier(np.array([x1, y1]), np.array([x1, y2]))
self._barriers[1] = Barrier(np.array([x1, y2]), np.array([x2, y2]))
self._barriers[2] = Barrier(np.array([x2, y2]), np.array([x2, y1]))
self._barriers[3] = Barrier(np.array([x2, y1]), np.array([x1, y1]))
self._people = people
for person in people:
assert(people[0].radius == person.radius)
max_speed = 0
for person in people:
speed = norm(person.vel)
if speed > max_speed:
max_speed = speed
self._delta_t = 0.5 * people[0].radius / max_speed
self._transmission_prob = transm_prob
self._death_rate = death_rate
self._recovery_time = recovery_time
self._total_healthy = 0
self._total_sick = 0
self._total_dead = 0
self._total_recovered = 0
self._R = 0
for person in people:
if person.health == 'healthy':
self._total_healthy += 1
elif person.health == 'sick':
self._total_sick += 1
elif person.health == 'recovered':
self._total_sick += 1
self._name = name
self._time = 0
if name is not None:
if not os.path.isdir(name):
try:
os.mkdir(name)
except(FileNotFoundError):
os.makedirs(name, exist_ok=True)
os.chdir(name)
if not os.path.isdir('states'):
os.mkdir('states')
self._files = [open('states/sim_person_%i.csv' % i, 'w') for i in range(len(people))]
self._files.append(open('states/stats.csv', 'w'))
for f in self._files[:-1]:
f.write('time,x,y,health,num_infected\n')
self._files[-1].write('time,healthy,sick,recovered,dead,R\n')
def update_obstacles(self):
for obstacle in self.obstacles:
obstacle.update()
#Add new obstacles if needed
if self.obstacles[-1].pos <= self.width:
self.obstacles.append(Barrier(pos = self.width + self.distance_between_obstacles, width = 50))
#Remove old obstacles if needed
if self.obstacles[0].pos + self.obstacles[0].width <= -50:
self.obstacles.remove(self.obstacles[0])
def __init__(self):
pygame.init()
self.lifes = [
pyg.image.load("lifes.png"),
pyg.image.load("lifes.png"),
pyg.image.load("lifes.png"),
pyg.image.load("lifes.png"),
pyg.image.load("lifes.png")
]
self.isgame = True
self.moving_flag = True
self.win = pygame.display.set_mode((500, 600))
pygame.display.set_caption("Space Invadors")
self.ship = Ship(self.win)
self.barrier_1 = Barrier(100, 450, self.win)
self.barrier_2 = Barrier(300, 450, self.win)
self.enemys = [Enemy(self.win, x, 100) for x in range(30, 425, 55)]
self.enemys += [Enemy(self.win, x, 225) for x in range(20, 435, 45)]
self.count = 0
def setup_devices(self, devices):
"""
Setup the devices before simulation begins.
@type devices: List of Device
@param devices: list containing all devices
"""
if self.device_id == 0:
self.barrier = Barrier(len(devices))
self.send_barrier(devices, self.barrier)
def initialize(grid_size, player_pos, barrier_h, barrier_x_list,
train_file):
game = Game()
game.grid = g.Grid(grid_size)
game.player = Player(player_pos)
game.barrier = Barrier(barrier_h, barrier_x_list)
game.barrier.createNN()
game.barrier.brain.importNN(train_file)
game.update_grid()
return game
class SamplingBuffer(object):
def __init__(self,
sampling_interval=None,
sampling_freq=None,
initial_value=None):
"""
if value is put too fast, `get` method should limit this speed with "sample interval" parameter.
if value is got too slow, `get` method should return immediately
"""
if sampling_interval:
self.sampling_interval = sampling_interval
elif sampling_freq:
self.sampling_interval = (1.0 / sampling_freq)
else:
self.sampling_interval = 0.01 # 10 ms default value
self.curr_val = initial_value
self.last_timestamp = 0
self.put_barrier = Barrier()
self.fine_tune_last_wait = 0.005 # seconds
def put(self, value):
self.curr_val = value
self.put_barrier.go()
def get(self):
while True:
remaining_time = self.last_timestamp + self.sampling_interval - time.time(
)
#print "remaining time: ", remaining_time
if remaining_time <= 0:
self.put_barrier.wait()
self.last_timestamp = time.time()
return self.curr_val
else:
if remaining_time > self.fine_tune_last_wait:
sleep(remaining_time - self.fine_tune_last_wait)
else:
# try to wait in the end very precisely
sleep(remaining_time / 2)
def makeBarriers(barriers, screen, ai_settings):
xTemp = ai_settings.screen_width / 4 - 40
yTemp = 4 * ai_settings.screen_height / 5
for j in range(3):
for n in range(2):
for i in range(7):
newBarrier = Barrier(screen, ai_settings)
newBarrier.rect.x = xTemp + (i * 10)
newBarrier.rect.y = yTemp + (20 * n)
barriers.add(newBarrier)
xTemp += ai_settings.screen_width / 4
def create(self, key, row, col):
if key == "G":
Goblin(row, col, self)
elif key == "S":
Snake(row, col, self)
elif key == "#":
Barrier(row, col, self)
elif key == "P":
Player(row, col, self)
elif key == "T":
Treasure(row, col, self)
def make_barriers(barriers, screen, ai_settings):
tempx = ai_settings.screen_width / 5 - 40
tempy = (4 * ai_settings.screen_height) / 5
for j in range(4):
for n in range(2):
for i in range(7):
newBarrier = Barrier(screen, ai_settings)
newBarrier.rect.x = tempx + (i * 10)
newBarrier.rect.y = tempy + (n * 20)
barriers.add(newBarrier)
tempx += ai_settings.screen_width / 5
def __init__(self,
sampling_interval=None,
sampling_freq=None,
initial_value=None):
"""
if value is put too fast, `get` method should limit this speed with "sample interval" parameter.
if value is got too slow, `get` method should return immediately
"""
if sampling_interval:
self.sampling_interval = sampling_interval
elif sampling_freq:
self.sampling_interval = (1.0 / sampling_freq)
else:
self.sampling_interval = 0.01 # 10 ms default value
self.curr_val = initial_value
self.last_timestamp = 0
self.put_barrier = Barrier()
self.fine_tune_last_wait = 0.005 # seconds
def __init__(self, count):
self.deck = Deck() # 牌堆
self.players = [] # 玩家清單
self.player_count = count # 玩家數量
self.__round_barrier = Barrier(count+1) # 每回合末同步狀態用
self.__jack_lock = Lock() # 搶牌鎖定
self.__dispenser_event = Event() # 牌發了沒
self.__dispenser_lock = CounterLock(self.player_count) # 發牌員等玩家用的鎖
self.steal = False # 大家來偷牌
self.table_top = None # 桌面上可以搶的那張牌
self.last_card = None # 被搶走的牌
self.end = False # GG?
self.player_reports = [[] for i in range(self.player_count)] # 得分記錄
self.player_finnished = [] # 排名
self.round = 0 # 回合計數器
self.output_mutex = Lock() # log 用的 lock, 不然你看想看意大利麵般的輸出嗎
self.deck.shuffle() # 洗牌
self.players = [Player(self, i) for i in range(self.player_count)] # 建立玩家
def create_barrier(ai_settings, screen, bar, bunker_num, barriers):
# Find new barrier's position
x = 150
y = 600
for i in range(1, bunker_num):
x += 245
# Create barrier in proper location
if bar == 1:
barrier = Barrier(ai_settings, screen, x, y, '1')
elif bar == 2:
barrier = Barrier(ai_settings, screen, x, y - ai_settings.bar_height,
'1')
elif bar == 3:
barrier = Barrier(ai_settings, screen, x,
y - (ai_settings.bar_height * 2), 'BR')
elif bar == 4:
barrier = Barrier(ai_settings, screen, x + ai_settings.bar_width,
y - ai_settings.bar_height, 'TL')
elif bar == 5:
barrier = Barrier(ai_settings, screen, x + ai_settings.bar_width,
y - (ai_settings.bar_height * 2), '1')
elif bar == 6:
barrier = Barrier(ai_settings, screen, x + (ai_settings.bar_width * 2),
y - ai_settings.bar_height, 'TR')
elif bar == 7:
barrier = Barrier(ai_settings, screen, x + (ai_settings.bar_width * 2),
y - (ai_settings.bar_height * 2), '1')
elif bar == 8:
barrier = Barrier(ai_settings, screen, x + (ai_settings.bar_width * 3),
y, '1')
elif bar == 9:
barrier = Barrier(ai_settings, screen, x + (ai_settings.bar_width * 3),
y - ai_settings.bar_height, '1')
elif bar == 10:
barrier = Barrier(ai_settings, screen, x + (ai_settings.bar_width * 3),
y - (ai_settings.bar_height * 2), 'BL')
barriers.add(barrier)
def restart(self):
self.play_button = Button(settings=self.settings,
screen=self.screen,
msg="Play")
self.hs_button = scorebutton(settings=self.settings,
screen=self.screen,
msg="HIGH SCORES")
self.stats = GameStats(settings=self.settings)
self.sb = Scoreboard(game=self, sound=self.sound)
self.settings.init_dynamic_settings()
self.barrier = Barrier(ship_height=self.ship_height, game=self)
self.ufo = Ufos(ship_height=self.ship_height, game=self)
self.aliens = Aliens(ship_height=self.ship_height, game=self)
self.ship = Ship(aliens=self.aliens,
sound=self.sound,
game=self,
ufo=self.ufo)
self.aliens.add_ship(ship=self.ship)
self.stats.high_score = self.hs
self.sb.prep_high_score()
def __init__(self, simMins, hdim, vdim):
global TICK_TIME
TICK_TIME = 1 # we're waiting one sec per tick
self.simulationRunning = False
self.maxSimTicks = simMins
self.globalTicks = 0 # num ticks the simulation has been running for
self.hdim = hdim
self.vdim = vdim
self.orgsList = Set() # Organisms alive/running in simulation
self.orgsListMutex = Lock()
self.newborns = [] # Organisms born during current tick
self.newbornsMutex = Lock()
self.creatures = dict()
self.creature_funcs = dict()
self.__createOcean(hdim, vdim)
self.__prepopulateCoccolithophores()
self.__createFoodchain()
self.barrier = Barrier(0) # for synchronization between ticks
self.stdoutLock = Lock() # for printing to stdout
def create_barriers(ai_settings, screen, barriers, sprites):
number_barriers_x = 4
for x in range(0, number_barriers_x):
barrier_offset_x = 160
barrier_offset_y = 608
barrier = Barrier(ai_settings, screen, barrier_offset_x + (256 * x),
barrier_offset_y, sprites, 1)
barriers.add(barrier)
barrier = Barrier(ai_settings, screen, barrier_offset_x + 32 + (256 * x),
barrier_offset_y, sprites, 0)
barriers.add(barrier)
barrier = Barrier(ai_settings, screen, barrier_offset_x + 64 + (256 * x),
barrier_offset_y, sprites, 0)
barriers.add(barrier)
barrier = Barrier(ai_settings, screen, barrier_offset_x + 96 + (256 * x),
barrier_offset_y, sprites, 2)
barriers.add(barrier)
barrier = Barrier(ai_settings, screen, barrier_offset_x + (256 * x),
barrier_offset_y + 32, sprites, 0)
barriers.add(barrier)
barrier = Barrier(ai_settings, screen, barrier_offset_x + 32 + (256 * x),
barrier_offset_y + 32, sprites, 4)
barriers.add(barrier)
barrier = Barrier(ai_settings, screen, barrier_offset_x + 64 + (256 * x),
barrier_offset_y + 32, sprites, 3)
barriers.add(barrier)
barrier = Barrier(ai_settings, screen, barrier_offset_x + 96 + (256 * x),
barrier_offset_y + 32, sprites, 0)
barriers.add(barrier)
barrier = Barrier(ai_settings, screen, barrier_offset_x + (256 * x),
barrier_offset_y + 64, sprites, 0)
barriers.add(barrier)
barrier = Barrier(ai_settings, screen, barrier_offset_x + 96 + (256 * x),
barrier_offset_y + 64, sprites, 0)
barriers.add(barrier)
def create_barriers(self):
self.barriers = []
for i in range(0, 4):
barrier = Barrier(screen=self.screen,
sprite_sheet=self.sprite_sheet,
column=i)
barrier.create_barrier()
barrier.draw_barrier()
self.barriers.append(barrier)
class StabilizedBuffer(object):
def __init__(self, duration=0, distance=None):
object.__init__(self)
self.duration = duration
self.curr_val = None
self.barrier = Barrier()
self.distance = distance
self.schmitt_low = None
self.schmitt_high = None
def set_limits(self):
self.schmitt_low = self.curr_val - (self.distance / 2.0)
self.schmitt_high = self.curr_val + (self.distance / 2.0)
def put(self, value):
self.curr_val = value
if self.distance is not None:
if self.schmitt_low is None:
self.set_limits()
if self.schmitt_low < self.curr_val < self.schmitt_high:
pass
else:
self.set_limits()
self.barrier.go()
else:
self.barrier.go()
def get(self):
while True:
success = self.barrier.wait(self.duration)
if not success:
# barrier is timed out, so there is no new
# value in this time slot, which means we have
# a stable value. return this value.
return self.curr_val
def mainloop(self):
self.output('game start')
self.output('dispenser: %d cards left in deck' % len(self.deck.deck))
for player in self.players:
player.hand = self.deck.withdraw(3)
player.start()
while not game.end:
if not self.deck.deck: # 牌堆空了沒
self.end = True
break
self.__dispenser_event.clear() # 搶有就有 沒有就等下一輪
self.round += 1 # 新回合
self.wait_for_round(-1) # 阿你是好了沒
self.steal = False # 關於偷牌這件事我們再評估
self.wait_for_players() # 大家都好了嗎
self.dispense() # 發牌！
player_state = set([player.check(self.table_top) for player in self.players])
if len(player_state) == 1: # 大家都一樣
if 0 in player_state: # 都沒牌好搶
self.steal = True
elif -1 in player_state: # 都兩手空空
self.end = True
self.__round_barrier = Barrier(self.player_count+1) # 重置同步
self.__dispenser_event.set() # 牌發了 大家都看好了 來搶噢
self.wait_for_players() # 所以架打完了嗎
self.wait_for_round(-1) # 好了收工啦
self.output('It\'s over!')
self.game_end()
def create_barriers(ai_settings, screen, barriers):
saved_x = 265
for barrier_count in range(ai_settings.barrier_total):
pos_y = ai_settings.barrier_topy
barrier_type = 0
for y in range(ai_settings.barrier_count_y):
pos_x = saved_x
for x in range(ai_settings.barrier_count_x):
new_barrier = Barrier(ai_settings, screen, barrier_type, pos_x,
pos_y)
barriers.add(new_barrier)
barrier_type += 1
pos_x += ai_settings.barrier_width
pos_y += ai_settings.barrier_height
saved_x += 300
def draw_barriers(self):
Barrier(250, self.canvas)
Barrier(550, self.canvas)
import threading
from barrier import Barrier
barrier = Barrier(10)
class thread(threading.Thread):
def __init__(self, thread_ID):
threading.Thread.__init__(self)
self.thread_ID = thread_ID
def run(self):
print("before barrier|thread_id={0}".format(str(self.thread_ID)))
barrier.wait()
print("after barrier|thread_id={0}".format(str(self.thread_ID)))
threads = []
for i in range(10):
threads.append(thread(i))
for t in threads:
t.start()
barrier.wait()
print("Exit\n")
class Game():
def __init__(self):
pygame.init()
self.lifes = [
pyg.image.load("lifes.png"),
pyg.image.load("lifes.png"),
pyg.image.load("lifes.png"),
pyg.image.load("lifes.png"),
pyg.image.load("lifes.png")
]
self.isgame = True
self.moving_flag = True
self.win = pygame.display.set_mode((500, 600))
pygame.display.set_caption("Space Invadors")
self.ship = Ship(self.win)
self.barrier_1 = Barrier(100, 450, self.win)
self.barrier_2 = Barrier(300, 450, self.win)
self.enemys = [Enemy(self.win, x, 100) for x in range(30, 425, 55)]
self.enemys += [Enemy(self.win, x, 225) for x in range(20, 435, 45)]
self.count = 0
def get_min_y(self, barrier, xc):
mas = [(y if xc == x else 700) for x, y in barrier]
try:
return min(mas)
except Exception as e:
print(e)
def find_enemy(self, enemyes):
mi = 550
mx = 0
for enemy in enemyes:
if enemy.x > mx: mx = enemyes.index(enemy)
if enemy.x < mi: mi = enemyes.index(enemy)
return (mx, mi)
def run(self):
bullets = []
ship_bullets = []
while self.isgame:
pygame.time.delay(70)
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.isgame = False
keys = pygame.key.get_pressed()
self.win.fill((0, 0, 0))
tmp = self.ship.action(keys)
self.barrier_1.draw()
self.barrier_2.draw()
font = pygame.font.SysFont(None, 40)
text = font.render(f"Score: {self.count}", True, (255, 255, 255))
self.win.blit(text, (160, 10))
i = 0
for x in range(5, (23 + 5) * len(self.lifes), 28):
self.win.blit(self.lifes[i], (x, 2))
i += 1
max_en, min_en = self.find_enemy(self.enemys)
if self.enemys[max_en].x + 5 < 450 and self.moving_flag:
for enemy in self.enemys:
tmp_2 = enemy.move(5)
if tmp_2 and len(bullets) < 30:
bullets.append(tmp_2)
elif self.enemys[min_en].x - 5 > 10:
for enemy in self.enemys:
tmp_2 = enemy.move(-5)
if tmp_2 and len(bullets) < 30:
bullets.append(tmp_2)
self.moving_flag = False
else:
self.moving_flag = True
for enemy in self.enemys:
tmp_2 = enemy.move(0)
if tmp_2 and len(bullets) < 30:
bullets.append(tmp_2)
if tmp and len(bullets) < 15:
bullets.append(tmp)
for bullet in bullets:
try:
bullets.index(bullet)
except:
continue
bullet.shot(bullet.x, bullet.y)
matrix = [self.barrier_1.pixels, self.barrier_2.pixels]
for pix in range(len(matrix[0])):
min_y_1 = self.get_min_y(matrix[0], matrix[0][pix][0])
min_y_2 = self.get_min_y(matrix[1], matrix[1][pix][0])
try:
bullets.index(bullet)
except:
continue
if matrix[0][pix][0] == bullet.x and bullet.y in range(
450, 550) and bullet.speed < 0:
try:
bullets.pop(bullets.index(bullet))
self.barrier_1.pixels[self.barrier_1.pixels.index(
(matrix[0][pix][0], min_y_1))] = (-10, 650)
except:
pass
elif matrix[1][pix][0] == bullet.x and bullet.y in range(
450, 550) and bullet.speed < 0:
try:
bullets.pop(bullets.index(bullet))
self.barrier_2.pixels[self.barrier_2.pixels.index(
(matrix[1][pix][0], min_y_1))] = (-10, 650)
except:
pass
for enemy in self.enemys:
if bullet.x in range(enemy.x,
enemy.x + 26) and bullet.y in range(
enemy.y, enemy.y + 26):
try:
index = bullets.index(bullet)
except:
continue
if bullet.speed > 0:
enemy.hit()
if enemy.live <= 0:
self.enemys.pop(self.enemys.index(enemy))
self.count += 1
bullets.pop(bullets.index(bullet))
if self.count == 18:
self.end()
if bullet.x in range(self.ship.x,
self.ship.x + 37) and bullet.y in range(
self.ship.y, self.ship.y + 52):
try:
index = bullets.index(bullet)
except:
continue
tmp = self.ship.hit()
self.lifes.pop(-1)
bullets.pop(bullets.index(bullet))
if tmp == "game over":
self.end()
if bullet.y < 600 and bullet.y > 0:
bullet.y -= bullet.speed
else:
bullets.pop(bullets.index(bullet))
pygame.display.update()
def end(self):
self.win.fill((0, 0, 0))
font = pygame.font.SysFont(None, 40)
text = font.render("GAME OVER", True, (255, 50, 50))
self.win.blit(text, (160, 300))
pygame.display.update()
pygame.time.wait(2000)
pygame.quit()
global pacCycle
if pacAnimate == True:
if pacCycle < 3:
pacCycle += 1
else:
pacCycle = 0
#----------------SETUP GAME--------------------
window = pyglet.window.Window(467, 566)
keys = key.KeyStateHandler()
window.push_handlers(keys)
#----------------CREATE OBJECTS----------------
barriers = [
#Barrier(x, y, wid, h)
Barrier(42, 42, 50, 64)
]
char = PacMan(0, 0, barriers)
#----------------ANIMATION---------------------
@window.event
def on_draw():
global pacCycle
pyglet.sprite.Sprite(pyglet.image.load("img/boards/lvl1.jpg"), x=0,
y=0).draw()
if char.right == True or char.left == True or char.up == True or char.down == True:
if char.direction == "right":
char.spr = pacRight[pacCycle]
# hk, even computed in the source code, is not
# used in the end, so we temporarily ignore it
###########################################
# compute trajectory to ck using basis function
from utils import convert_traj2ck
ck = convert_traj2ck(basis, xt)
print('ck: ')
print(ck)
###########################################
# barrier function test
from barrier import Barrier
# define the Barrier object
barrier = Barrier(explr_space)
# test cost function
print(barrier.cost(explr_space.sample() - 1.0))
# test derivative of cost function wrt to pose
print(barrier.dx(explr_space.sample() - 1.0))
###########################################
# target distribution test
from target_dist import TargetDist
from utils import convert_phi2phik, convert_phik2phi
import matplotlib.pyplot as plt
# define a target distribution object
t_dist = TargetDist()
# plot first fig, original target dist
fig1 = plt.figure()
