def __init__(self, player1: Player, player2: Player):
self.__player1 = player1
self.__player2 = player2
self.__set_move_strategy(player1)
self.__set_move_strategy(player2)
self.__board_builder = Connect4BoardBuilder()
self.__game_state = GameState(self.__board_builder, player1)
def main():
window = arcade.Window(constants.SCREEN_WIDTH, constants.SCREEN_HEIGHT,
constants.SCREEN_TITLE)
views = {}
game = Director(views)
game_state = GameState()
start_screen = StartScreen(views)
controls = ControlScreen(views)
game_over = GameOverView(views)
win_screen = WinScreen(views)
views['window'] = window
views['game'] = game
views['start_screen'] = start_screen
views['controls'] = controls
views['game_over'] = game_over
views['win_screen'] = win_screen
views['game_state'] = game_state
views['window'].show_view(views['start_screen'])
game_view = views['start_screen']
game_view.setup()
arcade.run()
def replay(self, wps, pi_mcts, board_logs, plus_turns, weights,
batch_size: int, beta: float) -> None:
inputs = np.zeros((batch_size, 7, 5, 3))
policy_true = np.zeros((batch_size, 315))
values_true = np.zeros((batch_size))
input_weights = np.zeros((batch_size))
indices = np.random.choice(np.arange(len(wps)),
size=batch_size,
replace=False)
mini_batch = [(wps[i], pi_mcts[i], board_logs[i], plus_turns[i],
weights[i]) for i in indices]
for i, (winner, pi, board, plus_turn, weight) in enumerate(mini_batch):
gs = GameState()
gs.board = board
inputs[i] = gs.to_inputs(flip=not plus_turn) # shape=(4, 5, 5)
policy_true[i] = pi**beta
values_true[i] = winner
input_weights[i] = weight
# epochsは訓練データの反復回数、verbose=0は表示なしの設定
self.model.fit(inputs, [policy_true, values_true],
sample_weight=input_weights,
epochs=1,
verbose=0,
shuffle=True)
def new_game(self,
layout,
pacman_agent,
ghost_agents,
display,
quiet=False,
catch_exceptions=False):
agents = [pacman_agent] + ghost_agents[:layout.get_ghost_count()]
init_state = GameState()
init_state.initialize(layout, len(ghost_agents))
game = Game(agents, display, self, catch_exceptions=catch_exceptions)
game.state = init_state
self.initial_state = init_state.deep_copy()
self.quiet = quiet
return game
def get_input():
k, m, n = map(int, input().split())
space = Space(n, m, k)
initial_state = GameState()
for i in range(k):
input_string = input()
column = Column()
if input_string != '#':
for card in input_string.split():
column.add_card(Card(card[-1], int(card[:-1])))
initial_state.add_column(column)
space.add_state(initial_state)
return space
def __init__(self):
# initialize imported components
pygame.init()
# number of frames rendered per second
# (equal to number of loop turns)
self.FPS = 60
# clock to synchronize ticks with desired FPS
self.clock = pygame.time.Clock()
# main loop condition
self.running = True
# initialize subsystems
self.drawer = Drawer()
self.handler = EventHandler(self)
self.game_state = GameState()
self.manager = Manager()
self.ticker = Ticker(self)
def __init__(self, settings: Settings) -> None:
pygame.init()
self.settings = settings
self.font = pygame.font.SysFont("Arial", 18)
self.display = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
self.clock = pygame.time.Clock()
pygame.display.set_caption(self.settings.window_caption)
self.running = False
self.current_level = LevelFactory.create(1)
self.camera_position = self.current_level.initial_position
self.game_state = GameState(self.current_level)
self.level_renderer = MapRenderer(
self.game_state,
self.display,
self.current_level.sprite,
)
def __init__(self, thread_index, global_network, initial_learning_rate,
learning_rate_input, optimizer, max_global_time_step, device):
self.thread_index = thread_index
self.learning_rate_input = learning_rate_input
self.max_global_time_step = max_global_time_step
if USE_LSTM:
self.local_network = A3CLSTMNetwork(STATE_DIM, STATE_CHN,
ACTION_DIM, device,
thread_index)
else:
self.local_network = A3CFFNetwork(STATE_DIM, STATE_CHN, ACTION_DIM,
device, thread_index)
self.local_network.create_loss(ENTROPY_BETA)
self.gradients = tf.gradients(self.local_network.total_loss,
self.local_network.get_vars())
clip_accum_grads = [
tf.clip_by_norm(accum_grad, 10.0) for accum_grad in self.gradients
]
self.apply_gradients = optimizer.apply_gradients(
zip(clip_accum_grads, global_network.get_vars()))
# self.apply_gradients = optimizer.apply_gradients(zip(self.gradients, global_network.get_vars()))
self.sync = self.local_network.sync_from(global_network)
self.game_state = GameState(thread_index)
self.local_t = 0
self.initial_learning_rate = initial_learning_rate
# for log
self.episode_reward = 0.0
self.episode_start_time = 0.0
self.prev_local_t = 0
return
def PlayGame(stop_flag, attach_target):
gs = GameState()
items = [
"spellthief's edge", "Tear of the Goddess", "kindlegem",
"amplifying Tome", "amplifying Tome", "Blasting Wand", "EverFrost"
]
loop_count = 1
ff_time = 0
first_run = True
s_time = time.time()
increase_loop_dur = random.randint(3, 7)
while Client.is_league_game_running():
gs.update()
if gs.has_game_started() and not stop_flag['val']:
if first_run is True:
time.sleep(1)
Actions.cast_spell('ctrl+4')
Actions.cast_spell('y')
time.sleep(1)
Actions.purchase_recommend()
first_run = False
ff_time = time.time() + 60 * 15
Actions.action_troll_ward(gs.get_my_team_side())
if time.time() > ff_time:
Actions.type_in_chat("/ff")
ff_time += 60
if not gs.is_adc_dead() and not gs.is_i_dead():
if gs.is_yummi_attached() is True:
if gs.is_adc_hp_low() is True:
Actions.cast_spell('e')
if gs.is_adc_hp_critical() is True:
coord = gs.get_general_enemy_dir_coords()
Actions.cast_spell('d')
mouse.move(coord.x, coord.y)
time.sleep(0.01)
Actions.cast_spell('r')
time.sleep(0.01)
Actions.cast_spell('q')
else:
Actions.yummi_attach(attach_target['val'])
if gs.is_i_dead():
Actions.purchase_recommend()
if random.randint(0, 15) == 10:
Actions.type_shit_in_chat()
if gs.is_adc_dead() and not gs.is_i_dead():
if gs.get_fountain_coords() is not None:
Actions.retreat(gs.get_fountain_coords())
if time.time() - s_time > increase_loop_dur:
loop_count = loop_count + 1
increase_loop_dur = random.randint(3, 7)
s_time = time.time()
if loop_count % 3 == 0:
if random.randint(0, 1) == 1:
pass
Actions.random_mouse_movement()
time.sleep(0.15)
if loop_count % 4 == 0:
if random.randint(0, 1) == 1:
Actions.level_all_spells('r', 'q', 'w', 'e')
if loop_count % 15 == 0:
if random.randint(0, 1) == 1:
if gs.is_yummi_attached():
Actions.cast_spell('4')
Actions.cast_spell('1')
if loop_count % 15 == 0:
if random.randint(0, 1) == 1:
if gs.is_yummi_attached():
Actions.cast_spell('ctrl+4')
time.sleep(0.04)
from classifier.digit_classifier import DigitClassifier
import cv2
if __name__ == "__main__":
if len(argv) < 2:
print("Provide an index")
test_img_index = int(argv[1])
img = cv2.imread(f"test_data/frame_{test_img_index}.png", cv2.IMREAD_COLOR)
game_data_handler = TestGameData(test_img_index)
game_classifier = GameClassifier()
game_classifier.load()
digit_classifier = DigitClassifier()
digit_classifier.load()
game_state = GameState(game_data_handler, digit_classifier)
state, data = game_state.get_game_state(img)
game_data, my_team = data
classifier_input = game_dataset.shape_input(game_data, game_data_handler)
outcome = game_classifier.predict(classifier_input)
if my_team == "red":
outcome = 1 - outcome
pct = f"{outcome * 100:.2f}"
print(f"Probability of win: {pct}%", flush=True)
shape = (img.shape[1] // 2, img.shape[0] // 2)
resized = cv2.resize(img, shape, interpolation=cv2.INTER_AREA)
atexit.register(cleanup)
get_nicknames(clients)
print('The players playing are: ', end='')
for i, client in enumerate(clients):
print(client[NAME], end='')
if not i == len(clients) - 1:
print(', ', end='')
else:
print() # newline
maze = random_maze(MAZE_WIDTH, server_config.MAP_COMPLEXITY,
server_config.MAP_DENSITY, PLAYERS)
game = GameState(maze)
for id_, client in enumerate(clients):
player = Player(maze.starting_locations[id_], client[NAME])
client['id'] = player.id
client[PLAYER] = player
game.add_player(player)
init_player_data = []
for _, player in game.players.items():
init_player_data.append(player.serializable_init())
print("Sending maze data...")
# Send the maze to all clients
for client in clients:
network.message.send_msg(client[SOCKET][0], str.encode(maze.as_json()))
def setUp(self):
self.gs = GameState()
def learn(model_config_path=None, weight_path=None):
config = Config()
qc = config.Qlearn
total_reward_vec = np.zeros(qc.num_consecutive_iterations) # 各試行の報酬を格納
# Qネットワークとメモリ、Actorの生成--------------------------------------------------------
if model_config_path is None or weight_path is None:
mainQN = QNetwork(config) # メインのQネットワーク
mainQN.build()
targetQN = QNetwork(config) # 価値を計算するQネットワーク
targetQN.build()
else:
mainQN = QNetwork(config)
success_load = mainQN.load(model_config_path, weight_path)
if not success_load:
raise FileNotFoundError(
f"{model_config_path} {weight_path}が読み込めませんでした")
targetQN = QNetwork(config)
targetQN.load(model_config_path, weight_path)
memory = Memory(max_size=qc.memory_size)
for episode in trange(qc.num_episodes): # 試行数分繰り返す
gs = GameState()
state = gs.random_play() # 1step目は適当な行動をとる
episode_reward = 0
targetQN.model.set_weights(
mainQN.model.get_weights()) # 行動決定と価値計算のQネットワークをおなじにする
for t in range(qc.max_number_of_steps): # 2手のループ
board = gs.to_inputs()
state, action = take_action_eps_greedy(board, episode, mainQN,
gs) # 時刻tでの行動を決定する
# next_state, reward, done, info = env.step(action) # 行動a_tの実行による、s_{t+1}, _R{t}を計算する
# verbose ==========
# if t % 10 == 9:
# print(gs)
# ==================
if state == Winner.minus:
reward = qc.reward_win # 報酬
else:
reward = 0
next_board = gs.to_inputs()
# board = next_board # 状態更新
# 1施行終了時の処理
if state != Winner.not_ended:
episode_reward += reward # 合計報酬を更新
memory.add((board, action, reward, next_board)) # メモリの更新する
# Qネットワークの重みを学習・更新する replay
if len(memory) > qc.batch_size: # and not islearned:
mainQN.replay(memory, qc.batch_size, qc.gamma, targetQN)
if qc.DQN_MODE:
targetQN.model.set_weights(
mainQN.model.get_weights()) # 行動決定と価値計算のQネットワークをおなじにする
total_reward_vec = np.hstack(
(total_reward_vec[1:], episode_reward)) # 報酬を記録
print(
'%d/%d: Episode finished after %d time steps / mean %f winner: %s'
% (episode + 1, qc.num_episodes, t + 1,
total_reward_vec.mean(),
'plus' if state == Winner.plus else 'minus'))
break
state, _ = gs.random_play()
if state == Winner.plus:
reward = qc.reward_lose
else:
reward = 0
episode_reward += reward # 合計報酬を更新
memory.add((board, action, reward, next_board)) # メモリの更新する
# Qネットワークの重みを学習・更新する replay
if len(memory) > qc.batch_size: # and not islearned:
mainQN.replay(memory, qc.batch_size, qc.gamma, targetQN)
if qc.DQN_MODE:
targetQN.model.set_weights(
mainQN.model.get_weights()) # 行動決定と価値計算のQネットワークをおなじにする
# 1施行終了時の処理
if state != Winner.not_ended:
total_reward_vec = np.hstack(
(total_reward_vec[1:], episode_reward)) # 報酬を記録
print(
'%d/%d: Episode finished after %d time steps / mean %f winner: %s'
% (episode + 1, qc.num_episodes, t + 1,
total_reward_vec.mean(),
'plus' if state == Winner.plus else 'minus'))
break
# 複数施行の平均報酬で終了を判断
# if total_reward_vec.mean() >= goal_average_reward:
# print('Episode %d train agent successfuly!' % episode)
# islearned = True
if episode % qc.save_interval == qc.save_interval - 1:
d = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S')
mainQN.save(f"results/001_QLearning/{d}-mainQN.json",
f"results/001_QLearning/{d}-mainQN.h5")
with open(f"results/001_QLearning/{d}-config.json", 'x') as f:
json.dump(config._to_dict(), f, indent=4)
# 最後に保存(直前にしていればしない)
if episode % qc.save_interval != qc.save_interval - 1:
d = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S')
mainQN.save(f"results/001_QLearning/{d}-mainQN.json",
f"results/001_QLearning/{d}-mainQN.h5")
with open(f"results/001_QLearning/{d}-config.json", 'x') as f:
json.dump(config._to_dict(), f, indent=4)
def new_game():
print("NEW GAME")
g = GameState(3, 3, 3)
play(g)
{
"championId": self.champions[8], "teamId": 200, "summonerId": self.summ_ids[8],
"spell1Id": self.get_summoner_spell_index(self.summs[8][0]), # Exhaust
"spell2Id": self.get_summoner_spell_index(self.summs[8][1]) # Flash
},
{
"championId": self.champions[9], "teamId": 200, "summonerId": self.summ_ids[9],
"spell1Id": self.get_summoner_spell_index(self.summs[9][0]), # Ignite
"spell2Id": self.get_summoner_spell_index(self.summs[9][1]) # Flash
}
]
}
if __name__ == "__main__":
test_img_index = 4
img = cv2.imread(f"test_data/frame_{test_img_index}.png", cv2.IMREAD_COLOR)
champion_data = TestGameData(test_img_index)
digit_classifier = DigitClassifier()
digit_classifier.load()
game_state_handler = GameState(champion_data, digit_classifier)
state, data = game_state_handler.get_game_state(img)
game_data, my_team = data
for team in game_data:
print(f"====== {team.upper()} TEAM ======")
print(f"Towers destroyed: {game_data[team]['towers_destroyed']}")
print(f"Dragons: {game_data[team]['dragons']}")
for player_data in game_data[team]["players"]:
print(player_data)
print("***********************************************")
