def learn(self):
for i in range(1, self.args.n_epochs + 1):
# bookkeeping
print('------EPOCH ' + str(i) + '------')
# examples of the iteration
if not self.skipFirstSelfPlay or i > 1:
iterationTrainExamples = deque([], maxlen=self.args.max_queue)
for eps in range(self.args.n_episodes):
self.mcts = MCTS(self.game, self.nnet,
self.args) # reset search tree
iterationTrainExamples += self.executeEpisode()
# save the iteration examples to the history
self.trainExamplesHistory.append(iterationTrainExamples)
if len(self.trainExamplesHistory) > self.args.n_trainexamples:
print("len(trainExamplesHistory) =",
len(self.trainExamplesHistory),
" => remove the oldest trainExamples")
self.trainExamplesHistory.pop(0)
# backup history to a file
# NB! the examples were collected using the model from the previous iteration, so (i-1)
self.saveTrainExamples(i - 1)
# shuffle examples before training
trainExamples = []
for e in self.trainExamplesHistory:
trainExamples.extend(e)
shuffle(trainExamples)
# training new network, keeping a copy of the old one
self.nnet.save_checkpoint(folder=self.args.checkpoint,
filename='temp.pth.tar')
self.pnet.load_checkpoint(folder=self.args.checkpoint,
filename='temp.pth.tar')
pmcts = MCTS(self.game, self.pnet, self.args)
self.nnet.train(trainExamples)
nmcts = MCTS(self.game, self.nnet, self.args)
print('PITTING AGAINST PREVIOUS VERSION')
arena = Arena(lambda x: np.argmax(pmcts.getActionProb(x, temp=0)),
lambda x: np.argmax(nmcts.getActionProb(x, temp=0)),
self.game)
pwins, nwins, draws = arena.playGames(self.args.arenaCompare)
print('NEW/PREV WINS : %d / %d ; DRAWS : %d' %
(nwins, pwins, draws))
if pwins + nwins == 0 or float(nwins) / (
pwins + nwins) < self.args.updateThreshold:
print('REJECTING NEW MODEL')
self.nnet.load_checkpoint(folder=self.args.checkpoint,
filename='temp.pth.tar')
else:
print('ACCEPTING NEW MODEL')
self.nnet.save_checkpoint(folder=self.args.checkpoint,
filename=self.getCheckpointFile(i))
self.nnet.save_checkpoint(folder=self.args.checkpoint,
filename='best.pth.tar')
def __init__(self, file1=None, file2=None):
pygame.mixer.pre_init(44100, -16, 2, 2048)
pygame.init()
self.fps = pygame.time.Clock()
flag = DOUBLEBUF
self.board = pygame.display.set_mode(screenRect, flag)
pygame.display.set_caption('[ --- Pong --- ]')
self.state = 1 # 1 - run, 0 - exit
self.track = Tracking(file1, file2)
self.sound = Sound()
self.p1 = Paddle(self.board, (200, 100, 100), screenRect)
self.p1.setInitialPostition(0, screenHeight / 2)
self.p2 = Paddle(self.board, (100, 200, 100), screenRect)
self.p2.setInitialPostition(screenWidth - self.p2.get()['width'],
screenHeight / 2)
self.ball = Ball(self.board, (50, 50, 250), screenRect, self.sound)
self.ball.setInitialPostition(screenWidth / 2, screenHeight / 2)
self.arena = Arena(self.board, screenRect)
self.referee = Referee(self.ball, self.p1, self.p2, screenRect,
self.sound)
self.t = Thread(target=self.track.run)
#self.track.run()
self.t.start()
self.p1_pos = 0
self.p2_pos = 0
self.loop()
def __init__(self, arena: Arena, x: int, y: int):
self._x, self._y = x, y
self._arena = arena
arena.add_character(self)
self._turn = 0
self._dx = 2 * (y % 2) - 1 # -1 if y is even, +1 if odd
self._size = Boat.DEF_SIZE
def train(self,
n_iterations=30,
n_games=50,
n_eval_games=15,
threshold=0.55):
for i in range(n_iterations):
print('Iteration', i)
train_set = []
for j in range(n_games):
print('Game', j)
game_clone = self.game.clone()
self.play_out(game_clone, train_set)
self.net.save_model()
self.old_net.load_model()
self.net.train(train_set)
new_mcts = MCTS(self.net)
old_mcts = MCTS(self.old_net)
arena = Arena(self.game, old_mcts, new_mcts)
win_rate = arena.fight(n_eval_games)
print('Win rate:', win_rate)
if win_rate > threshold:
print('New best model')
self.net.save_model()
else:
print('Leaving old model')
self.net.load_model()
class HelloWorld(cocos.layer.Layer): # 继承ColorLayer类
is_event_handler = True # 设置状态为处理者，获取鼠标和键盘事件
def __init__(self):
super(HelloWorld, self).__init__()
self.arena = Arena() # 创建Arena对象
self.add(self.arena) # 添加Arena对象
self.score = cocos.text.Label('30',
font_name='Times New Roman',
font_size=24,
color=define.GOLD) # 设置得分面板的格式
self.score.position = 20, 440 # 设置得分面板的位置
self.add(self.score, 99999) # 加入得分面板并设置Z轴位置为99999
self.gameover = Gameover() # 创建Gameover对象
self.add(self.gameover, 100000) # 加入Gameover对象
def update_score(self): # 更新得分
self.score.element.text = str(self.arena.snake.score)
def end_game(self): # 游戏结束
self.gameover.visible = True # 设置Gameover图层为可见
self.gameover.score.element.text = str(
self.arena.snake.score) # 传递得分参数
def on_mouse_press(self, x, y, buttons, modifiers): # 设置重新开始游戏的鼠标事件
if self.gameover.visible: # 当前处于游戏结束状态
self.gameover.visible = False # 设置Gameover图层不可见
self.arena.unschedule(self.arena.update) # 在时间安排表中关闭arena的更新
self.remove(self.arena) # 移除arena对象
self.arena = Arena() # 创建Arena对象
self.add(self.arena) # 添加Arena对象
self.update_score() # 更新得分
def main():
seed(datetime.now())
orcs = [
Character("Orc-" + str(i + 1),
Equipment(uniform(1.1, 1.5), uniform(1.1, 1.3)), 2,
randrange(4)) for i in range(5)
]
orcs += [
Tank("Orc Tank" + str(i + 1),
Equipment(uniform(1.1, 1.5), uniform(1.1, 1.3)), 2, randrange(4))
for i in range(5)
]
night_elves = [
Character("Night Elf" + str(i + 1),
Equipment(uniform(1.1, 1.5), uniform(1.1, 1.3)), 3,
randrange(3)) for i in range(3)
]
night_elves += [
Mage("Night Elf Mage" + str(i + 1),
Equipment(uniform(1.1, 1.5), uniform(1.1, 1.3)), 2, randrange(4))
for i in range(5)
]
a = Arena(orcs, night_elves)
a.play()
def __init__(self):
self.__arena = Arena()
self.__wall = Wall(self.__arena)
self.__snake = Snake(self.__arena)
self.__movement = Movement(self.__arena, self.__snake)
self.cls()
self.gameloop()
def test_add_player(self):
game_display = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
arena = Arena()
player = Player((0, 0), arena)
arena.add_player(player)
self.assertEqual(len(arena.players), 1)
def test_get_non_destructible_walls(self):
game_display = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
arena = Arena()
non_destructible_walls = arena.non_destructible_walls
self.assertEqual(
arena.get_non_destructible_walls(), non_destructible_walls)
class HelloWorld(cocos.layer.Layer):
is_event_handler = True
def __init__(self):
super(HelloWorld, self).__init__()
self.arena = Arena()
self.add(self.arena)
self.score = cocos.text.Label('30',
font_name='Times New Roman',
font_size=24,
color=define.GOLD)
self.score.position = 20, 440
self.add(self.score, 99999)
self.gameover = Gameover()
self.add(self.gameover, 100000)
def update_score(self):
self.score.element.text = str(self.arena.snake.score)
def end_game(self):
self.gameover.visible = True
self.gameover.score.element.text = str(self.arena.snake.score)
def on_mouse_press(self, x, y, buttons, modifiers):
if self.gameover.visible:
self.gameover.visible = False
self.arena.unschedule(self.arena.update)
self.remove(self.arena)
self.arena = Arena()
self.add(self.arena)
self.update_score()
def __init__(self, arena: Arena, x: int, y: int):
self._x, self._y = x, y
self._arena = arena
arena.add_character(self)
self._turn = 0
self._dx = 2 * (y % 2) - 1 # -1 if y is even, +1 if odd
self._size = Boat.DEF_SIZE
class HungrySnake(cocos.layer.Layer):
is_event_handler = True
def __init__(self):
super(HungrySnake, self).__init__()
#新建竞技场图层
self.arena = Arena()
self.add(self.arena)
#分数列表
self.score = cocos.text.Label('0',
font_name='Times New Roman',
font_size=24,
color=definition.GOLD)
self.score.position = 20, 440
self.add(self.score, 99999)
#播放BGM
self.bgm = Audio('assets/audio/bgm.ogg')
self.bgm.play(-1)
#更新分数
def update_score(self):
self.score.element.text = str(self.arena.snake.score)
#游戏结束
def end_game(self):
#bgm暂停
self.bgm.stop()
del self.bgm
#播放失败音效
Audio("assets/audio/gameover.wav").play()
self.arena.unschedule(self.arena.update)
self.arena.accel.stop()
self.parent.gameEnd(str(self.arena.snake.score))
def __init__(self,
image_fn,
description=None,
num_triangles=DEFAULT_NUM_TRIANGLES,
population_size=100):
# to use some of the wx drawing capabilities, must declare the wx.App first
self.app = wx.App(redirect=False)
ref_image = wx.Image(image_fn)
description = description or image_fn
self.num_triangles = num_triangles
self.population_size = population_size
self.best_fitness = 1e100 # exceeding large number
# insert problem description into database
self.db = database.Database(DB_FILE)
image = ref_image.GetData()
width, height = ref_image.GetSize()
self.info_id = self.db.writeInfo(self.num_triangles, 3, width, height,
description, image)
# create the wxImage "arena" where individuals are evaluated for fitness
self.arena = Arena(ref_image)
self.start_time = time.time()
print()
print('Generation Elapsed Fitness')
print('---------- ----------- -------------')
def test_down_tiles_can_be_exploded(self):
game_display = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
arena = Arena()
arena.arena_matrix = self.get_default_arena()
self.assertEqual(
arena.down_tiles_can_be_exploded((1, 1)), ARENA_HEIGHT - 3)
class SnakeBigFightGame(cocos.layer.Layer):
is_event_handler = True
def __init__(self):
super(SnakeBigFightGame, self).__init__()
self.score = cocos.text.Label(
'30', # 显示当前分数用的label
font_name='Times New Roman',
font_size=24,
color=define.GOLD)
self.score.position = 20, 540
self.add(self.score, define.SCORE_LAYER_FLOOR)
self.arena = Arena() # 添加一个竞技场
self.add(self.arena)
self.gameover = GameOver()
self.add(self.gameover, define.GAME_OVER_LAYER_FLOOR)
self.schedule(self.update) # 执行更新
def update(self, dt): # 更新当前分数
self.score.element.text = str(self.arena.snake.score)
def end_game(self): # 游戏结束时的场景
self.gameover.visible = True
self.gameover.score.element.text = str(self.arena.snake.score)
def on_mouse_press(self, x, y, buttons, modifiers): # 当游戏结束时，鼠标点击启动一个新的游戏
if self.gameover.visible:
self.gameover.visible = False
self.arena.unschedule(self.arena.update)
self.remove(self.arena)
self.arena = Arena()
self.add(self.arena)
def on_mouse_press(self, x, y, buttons, modifiers): # 当游戏结束时，鼠标点击启动一个新的游戏
if self.gameover.visible:
self.gameover.visible = False
self.arena.unschedule(self.arena.update)
self.remove(self.arena)
self.arena = Arena()
self.add(self.arena)
def setUp(self):
self.test_arena = Arena('characters.sqlite')
self.test_mage = MageCharacter('Tyler', 10000, 100, 100, 10, 'mage',
10, 10)
self.test_knight = KnightCharacter('Connor', 10000, 100, 100, 10,
'knight', 10, 10, 10)
self.logPoint()
class HelloWorld(cocos.layer.Layer):
is_event_handler = True
def __init__(self):
super(HelloWorld, self).__init__()
self.arena = Arena()
self.add(self.arena)
self.score = cocos.text.Label('30',
font_name='Times New Roman',
font_size=24,
color=define.GOLD)
self.score.position = 20, 440
self.add(self.score, 99999)
self.gameover = Gameover()
self.add(self.gameover, 100000)
def update_score(self):
self.score.element.text = str(self.arena.snake.score)
def end_game(self):
self.gameover.visible = True
self.gameover.score.element.text = str(self.arena.snake.score)
def on_mouse_press(self, x, y, buttons, modifiers):
if self.gameover.visible:
self.gameover.visible = False
self.arena.unschedule(self.arena.update)
self.remove(self.arena)
self.arena = Arena()
self.add(self.arena)
self.update_score()
def __init__(self):
self.__arena = Arena()
self.__player = Mando(self.__arena.board)
self.__enemy = Enemy(self.__arena.board)
self.__score = 0
self.__start = time.time()
self.__frame = 0
self.__framerate = 2
def on_mouse_press(self, x, y, buttons, modifiers): # 设置重新开始游戏的鼠标事件
if self.gameover.visible: # 当前处于游戏结束状态
self.gameover.visible = False # 设置Gameover图层不可见
self.arena.unschedule(self.arena.update) # 在时间安排表中关闭arena的更新
self.remove(self.arena) # 移除arena对象
self.arena = Arena() # 创建Arena对象
self.add(self.arena) # 添加Arena对象
self.update_score() # 更新得分
def test_can_place_bomb(self):
game_display = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
arena = Arena()
arena.arena_matrix = self.get_default_arena()
self.assertEqual(arena._can_place_bomb(1, 1), True)
self.assertEqual(arena._can_place_bomb(2, 2), False)
self.assertEqual(arena._can_place_bomb(5, 1), True)
def test_snapshot_with_dude(self):
pc = Pc()
arena = Arena(1, 1)
arena.get_location(Point(0, 0)).additem(pc)
snapshot = Snapshot(WorldSnapshot(arena), pc.id, [])
stringed = snapshot_to_string(snapshot)
expected = "###\n#\u263A#\n###\nHP: 100, Strength: 10"
self.assertEqual(expected, stringed)
def enterGame(self):
# main game code should be called here
self.arena = Arena(1)
self.arena.start()
self.camera.setPos(0, -5, 1.25)
self.player.start(self.arena.getStartPos(1))
self.player2.start(self.arena.getStartPos(2))
self.taskMgr.add(self.updateWorldCam, "world camera updare task")
def test_snapshot_with_dude(self):
pc = Pc()
arena = Arena(1, 1)
arena.get_location(Point(0, 0)).additem(pc)
snapshot = Snapshot(WorldSnapshot(arena), pc.id, [])
stringed = snapshot_to_string(snapshot)
expected = "###\n#\u263A#\n###\nHP: 100, Strength: 10"
self.assertEqual(expected, stringed)
def on_mouse_press(self, x, y, buttons, modifiers):
if self.gameover.visible:
self.gameover.visible = False
self.arena.unschedule(self.arena.update)
self.remove(self.arena)
self.arena = Arena()
self.add(self.arena)
self.update_score()
def train(n_epoch):
env = Environment()
arena = Arena()
print('Making Models...')
agents = [None, get_ddqn(env), get_ddqn(env)]
agents[1].load('./models/agent1')
# agents[1].replay_buffer.load('./models/replay1.npz')
agents[2].load('./models/agent2')
# agents[2].replay_buffer.load('./models/replay2.npz')
for e in range(n_epoch):
print('-' * 30)
print(f'{e} Epoch Start...')
print('-' * 30)
for i in range(100):
obs = env.reset(1)
done = False
rewards = [0] * 3
value = 0
last = None
while not done:
last = env.state
action = agents[env.current_player].act_and_train(
obs, rewards[env.current_player])
obs, r, done, value = env.step(action)
rewards[env.current_player - 1] = r
assert last is not None
if value == 1:
agents[1].stop_episode_and_train(env.state, 1, True)
agents[-1].stop_episode_and_train(last, -1, True)
elif value == -1:
agents[-1].stop_episode_and_train(env.state, 1, True)
agents[1].stop_episode_and_train(last, -1, True)
elif value == 0:
agents[1].stop_episode_and_train(env.state, 0, True)
agents[-1].stop_episode_and_train(env.state, 0, True)
elif value == 2:
agents[1].stop_episode_and_train(env.state, -1, True)
agents[-1].stop_episode()
elif value == -2:
agents[-1].stop_episode_and_train(env.state, -1, True)
agents[1].stop_episode()
# print(env.print_board())
# print('Result: ', value)
print(f'{i} Episode Ended')
res1, res2 = arena.battles(agents[1], agents[2])
if res1:
dir_name = 'models/' + 'agent1'
print('Saving model', dir_name)
agents[1].save(dir_name)
agents[1].replay_buffer.save('models/replay1.npz')
if res2:
dir_name = 'models/' + 'agent2'
print('Saving model', dir_name)
agents[2].save(dir_name)
agents[2].replay_buffer.save('models/replay2.npz')
def tournament_players(players):
"""Lets every player play against every other player in order to determine their strength"""
timeout = float(input("How much time per move? "))
params = GameParameters(timeout=timeout, verbose=False)
arena = Arena()
scores = {}
print("\nParticipating players:")
for i in range(len(players)):
print("{}: {}".format(i, players[i].__name__))
scores[i] = 0
print("\n ", end=" ")
for i in range(len(players)):
print(i, end=" ")
print()
errors = []
for i in range(len(players)):
print(i, end=" ", flush=True)
for j in range(len(players)):
if i != j:
outcome = arena.play_game(players[i], players[j], BitBoard7x6,
params)
print(outcome.get_char(), end=" ", flush=True)
if outcome.error is not None or outcome.timeout or outcome.illegal:
errors.append((players[i], players[j], outcome))
if outcome.red_won:
scores[i] += 3
elif outcome.tie:
scores[j] += 1
scores[i] += 1
else:
scores[j] += 3
else:
print("X", end=" ", flush=True)
print()
if len(errors) > 0:
print("\nErrors:")
for error in errors:
player1 = error[0].__name__
player2 = error[1].__name__
message = str(error[2])
gameboard = error[2].gb
print("{} (X) vs {} (O): {}\n{}\n".format(player1, player2,
message, gameboard))
print("\nScoreboard:")
sorted_scores = sorted(scores.items(),
key=operator.itemgetter(1),
reverse=True)
for i in range(len(sorted_scores)):
player_name = players[sorted_scores[i][0]].__name__
score = sorted_scores[i][1]
print("{}: {:>3}P {}".format(i, score, player_name))
def run_trial(opt, result_path=None, verbose=False):
# Initialize action and comm bit settings
opt = init_opt(opt)
game = create_game(opt)
agents = create_agents(opt, game)
arena = Arena(opt, game)
test_callback = None
if result_path:
result_out = open(result_path, 'w')
csv_meta = '#' + json.dumps(opt) + '\n'
result_out.write(csv_meta)
writer = csv.DictWriter(result_out, fieldnames=['episode', 'reward'])
writer.writeheader()
test_callback = partial(save_episode_and_reward_to_csv, result_out,
writer)
episode_numbers, rewards = arena.train(agents,
verbose=verbose,
test_callback=test_callback)
plt.figure()
plt.plot(episode_numbers, rewards)
if opt.model_dial == True:
plt.title("DIAL")
else:
plt.title("RIAL")
plt.ylabel("Average Reward")
plt.xlabel("Num Episodes")
if opt.model_dial == True:
plt.savefig("results/dial.png")
else:
plt.savefig("results/rial.png")
plt.close("all")
ACTIONS = [
None, 'The prisoner decided to do nothing.',
'The prisoner chose to tell.'
]
game.reset()
batch = 0
for j in range(10):
ep = arena.run_episode(agents, False)
print("\n\n\nEpisode", j + 1)
for i, step in enumerate(ep.step_records[:-1]):
print('Day', i + 1)
active_agent = game.active_agent[batch][i].item()
print('Prisoner Selected for the interrogation: ', active_agent)
print(ACTIONS[step.a_t[batch].detach().numpy()[active_agent - 1]])
if step.comm[batch].detach().numpy()[active_agent - 1][0] == 1.0:
print('The prisoner toggled the light bulb.')
print()
if step.terminal[batch]:
break
if result_path:
result_out.close()
def mdf_to_array():
part1 = request.form['part1']
part2 = request.form['part2']
arena_obj = Arena()
arena_obj.from_mdf_strings(part1, part2)
arena_2d = arena_to_array(arena_obj)
return json.dumps(arena_2d)
def test_snapshot_with_cat(self):
arena = Arena(1, 1)
location = arena.get_location(Point(0, 0))
cat = Cat()
location.additem(cat)
snapshot = Snapshot(WorldSnapshot(arena), cat.id, [])
stringed = snapshot_to_string(snapshot)
expected = "###\n#x#\n###\nHP: 10, Strength: 2"
self.assertEqual(expected, stringed)
def test_update_matrix_explosion_up(self):
game_display = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
arena = Arena()
arena.arena_matrix = self.get_default_arena()
bomb = Bomb((112, 90), 2, arena)
arena._update_matrix_explosion_up(bomb, TileType.FLAME)
self.assertEqual(arena.arena_matrix[1][3], TileType.FLAME)
def test_snapshot_with_cat(self):
arena = Arena(1, 1)
location = arena.get_location(Point(0, 0))
cat = Cat()
location.additem(cat)
snapshot = Snapshot(WorldSnapshot(arena), cat.id, [])
stringed = snapshot_to_string(snapshot)
expected = "###\n#x#\n###\nHP: 10, Strength: 2"
self.assertEqual(expected, stringed)
def test_snapshot_with_log(self):
arena = Arena(1, 1)
location = arena.get_location(Point(0, 0))
cat = Cat()
location.additem(cat)
log = ["loglog", "log2"]
snapshot = Snapshot(WorldSnapshot(arena), cat.id, log)
stringed = snapshot_to_string(snapshot)
expected = "###\n#x#\n###\n" + "\n".join(log) + "\nHP: 10, Strength: 2"
self.assertEqual(expected, stringed)
def test_snapshot_with_log(self):
arena = Arena(1, 1)
location = arena.get_location(Point(0, 0))
cat = Cat()
location.additem(cat)
log = ["loglog", "log2"]
snapshot = Snapshot(WorldSnapshot(arena), cat.id, log)
stringed = snapshot_to_string(snapshot)
expected = "###\n#x#\n###\n" + "\n".join(log) + "\nHP: 10, Strength: 2"
self.assertEqual(expected, stringed)
def play_game(game, participants_dir, participant_iter_1, participant_iter_2):
print('\n')
print(f'Game beginning! {participant_iter_1} v/s {participant_iter_2}...')
player1 = get_player(game, participants_dir, participant_iter_1)
player2 = get_player(game, participants_dir, participant_iter_2)
show_game = (participant_iter_1 == 'human') or (participant_iter_2
== 'human')
display = game.display if show_game else None
arena = Arena(player1, player2, game, display=display)
return arena.playGame(verbose=show_game)
def main():
seed(datetime.now())
orcs = [Character("Orc-" + str(i + 1), 2, randrange(4)) for i in range(5)]
night_elves = [
Character("Night-Elf-" + str(i + 1), 3, randrange(3)) for i in range(3)
]
a = Arena(orcs, night_elves)
a.play()
def test_update_explosion_in_matrix(self):
game_display = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
arena = Arena()
arena.arena_matrix = self.get_default_arena()
bomb = Bomb((22, 0), 2, arena)
bomb.state = BombState.EXPLODING
arena.update_explosion_in_matrix(bomb)
matrix = arena.get_arena()
self.assertEqual(matrix[1][1], TileType.FLAME)
def createMapTest():
file = open(
"C:\\Users\\nghia\\OneDrive\\CS\\Year 3 sem 2\\CZ3004 MDP\\MazeRunner\\MazeRunner\\algorithm\\mapTest.txt"
).read()
file = file.split()
map = Arena()
for i in range(len(file)):
s = file[i]
for j in range(len(s)):
map.set(i, j, int(s[j]))
print(map.get_2d_arr())
return (map)
def __init__(self):
super(HelloWorld, self).__init__()
self.arena = Arena() # 创建Arena对象
self.add(self.arena) # 添加Arena对象
self.score = cocos.text.Label('30',
font_name='Times New Roman',
font_size=24,
color=define.GOLD) # 设置得分面板的格式
self.score.position = 20, 440 # 设置得分面板的位置
self.add(self.score, 99999) # 加入得分面板并设置Z轴位置为99999
self.gameover = Gameover() # 创建Gameover对象
self.add(self.gameover, 100000) # 加入Gameover对象
def __init__(self):
super(HelloWorld, self).__init__()
self.arena = Arena()
self.add(self.arena)
self.score = cocos.text.Label('30',
font_name='Times New Roman',
font_size=24,
color=define.GOLD)
self.score.position = 20, 440
self.add(self.score, 99999)
self.gameover = Gameover()
self.add(self.gameover, 100000)
class ArenaTests(unittest.TestCase):
def setUp(self):
self._arena = Arena(8, 8)
def testCorner0(self):
p = self._arena.corner_location(0)
util.assertEqual(Point(0,0), p)
def testCorner1(self):
p = self._arena.corner_location(1)
util.assertEqual(Point(0,8), p)
def testCorner2(self):
p = self._arena.corner_location(2)
util.assertEqual(Point(8,8), p)
def testCorner3(self):
p = self._arena.corner_location(3)
util.assertEqual(Point(8,0), p)
def test_limits_origin(self):
p = Point(0,0)
valid = self._arena.position_valid(p)
util.assertTrue(valid)
def test_limits_max(self):
p = Point(8, 8)
valid = self._arena.position_valid(p)
util.assertTrue(valid)
def test_limits_neg(self):
p = Point(8, -8)
valid = self._arena.position_valid(p)
util.assertFalse(valid)
def test_limits_pos(self):
p = Point(8, 16)
valid = self._arena.position_valid(p)
util.assertFalse(valid)
def test_limits_neg2(self):
p = Point(-8, 0)
valid = self._arena.position_valid(p)
util.assertFalse(valid)
def test_limits_pos2(self):
p = Point(16, 0)
valid = self._arena.position_valid(p)
util.assertFalse(valid)
def __init__(self):
super(SnakeBigFightGame, self).__init__()
self.score = cocos.text.Label(
'30', # 显示当前分数用的label
font_name='Times New Roman',
font_size=24,
color=define.GOLD)
self.score.position = 20, 540
self.add(self.score, define.SCORE_LAYER_FLOOR)
self.arena = Arena() # 添加一个竞技场
self.add(self.arena)
self.gameover = GameOver()
self.add(self.gameover, define.GAME_OVER_LAYER_FLOOR)
self.schedule(self.update) # 执行更新
def __init__(self, file1=None, file2=None):
pygame.mixer.pre_init(44100, -16, 2, 2048)
pygame.init()
self.fps = pygame.time.Clock()
flag = DOUBLEBUF
self.board = pygame.display.set_mode(screenRect, flag)
pygame.display.set_caption('[ --- Pong --- ]')
self.state = 1 # 1 - run, 0 - exit
self.track = Tracking(file1, file2)
self.sound = Sound()
self.p1 = Paddle(self.board, (200,100,100),screenRect)
self.p1.setInitialPostition(0,screenHeight/2)
self.p2 = Paddle(self.board, (100,200,100),screenRect)
self.p2.setInitialPostition(screenWidth-self.p2.get()['width'],screenHeight/2)
self.ball = Ball(self.board, (50,50,250), screenRect, self.sound)
self.ball.setInitialPostition(screenWidth/2,screenHeight/2)
self.arena = Arena(self.board, screenRect)
self.referee = Referee(self.ball, self.p1, self.p2, screenRect, self.sound)
self.t = Thread(target=self.track.run)
#self.track.run()
self.t.start()
self.p1_pos = 0
self.p2_pos = 0
self.loop()
def __init__(self):
""" Constructeur """
# Arena de largeur 5 et de hauteur 2. L'initialisation du contenu de l'Arena
# (ses Components) est directement effectuée dans l'init de la classe Arena.
# TRODO : d'ailleurs c'est mal. Mais provisoire.
self.arena = Arena((5, 2))
self.arenaDisplayer = ArenaDisplayer(self.arena)
class Model(object):
"""
Asteroids float in space
"""
def __init__(self, width, height, n_asteroids, min_mass=800, max_mass=1000):
self.min_mass = min_mass
self.max_mass = max_mass
self.schedule = Schedule('move', 'random', 'collision_check', 'collision_response')
Asteroid.activate(self.schedule)
Ship.activate(self.schedule)
Bullet.activate(self.schedule)
CollisionChecker.activate(self.schedule)
self._tick = 0
self.logger = logging.getLogger("Model")
self.arena = Arena(width, height)
for i in range(n_asteroids):
self.add_asteroid()
centre = [self.arena.width / 2, self.arena.height / 2]
self.ship = Ship(centre, 1500, 150, 1500, self.arena)
def add_asteroid(self):
position = (random() * self.arena.width, random() * self.arena.height)
mass = random() * (self.max_mass - self.min_mass) + self.min_mass
velocity = [0, 0]
density = MAX_DENSITY * 0.1 + random() * MAX_DENSITY * 0.9
a = Asteroid(position, mass, velocity, density, self.arena)
a.apply_force(10000 * (random() - 0.5), 10000 * (random() - 0.5))
def tick(self):
self._tick += 1
self.schedule.execute(self.arena.agents())
def __init__(self):
# Initialize arena
self.arena = Arena()
# Initialize other bookkeeping variables
self.total_elapsed = 0
def on_mouse_press(self, x, y, buttons, modifiers):
if self.gameover.visible:
self.gameover.visible = False
self.arena.unschedule(self.arena.update)
self.remove(self.arena)
self.arena = Arena()
self.add(self.arena)
self.update_score()
def main(botname, player):
competition_io = CompetitionIo()
quiet_interactive_io = QuietInteractiveIo()
prop_bot = getattr(B, botname)(bot_io = competition_io)
opp_bot = B.InteractiveBot(bot_io = quiet_interactive_io)
if player == 0:
bot1, bot2 = prop_bot, opp_bot
else:
bot2, bot1 = prop_bot, opp_bot
try:
arena_competition = Arena(arena_io = quiet_interactive_io, bot1 = bot1, bot2 = bot2)
arena_competition.fight()
except EOFError:
pass
class ArenaTests(unittest.TestCase):
def setUp(self):
self._arena = Arena(8, 8)
def testCorner0(self):
p = self._arena.corner_location(0)
util.assertEqual(Point(0, 0), p)
def testCorner1(self):
p = self._arena.corner_location(1)
util.assertEqual(Point(0, 8), p)
def testCorner2(self):
p = self._arena.corner_location(2)
util.assertEqual(Point(8, 8), p)
def testCorner3(self):
p = self._arena.corner_location(3)
util.assertEqual(Point(8, 0), p)
def __init__(self):
super(HelloWorld, self).__init__()
self.arena = Arena()
self.add(self.arena)
self.score = cocos.text.Label('30',
font_name='Times New Roman',
font_size=24,
color=define.GOLD)
self.score.position = 20, 440
self.add(self.score, 99999)
self.gameover = Gameover()
self.add(self.gameover, 100000)
class Battle(object):
def __init__(self):
# Initialize arena
self.arena = Arena()
# Initialize other bookkeeping variables
self.total_elapsed = 0
"""
Called once per game tick
Updates arena
"""
def update(self, events, elapsed):
self.arena.update(events, elapsed)
self.total_elapsed += elapsed
"""
Called once per frame
Draws the arena
"""
def draw(self, screen):
return self.arena.draw(screen)
def __init__(self, width, height, n_asteroids, min_mass=800, max_mass=1000):
self.min_mass = min_mass
self.max_mass = max_mass
self.schedule = Schedule('move', 'random', 'collision_check', 'collision_response')
Asteroid.activate(self.schedule)
Ship.activate(self.schedule)
Bullet.activate(self.schedule)
CollisionChecker.activate(self.schedule)
self._tick = 0
self.logger = logging.getLogger("Model")
self.arena = Arena(width, height)
for i in range(n_asteroids):
self.add_asteroid()
centre = [self.arena.width / 2, self.arena.height / 2]
self.ship = Ship(centre, 1500, 150, 1500, self.arena)
def test_update_player_state(self):
game_display = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
arena = Arena()
player = Player((0, 0), arena)
arena.add_player(player)
arena.arena_matrix[1][1] = TileType.FLAME
arena._update_players_state()
self.assertEqual(player.is_alive(), False)
def arena_load(self, filename_list):
"""Load an arena from a file"""
lines = []
with codecs.open(os.sep.join(filename_list), 'r', 'UTF-8') as fp:
for line in fp:
lines.append(line.rstrip())
self.arena = Arena(max((len(line) for line in lines)), len(lines))
for row, line in enumerate(lines):
for col, char in enumerate(line):
if char == ' ':
continue
self._lookup[char](state=self, coords=(col, row))
def enterGame(self):
# main game code should be called here
self.arena = Arena(self.levelSelection.selectedLevel)
self.arena.start()
self.camera.setPos(0, -5, 1.25)
self.player = Player(0, self.selectedChar1, "p1")
self.player2 = Player(1, self.selectedChar2, "p2")
self.player.setEnemy(self.player2.collisionNodeName)
self.player2.setEnemy(self.player.collisionNodeName)
self.player.start(self.arena.getStartPos(1))
self.player2.start(self.arena.getStartPos(2))
self.taskMgr.add(self.updateWorldCam, "world camera update task")
self.accept("gameOver", self.gameOver)
self.hud.show()
def lifeChanged(charId, health):
base.messenger.send(
"hud_setLifeBarValue",
[charId, health])
self.accept("lifeChanged", lifeChanged)
hide_cursor()
if self.fightMusic.status() != AudioSound.PLAYING:
self.fightMusic.play()
if self.menuMusic.status() == AudioSound.PLAYING:
self.menuMusic.stop()
class ArenaController():
"""
classe qui gère tout le bazar pour une Arena :
Déroulement des cycles d'animation et de jeu, affichage de l'Arena entière, des anims, ...
L'affichage est effectué sur la sortie standard, paf, direct.
Type MVC : Contrôleur
"""
def __init__(self):
""" Constructeur """
# Arena de largeur 5 et de hauteur 2. L'initialisation du contenu de l'Arena
# (ses Components) est directement effectuée dans l'init de la classe Arena.
# TRODO : d'ailleurs c'est mal. Mais provisoire.
self.arena = Arena((5, 2))
self.arenaDisplayer = ArenaDisplayer(self.arena)
def printSeparator(self):
""" écrit une superbe ligne de séparation sur la sortie standard """
print "#" * 79
def refreshAndDisplayAll(self):
"""
Rafraîchit en entier l'image de l'arenaDisplayer, représentant toute l'Arena.
Et balance cette image sur la sortie standard, suivi d'une superbe ligne de séparation.
"""
self.arenaDisplayer.refreshAllScreen()
for line in self.arenaDisplayer.screen:
print line
self.printSeparator()
def ProcessAndAnimOneGameCycle(self):
"""
Exécute, anime, et affiche un cycle de jeu, sur la sortie standard.
On peut recommencer un autre cycle de jeu immédiatement après celui-là.
"""
# Préparation du cycle de jeu en cours
self.arena.handleNextMarbleMove()
self.arenaDisplayer.initAnimation()
# Exécution des cycles d'animation de ce cycle de jeu en cours.
for animCounter in xrange(NB_ANIM_CYCLE_PER_GAME_CYCLE):
if self.arenaDisplayer.advanceAnimationCounter():
# Le cycle d'animation qu'on vient d'exécuter a provoqué un changement dans
# la grande image représentant l'arène.
# On indique quelle est le numéro du cycle d'anim en cours. Pour pouvoir se
# repérer un minimum dans le temps. (Parce qu'en vrai, on peut pas trop
# gérer le temps, puisqu'on balance tout derec sur la sortie standard).
print "animCounter :", animCounter
# Rafraîchissement des zones de l'image de l'Arena qui sont susceptibles
# de changer. Et affichage, sur la sortie standard, de toute l'image
self.arenaDisplayer.refreshAnimation()
for line in self.arenaDisplayer.screen:
print line
self.printSeparator()
# Si le cycle d'anim qu'on vient d'exécuter n'a pas provoqué de changement dans
# l'image, on ne la réaffiche pas sur la sortie standard. Ca servirait à rien.
print "animation ended"
# Terminaison du cycle de jeu en cours. Modification des coordonnées des marbles
# dans l'Arena, selon le mouvement qu'on avait prévus lors de la préparation de ce
# cycle de jeu.
self.arena.doMarbleMove()
self.printSeparator()
class TestArena(TestCase):
def setUp(self):
self.arena = Arena(12, 12)
def test_get_location(self):
self.arena.get_location(Point(1, 1)).additem('asdf')
self.arena.get_location(Point(1, 1)).removeitem('asdf')
def test_find_character(self):
self.arena.get_location(Point(1, 2)).additem('asdf')
self.assert_character_location(self.arena, 1, 2)
def test_move_item(self):
self.arena.get_location(Point(1, 2)).additem('asdf')
self.arena.move_item('asdf', Point(3, 5))
self.assert_character_location(self.arena, 3, 5)
def test_width_and_height(self):
arena = Arena(10, 4)
self.assertEqual(10, arena.width)
self.assertEqual(4, arena.height)
def test_copy(self):
self.arena.get_location(Point(1, 2)).additem('asdf')
copy = self.arena.copy()
copy.move_item('asdf', Point(3, 5))
self.assert_character_location(copy, 3, 5)
self.assert_character_location(self.arena, 1, 2)
def test_ingrid(self):
self.assertEqual(self.arena.in_grid(Point(-1, 0)), False)
self.assertEqual(self.arena.in_grid(Point(0, -1)), False)
self.assertEqual(self.arena.in_grid(Point(1, 0)), True)
self.assertEqual(self.arena.in_grid(Point(0, 4)), True)
self.assertEqual(self.arena.in_grid(Point(0, 5)), True)
self.assertEqual(self.arena.in_grid(Point(1, 12)), False)
self.assertEqual(self.arena.in_grid(Point(12, 1)), False)
def assert_character_location(self, arena, x, y):
found = arena.find_character('asdf')
self.assertEqual(found.x, x)
self.assertEqual(found.y, y)
def setUp(self):
self.arena = Arena(12, 12)
bot2 = IdleBot(bot_io = thunk_io))
#arena_interactive.fight()
# Two randoms duking it out
arena_random = Arena(arena_io = game_io,
bot1 = RandomBot(bot_io = CompositeIo(game_io, WriteReplayIo(fd = rpl_fd))),
bot2 = RandomBot(bot_io = thunk_io))
#arena_random.fight()
# Non-interactive faux strat against idle with replay
strategy_bot_test = StrategyBot(bot_io = CompositeIo(game_io, WriteReplayIo(fd = rpl_fd)))
strategy_bot_test.add_strategy(
SequenceStrategy(
#GenerateValueStrategy(slot = 0, target = 15),
#GenerateValueStrategy(slot = 1, target = 3),
#GenerateValueStrategy(slot = 3, target = 15),
#AppNTo0Strategy(slot = 2, n_slot = 4),
#GetIStrategy(slot = 100, i_slot = 1),
#AppFIJNStrategy(slot = 2, f_card = cards.help, i_num = 3, j_num = 3, n_num = 8192),
#AppFIJNStrategy(slot = 2, f_card = cards.attack, i_num = 3, j_num = 3, n_num = 1024),
DumbSlotKiller(battery_slot = 3, target_slot = 252),
#IdleStrategy(),
))
arena_strategy = Arena(arena_io = game_io,
bot1 = IdleBot(bot_io = thunk_io),
bot2 = strategy_bot_test)
arena_strategy.fight()
game_io.notify_total_time(clock() - start)
import random
import numpy
from numpy import pi
from pylab import show, draw, ion
from arena import Wall, Robot, Arena
from importance import *
if __name__ == "__main__":
random.seed(10)
numpy.random.seed(10)
w11 = Wall(0.15, 0.05, 0.15, 0.45)
w12 = Wall(0.15, 0.55, 0.15, 0.95)
w2 = Wall(0.15, 0.95, 0.7, 0.95)
w3 = Wall(0.2, 0.5, 0.7, 0.5)
r = Robot(0.95, 0.05, 0)
Arena.plot()
for i in xrange(4):
r.move("GO", 0.06);
Arena.plot()
# particle_filter(Arena, N = 100000, resampT = -1)
particle_filter(Arena, N = 100000)
show()
