def run(sample_number, resolution):
global engine, screen
print("hi")
screen = pygame.display.set_mode(resolution if resolution else (600, 600))
engine = Engine(screen)
globals()[f"sample_{sample_number}"]()
engine.start()
def __init__(self, datafile, db, log):
with open(datafile, 'rb') as src:
self.data = Data(src)
self.engine = Engine(self.data, log=log)
self.db = db
self.log = log
def __init__(self,max_moves,ai_config,opponent_config,param_ranges,n_iter,n_games,init_params,n_batches = 1):
self.ai_config = ai_config
self.opponent_config = opponent_config
self.param_ranges = param_ranges
self.n_iter = n_iter
self.n_games = n_games
self.max_moves = max_moves
self.engine = Engine(self.max_moves,self.ai_config, self.opponent_config)
self.params = init_params
self.n_batches = n_batches
self.score_history = []
self.the_good_ones = []
def setUp(self):
self.cleaner = Mock()
self.cleaner.position = MagicMock(return_value=(1, 1))
self.environment = Mock()
self.touch_sensor = Mock()
self.photo_sensor = Mock()
self.infrared_sensor = Mock()
self.engine = Engine(
self.cleaner, self.environment, self.touch_sensor, self.photo_sensor, self.infrared_sensor,
)
def main(datafile):
''' Text Adventure CLI
DATAFILE - Path to ScottFree data file
'''
data = Data(datafile)
state = StateFromGameData(data)
engine = Engine(data)
state = engine.start_game(state)
click.echo(state.last_message)
repl = REPL(engine, state)
repl.cmdloop()
def main(datafile):
''' Text Adventure CLI
DATAFILE - Path to ScottFree data file
'''
data = Data(datafile)
state = StateFromGameData(data)
engine = Engine(data)
state = engine.start_game(state)
click.echo(state.last_message)
repl = REPL(engine, state)
repl.cmdloop()
def __init__(self, datafile, db, log):
with open(datafile, 'rb') as src:
self.data = Data(src)
self.engine = Engine(self.data, log=log)
self.db = db
self.log = log
class Server(object):
def __init__(self, datafile, db, log):
with open(datafile, 'rb') as src:
self.data = Data(src)
self.engine = Engine(self.data, log=log)
self.db = db
self.log = log
def play(self, player, command):
self.log.debug('Searching for player %s in DB', player)
db_player = self.db.session.query(User).filter_by(
sender_id=player).all()
if db_player:
self.log.debug('Found player; loading state')
state = StateFromDatabase(db_player[0])
self.log.debug('Location: %s', state.current_location)
self.log.debug('Flags: %s', state.bitflags)
else:
self.log.debug('New player; take initial state from game data')
state = StateFromGameData(self.data)
new_state = self.engine.start_game(state)
self._save_to_db(player, new_state)
return new_state.last_message
self.log.debug('Command: %s', command)
new_state = self.engine.process(state, command)
self._save_to_db(player, new_state)
return new_state.last_message
def _save_to_db(self, player, state):
self.log.debug('Bitflags: %s', state.bitflags)
item_string = ','.join(str(item.location) for item in state.items)
db_state = User(
sender_id=player,
game_id=self.data.version['game_id'],
bitflags=state.serialise_bitflags(),
items=item_string,
current_location=state.current_location,
)
self.db.session.merge(db_state)
self.db.session.commit()
def __init__(self, start=None, n_games=10, start_temp=1024, factor=2):
self.start = start
if start == None:
self.start = get_random_start()
self.delta = 0.00001
self.n_games = n_games
#make both of them random, but the simpel start state
self.player_config = {
Settings.AI.value: True, #should this be Ai or person
Settings.START_TYPE.value:
StartType.SIMPLE.value, #what kind of start state
Settings.START_PARAMS.value: [], #any parameters for the stater
Settings.SEARCH_TYPE.value:
SearchType.RANDOM.value, #what kind of search is happening
Settings.SEARCH_PARAMS.value: [], #any parameters for the search
Settings.AI_TYPE.value: AIType.NONE.value, # what is the AI
Settings.AI_PARAMS.value: [] #any params for the ai
}
self.opponent_config = {
Settings.AI.value: True, #should this be Ai or person
Settings.START_TYPE.value:
StartType.CHAMPION.value, #what kind of start state
Settings.START_PARAMS.value: [], #any parameters for the stater
Settings.SEARCH_TYPE.value:
SearchType.RANDOM.value, #what kind of search is happening
Settings.SEARCH_PARAMS.value: [], #any parameters for the search
Settings.AI_TYPE.value: AIType.NONE.value, # what is the AI
Settings.AI_PARAMS.value: [] #any params for the ai
}
self.engine = Engine(1000)
self.best, stats = self.simulated_annealing(start_temp, factor)
print(self.best)
f = open("train/simulated_annealing_results.txt", "a")
t = open("train/simulated_annealing_factors.txt", "a")
s = open("train/simuated_annealing_start_state.txt", "a")
g = open("train/simulated_annealing_stats.txt", "a")
f.write("{}\n".format(self.best))
t.write("{}\n".format([start_temp, factor]))
s.write("{}\n".format(self.start))
g.write("{}\n".format(stats))
g.close()
s.close()
t.close()
f.close()
class Server(object):
def __init__(self, datafile, db, log):
with open(datafile, 'rb') as src:
self.data = Data(src)
self.engine = Engine(self.data, log=log)
self.db = db
self.log = log
def play(self, player, command):
self.log.debug('Searching for player %s in DB', player)
db_player = self.db.session.query(User).filter_by(sender_id=player).all()
if db_player:
self.log.debug('Found player; loading state')
state = StateFromDatabase(db_player[0])
self.log.debug('Location: %s', state.current_location)
self.log.debug('Flags: %s', state.bitflags)
else:
self.log.debug('New player; take initial state from game data')
state = StateFromGameData(self.data)
new_state = self.engine.start_game(state)
self._save_to_db(player, new_state)
return new_state.last_message
self.log.debug('Command: %s', command)
new_state = self.engine.process(state, command)
self._save_to_db(player, new_state)
return new_state.last_message
def _save_to_db(self, player, state):
self.log.debug('Bitflags: %s', state.bitflags)
item_string = ','.join(str(item.location) for item in state.items)
db_state = User(sender_id=player,
game_id=self.data.version['game_id'],
bitflags=state.serialise_bitflags(),
items=item_string,
current_location=state.current_location,
)
self.db.session.merge(db_state)
self.db.session.commit()
def test_should_set_home_when_engine_init(self):
home_position = (1, 1)
self.cleaner.position = MagicMock(return_value=home_position)
environment = Mock()
Engine(
self.cleaner, environment, self.touch_sensor, self.photo_sensor, self.infrared_sensor,
)
environment.set_home.assert_called_once_with(home_position)
def __init__(self, menu, players):
super().__init__()
self.menu = menu
self.setWindowTitle('Code with Fire')
self.setGeometry(200, 50, 800, 650)
self.player_names = players
self.alive_players = len(players)
self.game_engine = Engine()
self.game_screen = Screen(self.game_engine)
self.score_manager = ScoreManager(self.game_screen)
self.setCentralWidget(self.game_screen)
self.create_menu_bar()
self.start_game(players)
def __init__(self, config, max_moves):
self.ai_configs = []
for filename in config[AI_FIELD][AIType.REACHABLE.value]:
self.ai_configs += read_file_into_configs(filename,
reachable_config)
for filename in config[AI_FIELD][AIType.MODIFIED_REACHABLE.value]:
self.ai_configs += read_file_into_configs(filename,
mod_reachable_config)
for filename in config[AI_FIELD][AIType.PIECE_BASED_ADD.value]:
self.ai_configs += read_file_into_configs(filename,
piecebased_config_add)
for filename in config[AI_FIELD][AIType.PIECE_BASED_MUL.value]:
self.ai_configs += read_file_into_configs(filename,
piecebased_config_mul)
self.start_configs = []
for filename in config[START_FIELD]:
self.start_configs += read_file_into_configs(
filename, flexible_start_config)
self.engine = Engine(max_moves, None, None)
self.max_moves = max_moves
def lint_and_run_game(pylint_args, fullscreen, resolution):
"""Run pylint, get the output, parse it, initialize the game and run it."""
animal_groups = create_animals(parse(lint(pylint_args)))
flags = pygame.FULLSCREEN if fullscreen else 0
if not resolution and not fullscreen:
resolution = (600, 600)
screen = pygame.display.set_mode((0, 0) if fullscreen else resolution,
flags)
organize_groups(screen, animal_groups)
engine = Engine(screen)
for animal_group in animal_groups:
engine.add_animals(*animal_group)
engine.start()
def test_game():
animal1 = Animal(shape="Y", max_health=2, size=40)
animal2 = Animal(shape="X", max_health=2, size=40)
animal1.also_likes_to_eat(animal2)
animal2.also_likes_to_eat(animal1)
screen = pygame.display.set_mode((600, 600))
animal1.put_relative(30, 30, screen)
animal2.put_relative(60, 60, screen)
engine = Engine(screen)
engine.add_animals(animal1, animal2)
engine.start()
def test_is_human():
engine = Engine()
player = Player(True, engine)
assert player.is_human()
""" // Filename : Instances // Created by: @ngeorgj This file holds the base instances for the game, don't change anything! """ from game.engine import Engine from game.cgame import Game game_engine = Engine() rpg = Game() rpg.engine = game_engine
class EngineTestCase(unittest.TestCase):
def setUp(self):
self.cleaner = Mock()
self.cleaner.position = MagicMock(return_value=(1, 1))
self.environment = Mock()
self.touch_sensor = Mock()
self.photo_sensor = Mock()
self.infrared_sensor = Mock()
self.engine = Engine(
self.cleaner, self.environment, self.touch_sensor, self.photo_sensor, self.infrared_sensor,
)
def test_should_get_score(self):
score = self.engine.score()
self.assertEqual(score, 0)
def test_should_lose_score_when_take_action(self):
self.engine.push_action("go_forward")
score = self.engine.score()
self.assertEqual(score, -1)
def test_should_get_score_when_successfully_clean_up(self):
self.cleaner.position = MagicMock(return_value=(1, 1))
self.environment.grids = MagicMock(return_value=[
[1, 1],
[0, 1],
])
self.engine.push_action("clean")
score = self.engine.score()
self.assertEqual(score, 100 - 1)
def test_should_do_nothing_and_terminate_when_turn_off_at_the_home_location(self):
self.environment.home = MagicMock(return_value=(1, 1))
self.cleaner.position = MagicMock(return_value=(1, 1))
self.engine.push_action("turn_off")
score = self.engine.score()
self.assertEqual(score, -1)
def test_should_reduce_score_and_terminate_when_turn_off_at_the_different_location(self):
self.engine.push_action("turn_off")
self.environment.home = MagicMock(return_value=(2, 2))
self.cleaner.position = MagicMock(return_value=(1, 1))
score = self.engine.score()
self.assertEqual(score, - 1000 - 1)
def test_should_not_get_score_when_clean_up_empty_tile(self):
self.cleaner.position = MagicMock(return_value=(0, 0))
self.environment.grids = MagicMock(return_value=[
[1, 1],
[0, 1],
])
self.engine.push_action("clean")
score = self.engine.score()
self.assertEqual(score, -1)
def test_should_set_home_when_engine_init(self):
home_position = (1, 1)
self.cleaner.position = MagicMock(return_value=home_position)
environment = Mock()
Engine(
self.cleaner, environment, self.touch_sensor, self.photo_sensor, self.infrared_sensor,
)
environment.set_home.assert_called_once_with(home_position)
def test_should_act_and_update_when_move(self):
next_cleaner = Mock()
self.cleaner.act = MagicMock(return_value=next_cleaner)
self.engine.push_action("go_forward")
self.cleaner.act.assert_called_with("go_forward")
self.assertEqual(self.engine._latest_cleaner, next_cleaner)
self.touch_sensor.set_cleaner.assert_called_with(next_cleaner)
self.photo_sensor.set_cleaner.assert_called_with(next_cleaner)
self.infrared_sensor.set_cleaner.assert_called_with(next_cleaner)
self.assertIn(next_cleaner, self.engine._history)
def test_should_call_sensors_to_retrieve_information(self):
self.touch_sensor.run = MagicMock(return_value=1)
self.photo_sensor.run = MagicMock(return_value=0)
self.infrared_sensor.run = MagicMock(return_value=1)
results = self.engine.sensors()
self._assertSensors(results, (1, 0, 1))
def test_should_clean_room_and_set_new_grids(self):
self.cleaner.position = MagicMock(return_value=(1, 1))
self.environment.grids = MagicMock(return_value=[
[1, 1],
[0, 1],
])
self.engine.push_action("clean")
self.environment.set_grids.assert_called_once_with([
[1, 0],
[0, 1],
])
def _assertSensors(self, results, expectations):
touch_sensor, photo_sensor, infrared_sensor = results
self.assertEqual(touch_sensor, expectations[0])
self.assertEqual(photo_sensor, expectations[1])
self.assertEqual(infrared_sensor, expectations[2])
def test_constructor():
#simple test to make sure that the constructor runs
my_engine = Engine()
# get_image_data())
#game_window.set_icon(icon)
class Score:
def __init__(self):
self.meters = 0
self.top = 0
def __iadd__(self, value):
self.meters += value
if self.meters > self.top:
self.top = self.meters
return self
score = Score()
title = Title(assets, score)
engine = Engine(assets, score)
director = Director(constants.VWIDTH * 2,
constants.VHEIGHT * 2,
caption="Fuel4TheLight",
vwidth=constants.VWIDTH,
vheight=constants.VHEIGHT)
director.set_background_color(0., 0., 0.)
Director.add_scene("title", title)
Director.add_scene("engine", engine)
Director.set_scene("title")
pyglet.app.run()
import game.chapter_one.main
import game.chapter_two.main
from game.engine import Engine, SceneMap
print("Starting the engine...")
a_map = SceneMap()
a_game = Engine(a_map)
a_game.play()
class GUI:
def ind_map_click(self, i, j):
def map_click(throw_me_away):
#ignore if the current player ia an Ai
print("click")
if self.player1_turn and self.player1_config[Settings.AI.value]:
return None
if not self.player1_turn and self.player2_config[
Settings.AI.value]:
return None
if self.button_counter % 2 is 0:
self.clicked_buttons.append((i, j))
self.button_counter += 1
else:
self.clicked_buttons.append((i, j))
self.button_counter += 1
p = self.e.player1
if not self.player1_turn:
p = self.e.player2
print(self.clicked_buttons)
p.set_move(self.clicked_buttons)
turn = self.e.make_move()
#print(self.curselection())
print(i, j)
if turn == self.player1_turn:
self.clicked_buttons = []
self.button_counter = 0
else:
self.clicked_buttons = []
self.button_counter = 0
self.player1_turn = not self.player1_turn
self.update()
if ((self.player1_turn
and self.player1_config[Settings.AI.value])
or (not self.player1_turn
and self.player2_config[Settings.AI.value])):
print("manual move setting up next move")
self.master.after(MS_BETWEEN_MOVES, self.ai_move)
return map_click
def __init__(self, master):
self.tiles = []
self.textids = []
self.master = master
self.frame = Frame(master)
self.canvas = Canvas(self.frame, width=510, height=510)
Grid.rowconfigure(master, 0, weight=1)
Grid.columnconfigure(master, 0, weight=1)
self.frame.grid(row=0, column=0)
# self.player1_config = {
# Settings.AI.value : True, #should this be Ai or person
# Settings.START_TYPE.value : StartType.RANDOM.value, #what kind of start state
# Settings.START_PARAMS.value : [], #any parameters for the stater
# Settings.SEARCH_TYPE.value : SearchType.RANDOM.value, #what kind of search is happening
# Settings.SEARCH_PARAMS.value : [], #any parameters for the search
# Settings.AI_TYPE.value : AIType.NONE.value, # what is the AI
# Settings.AI_PARAMS.value : [] #any params for the ai
# }
self.player1_config = {
'ai parameters': [
-1, 1, 0, 0, 0, 0, -1, 1, -1, 0, 1, -1, -1, 1, 0, -1, 0, 0, 1,
1, 0
],
'eval_type':
'modified_reachable',
'search_parmeters': [],
'FILENAME':
'train/good_modified_reachable.txt',
'params_for_start_state': [],
'type_of_start_state':
'champion',
'is an ai':
True,
'type_of_search':
'no searcher'
}
self.player2_config = {
Settings.AI.value: True, #should this be Ai or person
Settings.START_TYPE.value:
StartType.RANDOM.value, #what kind of start state
Settings.START_PARAMS.value: [], #any parameters for the stater
Settings.SEARCH_TYPE.value:
SearchType.RANDOM.value, #what kind of search is happening
Settings.SEARCH_PARAMS.value: [], #any parameters for the search
Settings.AI_TYPE.value: AIType.NONE.value, # what is the AI
Settings.AI_PARAMS.value: [] #any params for the ai
}
self.tile_colors = [[
"#DBE0FF", "#C7CCF7", "#B3B9EF", "#9FA6E8", "#8C92E0", "#787FD9",
"#646CD1", "#5059CA", "#3D45C2", "#2932BB", "#151FB3", "#020CAC"
],
[
"#FFDBE0", "#F7C7CD", "#EFB3BB", "#E89FA8",
"#E08C96", "#D97884", "#D16471", "#CA505F",
"#C23D4D", "#BB293A", "#B31528", "#AC0216"
]]
self.hidden_color = ["#787FD9", "#D97884"]
self.e = Engine(1000, self.player1_config, self.player2_config, False)
self.e.setup_board()
if not self.player1_config[Settings.AI.value]:
board = self.e.get_board(1, True)
else:
board = self.e.get_board(None, True)
self.win = False #winner trigger
self.player1_turn = True #player 1 turn trigger
self.winning_player = 0
self.button_counter = 0
self.clicked_buttons = []
# board setup
#print(board)
for i in range(10):
for j in range(10):
tag = i * 10 + j
if board[i][j] == 111:
text_item = ""
tile_color = "white"
tile_outline = "white"
elif board[i][j] == 0:
text_item = ""
tile_outline = "black"
tile_color = "grey"
elif board[i][j] % 1000 == piece_diplay_map[
pieces.HIDDEN.value]:
text_item = ""
tile_outline = "black"
tile_color = self.hidden_color[board[i][j] / 1000 - 2]
else:
text_item = str(board[i][j] % 100)
tile_outline = "black"
#print(board[i][j])
#print(board[i][j]/100 - 2)
#print(board[i][j]%100 - 1)
tile_color = self.tile_colors[board[i][j] / 100 -
2][board[i][j] % 100 - 1]
tile = self.canvas.create_rectangle(j * 50 + 10,
i * 50 + 10,
j * 50 + 50,
i * 50 + 50,
outline=tile_outline,
fill=tile_color,
activefill="cyan",
tags=tag)
textid = self.canvas.create_text(j * 50 + 30,
i * 50 + 30,
text=text_item,
tags=str(tag) + "text")
rect_handler = self.ind_map_click(9 - i, j)
self.tiles.append(tile)
self.textids.append(textid)
self.canvas.tag_bind(tile, "<Button-1>", rect_handler)
self.canvas.grid(row=0, column=0)
def ai_move(self):
print("ai_move called")
if self.player1_turn and not self.player1_config[Settings.AI.value]:
return None
if not self.player1_turn and not self.player2_config[
Settings.AI.value]:
return None
self.player1_turn = self.e.make_move()
self.update()
winner = self.e.get_winner()
if winner:
#what do we want to happen on win
pass
else:
if ((self.player1_turn and self.player1_config[Settings.AI.value])
or (not self.player1_turn
and self.player2_config[Settings.AI.value])):
print("ai move setting up next move")
self.master.after(MS_BETWEEN_MOVES, self.ai_move)
def update(self):
#two ais playing
if (self.player2_config[Settings.AI.value]
and self.player1_config[Settings.AI.value]):
board = self.e.get_board(None, True)
#player 1 is manual and 2 is an ai
elif (self.player2_config[Settings.AI.value]
and not self.player1_config[Settings.AI.value]):
board = self.e.get_board(1, True)
#player 1 is an ai and 2 is manual
elif (not self.player2_config[Settings.AI.value]
and self.player1_config[Settings.AI.value]):
board = self.e.get_board(2, True)
else: #both are manual players
if self.player1_turn:
board = self.e.get_board(1, True)
else:
board = self.e.get_board(2, True)
for i in range(10):
for j in range(10):
if board[i][j] == 111:
text_item = ""
tile_color = "white"
elif board[i][j] == 0:
text_item = ""
tile_color = "grey"
elif board[i][j] % 1000 == piece_diplay_map[
pieces.HIDDEN.value]:
text_item = ""
tile_color = self.hidden_color[board[i][j] / 1000 - 2]
else:
text_item = str(board[i][j] % 100)
tile_color = self.tile_colors[board[i][j] / 100 -
2][board[i][j] % 100 - 1]
self.canvas.itemconfig(self.tiles[i * 10 + j], fill=tile_color)
self.canvas.itemconfig(self.textids[i * 10 + j],
text=text_item)
class Tournement:
def __init__(self, config, max_moves):
self.ai_configs = []
for filename in config[AI_FIELD][AIType.REACHABLE.value]:
self.ai_configs += read_file_into_configs(filename,
reachable_config)
for filename in config[AI_FIELD][AIType.MODIFIED_REACHABLE.value]:
self.ai_configs += read_file_into_configs(filename,
mod_reachable_config)
for filename in config[AI_FIELD][AIType.PIECE_BASED_ADD.value]:
self.ai_configs += read_file_into_configs(filename,
piecebased_config_add)
for filename in config[AI_FIELD][AIType.PIECE_BASED_MUL.value]:
self.ai_configs += read_file_into_configs(filename,
piecebased_config_mul)
self.start_configs = []
for filename in config[START_FIELD]:
self.start_configs += read_file_into_configs(
filename, flexible_start_config)
self.engine = Engine(max_moves, None, None)
self.max_moves = max_moves
def play_against(self, config1, config2, n_games=5):
player1_wins = 0
player2_wins = 0
for i in range(n_games):
self.engine.restart(self.max_moves, config1, config2)
winner = self.engine.run()
if winner == 1:
player1_wins += 1
elif winner == 2:
player2_wins += 1
if player1_wins > player2_wins:
return 1
elif player1_wins < player2_wins:
return 2
else:
return 0
def playoff_helper(self, param_lst, num):
this_round = param_lst
next_round = []
i = 1
while len(this_round) > num:
print("round {}, {} configurations left".format(
i, len(this_round)))
i += 1
random.shuffle(this_round)
for i in range(int(len(this_round) / 2)):
config1 = param_lst[i]
config2 = param_lst[i + 1]
# do a playoff and the winner goes to the next round
winner = self.play_against(config1, config2)
if winner == 1:
next_round.append(config1)
elif winner == 2:
next_round.append(config2)
else:
#in the event of a tie, play again with twice the number of
#moves to try to determine the winner
self.engine.restart(2 * self.max_moves, config1, config2)
winner = self.engine.run()
if winner == 1:
next_round.append(config1)
elif winner == 2:
next_round.append(config2)
else:
#double tie indicates the configs are about the same
#so its safe to just randomly pick one to move on to
#the next round
if random.random() < 0.5:
next_round.append(config1)
else:
next_round.append(config2)
if (len(this_round) % 2 != 0):
next_round.append(this_round[-1])
this_round = next_round
next_round = []
return this_round
def playoff(self, num=1):
print('finding the best ai configurations')
best_ai = self.playoff_helper(self.ai_configs, num)
print('finding the best start state')
best_start = self.playoff_helper(self.start_configs, num)
return best_ai, best_start
import game.chapter_two.main
import game.chapter_one.main
from game.engine import Engine, SceneMap
print("Starting the engine...")
a_map = SceneMap()
a_game = Engine(a_map)
a_game.play()
#!/usr/bin/env python2
# from network import Channel
# import socket
# import time
# from ctypes import cdll
import platform
# import sys
# import os
# sys.path.append(os.path.abspath())
from game.engine import Engine
engine = Engine()
engine.start()
def init_steam():
# arch, _ = platform.architecture()
# if arch == '64bit':
# i9c = cdll.LoadLibrary('./i9c_64.so')
# else:
# i9c = cdll.LoadLibrary('./i9c_32.so')
#
# i9c.api_init()
# i9c.api_request_ticket()
# #time.sleep(3)
# #i9c.api_get_ticket()
libsteam_api = cdll.LoadLibrary('old/libsteam_api.so')
libsteam_api.SteamAPI_Init()
# steam_
# steam_user = libsteam_api.SteamUser()
def main(self):
Engine(filename=self.params.file).play()
#!/usr/bin/env python2
# from network import Channel
# import socket
# import time
# from ctypes import cdll
import platform
# import sys
# import os
# sys.path.append(os.path.abspath())
from game.engine import Engine
engine = Engine()
engine.start()
def init_steam():
# arch, _ = platform.architecture()
# if arch == '64bit':
# i9c = cdll.LoadLibrary('./i9c_64.so')
# else:
# i9c = cdll.LoadLibrary('./i9c_32.so')
#
# i9c.api_init()
# i9c.api_request_ticket()
# #time.sleep(3)
# #i9c.api_get_ticket()
libsteam_api = cdll.LoadLibrary('old/libsteam_api.so')
libsteam_api.SteamAPI_Init()
class LSStartStateTrainer:
def __init__(self, start=None, n_games=10, start_temp=1024, factor=2):
self.start = start
if start == None:
self.start = get_random_start()
self.delta = 0.00001
self.n_games = n_games
#make both of them random, but the simpel start state
self.player_config = {
Settings.AI.value: True, #should this be Ai or person
Settings.START_TYPE.value:
StartType.SIMPLE.value, #what kind of start state
Settings.START_PARAMS.value: [], #any parameters for the stater
Settings.SEARCH_TYPE.value:
SearchType.RANDOM.value, #what kind of search is happening
Settings.SEARCH_PARAMS.value: [], #any parameters for the search
Settings.AI_TYPE.value: AIType.NONE.value, # what is the AI
Settings.AI_PARAMS.value: [] #any params for the ai
}
self.opponent_config = {
Settings.AI.value: True, #should this be Ai or person
Settings.START_TYPE.value:
StartType.CHAMPION.value, #what kind of start state
Settings.START_PARAMS.value: [], #any parameters for the stater
Settings.SEARCH_TYPE.value:
SearchType.RANDOM.value, #what kind of search is happening
Settings.SEARCH_PARAMS.value: [], #any parameters for the search
Settings.AI_TYPE.value: AIType.NONE.value, # what is the AI
Settings.AI_PARAMS.value: [] #any params for the ai
}
self.engine = Engine(1000)
self.best, stats = self.simulated_annealing(start_temp, factor)
print(self.best)
f = open("train/simulated_annealing_results.txt", "a")
t = open("train/simulated_annealing_factors.txt", "a")
s = open("train/simuated_annealing_start_state.txt", "a")
g = open("train/simulated_annealing_stats.txt", "a")
f.write("{}\n".format(self.best))
t.write("{}\n".format([start_temp, factor]))
s.write("{}\n".format(self.start))
g.write("{}\n".format(stats))
g.close()
s.close()
t.close()
f.close()
def evaluate(self, last_start, next_start):
wins = 0
self.player_config[Settings.START_PARAMS.value] = next_start
self.opponent_config[Settings.START_PARAMS.value] = last_start
for i in range(self.n_games):
self.engine.restart(1000, self.player_config, self.opponent_config)
res = self.engine.run()
if res == 0:
wins += 0.5
else:
wins += (res == 1)
print(float(self.n_games - wins) / self.n_games)
return float(self.n_games - wins) / self.n_games
def get_random_next(self, last_start):
i = int(random.random() * len(last_start))
j = i
while j == i:
j = random.random() * len(last_start)
next_start = copy.copy(last_start)
temp = next_start[i]
next_start[i] = next_start[j]
next_start[j] = temp
return next_start
def get_similar_random_next(self, last_start):
#want to swap two neighboring pieces
s1 = int(random.random() * len(last_start))
i1, j1 = s1 / 10, s1 % 10
s2 = s1
valid = False
while (not valid):
n = int(random.random() * 8)
count = 0
for i2 in range(i1 - 1, i1 + 2):
if valid: break
for j2 in range(j1 - 1, j1 + 2):
if valid: break
if (i1 == i2 and j1 == j2): continue
s2 = 10 * i2 + j2
if (count == n):
if (not s2 < 0) and (not s2 >= len(last_start)):
#print(s2)
valid = True
count += 1
next_start = copy.copy(last_start)
#print("s1 : {}".format(s1))
#print("s2 : {}".format(s2))
temp = next_start[s1]
next_start[s1] = next_start[s2]
next_start[s2] = temp
return next_start
def simulated_annealing(self, start_temp, factor):
cur = self.start
temp = start_temp
stats = []
while True:
if temp <= self.delta: return cur, stats
next_start = self.get_similar_random_next(cur)
e = self.evaluate(cur, next_start)
stats.append(e)
if (e > 0.5):
cur = next_start
else:
should_use_anyways = random.random()
p = np.exp((e - 0.5) / temp)
if (should_use_anyways < p):
cur = next_start
temp = temp / factor
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.engine = Engine(consumer=self)
class GBRTTrainer(): #trains using Bayesian global optimization with GBRT against random play
def __init__(self,max_moves,ai_config,opponent_config,param_ranges,n_iter,n_games,init_params,n_batches = 1):
self.ai_config = ai_config
self.opponent_config = opponent_config
self.param_ranges = param_ranges
self.n_iter = n_iter
self.n_games = n_games
self.max_moves = max_moves
self.engine = Engine(self.max_moves,self.ai_config, self.opponent_config)
self.params = init_params
self.n_batches = n_batches
self.score_history = []
self.the_good_ones = []
def objective(self,params):
self.ai_config[Settings.AI_PARAMS.value] = params
wins = 0
for i in range(self.n_games):
self.engine.restart(self.max_moves,self.ai_config,self.opponent_config)
winner = self.engine.run()
if winner == 1:
wins += 1.0
elif winner == 0:
wins += 0.5
print wins / self.n_games
self.score_history.append(wins / self.n_games)
if(wins / self.n_games) >= .99:
#print(params)
self.the_good_ones.append(params)
#return 1 - (wins / self.n_games)
return - self.engine.get_value(1, 100, -1, 500)
#res = 0
#for i in range(self.n_games):
# self.engine.restart(self.max_moves,self.ai_config,self.opponent_config)
# self.engine.run()
# val = self.engine.get_value(1,100,-1,500)
# res += val
#print res
#self.score_history.append(res)
#return -res
def train(self):
opt = Optimizer(self.param_ranges,"GP")
r = opt.run(self.objective,n_iter=self.n_iter)
self.params = r.x
#print("trained paramaters are: ")
#print(r.x)
def objective_batchwise(self,params):
full_params = self.params[:self.training_param_range[0]] + params + self.params[self.training_param_range[1]:]
self.ai_config[Settings.AI_PARAMS.value] = full_params
wins = 0
for i in range(self.n_games):
self.engine.restart(self.max_moves,self.ai_config,self.opponent_config)
self.engine.run()
val = self.engine.get_value(1,100,-1,500)
res += val
print res
return -res
def train_batchwise(self):
opt = Optimizer(self.param_ranges,"GP")
for batch in range(self.n_batches):
print("starting a batch")
for start in range(10):
print("starting a round of optimization")
self.training_param_range = [start*10, start*10 + 10]
opt = Optimizer(self.param_ranges[start*10:start*10 + 10],"GP")
r = opt.run(self.objective,n_iter=self.n_iter)
self.params[start*10:start*10 + 10] = r.x
def evaluate(self):
wins = 0.0
for i in range(self.n_games):
self.engine.restart(self.max_moves,self.ai_config,self.opponent_config)
winner = self.engine.run()
if winner == 1:
wins += 1.0
elif winner == 0:
wins += 0.5
print winner
return wins / (self.n_games)
def test_contructor():
#simple test to make sure that the constructor runs
engine = Engine()
player = Player(True, engine)
def main(self):
Engine(no_player=self.params.no_player).play()
# Run game options
elif action in ['run', 'r']:
# Additional args
quiet = False
if par_args.debug is not None:
if par_args.debug >= 0:
game.config.Debug.level = par_args.debug
else:
print('Valid debug input not found, using default value')
if par_args.q_bool:
quiet = True
engine = Engine(quiet)
engine.loop()
# Boot up the scrimmage server client
elif action in ['scrimmage', 's']:
cl = Client()
elif action in ['visualizer', 'v']:
# Check operating system and run corresponding visualizer
if plat == "win32":
print("You're running Windows")
subprocess.call(["./visualizer.exe"])
elif plat == "linux":
print("You're a linux man I see.")
subprocess.call(["./visualizer.x86_64"])
elif plat == "darwin":
def __init__(self, master):
self.tiles = []
self.textids = []
self.master = master
self.frame = Frame(master)
self.canvas = Canvas(self.frame, width=510, height=510)
Grid.rowconfigure(master, 0, weight=1)
Grid.columnconfigure(master, 0, weight=1)
self.frame.grid(row=0, column=0)
# self.player1_config = {
# Settings.AI.value : True, #should this be Ai or person
# Settings.START_TYPE.value : StartType.RANDOM.value, #what kind of start state
# Settings.START_PARAMS.value : [], #any parameters for the stater
# Settings.SEARCH_TYPE.value : SearchType.RANDOM.value, #what kind of search is happening
# Settings.SEARCH_PARAMS.value : [], #any parameters for the search
# Settings.AI_TYPE.value : AIType.NONE.value, # what is the AI
# Settings.AI_PARAMS.value : [] #any params for the ai
# }
self.player1_config = {
'ai parameters': [
-1, 1, 0, 0, 0, 0, -1, 1, -1, 0, 1, -1, -1, 1, 0, -1, 0, 0, 1,
1, 0
],
'eval_type':
'modified_reachable',
'search_parmeters': [],
'FILENAME':
'train/good_modified_reachable.txt',
'params_for_start_state': [],
'type_of_start_state':
'champion',
'is an ai':
True,
'type_of_search':
'no searcher'
}
self.player2_config = {
Settings.AI.value: True, #should this be Ai or person
Settings.START_TYPE.value:
StartType.RANDOM.value, #what kind of start state
Settings.START_PARAMS.value: [], #any parameters for the stater
Settings.SEARCH_TYPE.value:
SearchType.RANDOM.value, #what kind of search is happening
Settings.SEARCH_PARAMS.value: [], #any parameters for the search
Settings.AI_TYPE.value: AIType.NONE.value, # what is the AI
Settings.AI_PARAMS.value: [] #any params for the ai
}
self.tile_colors = [[
"#DBE0FF", "#C7CCF7", "#B3B9EF", "#9FA6E8", "#8C92E0", "#787FD9",
"#646CD1", "#5059CA", "#3D45C2", "#2932BB", "#151FB3", "#020CAC"
],
[
"#FFDBE0", "#F7C7CD", "#EFB3BB", "#E89FA8",
"#E08C96", "#D97884", "#D16471", "#CA505F",
"#C23D4D", "#BB293A", "#B31528", "#AC0216"
]]
self.hidden_color = ["#787FD9", "#D97884"]
self.e = Engine(1000, self.player1_config, self.player2_config, False)
self.e.setup_board()
if not self.player1_config[Settings.AI.value]:
board = self.e.get_board(1, True)
else:
board = self.e.get_board(None, True)
self.win = False #winner trigger
self.player1_turn = True #player 1 turn trigger
self.winning_player = 0
self.button_counter = 0
self.clicked_buttons = []
# board setup
#print(board)
for i in range(10):
for j in range(10):
tag = i * 10 + j
if board[i][j] == 111:
text_item = ""
tile_color = "white"
tile_outline = "white"
elif board[i][j] == 0:
text_item = ""
tile_outline = "black"
tile_color = "grey"
elif board[i][j] % 1000 == piece_diplay_map[
pieces.HIDDEN.value]:
text_item = ""
tile_outline = "black"
tile_color = self.hidden_color[board[i][j] / 1000 - 2]
else:
text_item = str(board[i][j] % 100)
tile_outline = "black"
#print(board[i][j])
#print(board[i][j]/100 - 2)
#print(board[i][j]%100 - 1)
tile_color = self.tile_colors[board[i][j] / 100 -
2][board[i][j] % 100 - 1]
tile = self.canvas.create_rectangle(j * 50 + 10,
i * 50 + 10,
j * 50 + 50,
i * 50 + 50,
outline=tile_outline,
fill=tile_color,
activefill="cyan",
tags=tag)
textid = self.canvas.create_text(j * 50 + 30,
i * 50 + 30,
text=text_item,
tags=str(tag) + "text")
rect_handler = self.ind_map_click(9 - i, j)
self.tiles.append(tile)
self.textids.append(textid)
self.canvas.tag_bind(tile, "<Button-1>", rect_handler)
self.canvas.grid(row=0, column=0)
class GameWindow(QMainWindow):
def __init__(self, menu, players):
super().__init__()
self.menu = menu
self.setWindowTitle('Code with Fire')
self.setGeometry(200, 50, 800, 650)
self.player_names = players
self.alive_players = len(players)
self.game_engine = Engine()
self.game_screen = Screen(self.game_engine)
self.score_manager = ScoreManager(self.game_screen)
self.setCentralWidget(self.game_screen)
self.create_menu_bar()
self.start_game(players)
def start_game(self, players):
if len(players) == 1:
start_one_player_game(self, self.game_engine, self.game_screen,
self.score_manager)
elif len(players) == 2:
start_two_player_game(self, self.game_engine, self.game_screen,
self.score_manager)
self.game_engine.start()
def create_menu_bar(self):
pause_button = QAction(QIcon(None), '&Pausar Juego', self)
pause_button.setShortcut('Ctrl+P')
pause_button.triggered.connect(self.game_engine.toggle_pause)
quit_button = QAction(QIcon(None), '&Cerrar Juego', self)
quit_button.setShortcut('Ctrl+E')
quit_button.triggered.connect(self.quit_game)
actions = self.menuBar().addMenu('&Menú')
actions.addAction(pause_button)
actions.addAction(quit_button)
# I pass the key events to the game screen widget.
def keyPressEvent(self, event):
self.game_screen.keyPressEvent(event)
def keyReleaseEvent(self, event):
self.game_screen.keyReleaseEvent(event)
def player_death(self, player_death_event):
player_score = (self.player_names[player_death_event.player],
player_death_event.score)
HighScores.add_and_save_highscore(list(HighScores.get_highscores()),
player_score)
self.alive_players -= 1
if self.alive_players <= 0:
self.end_game()
def quit_game(self):
player_score = (self.player_names[0], self.score_manager.score)
HighScores.add_and_save_highscore(list(HighScores.get_highscores()),
player_score)
self.end_game()
def end_game(self):
self.game_engine.stop = True
self.hide()
QWidget().setLayout(
self.menu.layout()
) # Simple hack to empty the current layout - https://stackoverflow.com/a/10439207
self.menu.initialize()
self.menu.show()
self.menu.open_highscores()
def main():
#####Initializations
pygame.init()
pygame.font.init()
pygame.mixer.init()
font = pygame.font.Font(None,25)
###Fonts
cmcsams = pygame.font.SysFont('comicsansms', 50, True, True)
superFont = pygame.font.SysFont('comicsansms',100,True,True)
FPS = 30
FPS_CLOCK = pygame.time.Clock()
SCREEN = pygame.display.set_mode(game.constants.WINDOW_SIZE)
SCREEN.set_colorkey(game.constants.WHITE)
##UI setup
playerAmmo = ammo()
hpBar = healthBar()
mobList =[]
engine = Engine(mobList)
pygame.mouse.set_visible(False)
timer = 0
seconds = 0
minutes=0
frame_count=0
########Game Loop##################
while True:
for event in pygame.event.get():
if event.type==QUIT:
pygame.quit()
sys.exit()
#player shoots
if event.type==pygame.MOUSEBUTTONUP and event.button==LEFTBUTTON:
#Play the shot sound
shootSound=pygame.mixer.Sound("../media/shoot.wav")
shootSound.play()
mob = engine.shoot(pygame.mouse.get_pos())
#go through and check collisions
if mob is None:
playerAmmo.shoot()
else:
if mob.name=='reload':
playerAmmo.reload()
else:
if playerAmmo.bullets>0:
playerAmmo.shoot()
mob.isDead=True
mob.die()
if pygame.mouse.get_focused():
pos = pygame.mouse.get_pos()
if event.type==pygame.KEYUP:
if event.key==pygame.K_DOWN:
hpBar.update()
###reload bird got triggered
if event.key==pygame.K_r:
mobList.append(reloadBird())
if event.key==pygame.K_a:
mobList.append(bossBird(0,0,2,0))
engine.turn(hpBar)
draw(SCREEN)
#Draw the Mobs
for mob in mobList:
mob.draw(SCREEN)
playerAmmo.draw(SCREEN)
hpBar.draw(SCREEN)
frame_count+=1
total_seconds=frame_count//FPS
minutes=total_seconds//FPS
seconds=total_seconds%FPS
output_string=" {0:02}:{1:02}".format(minutes, seconds)
text = font.render(output_string,True,game.constants.SALMON)
SCREEN.blit(text,(game.constants.WIDTH-60,game.constants.HEIGHT-25))
text = cmcsams.render(str(engine.score),True,game.constants.CORAL)
SCREEN.blit(text,(game.constants.WIDTH/2,game.constants.HEIGHT-80))
if hpBar.width<1:
drawEnd(SCREEN,engine.score,output_string,superFont)
pygame.quit()
sys.exit()
pygame.display.flip()
FPS_CLOCK.tick(FPS)
