def test_whole():
sys.stdin = open("test_input_files/2p_input.txt")
player, board_size, reverse_status = game_setup()
assert play_game(board_size, player) == 1
sys.stdin = open("test_input_files/2p_input.txt")
run_game()
def run_game2():
global ch, dobollet, bulets
forrand = 1000
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption('Alien Invasion')
planets = Group()
t = [0, 1, 1, 1]
mars = Planet(ai_settings, screen, 0, 0, t)
planets.add(mars)
while True:
for event in pygame.event.get():
#for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
for planet in planets.sprites():
if planet.rect.collidepoint(mouse_x, mouse_y):
print(planet.libe)
game.run_game(planet.libe)
screen.fill(ai_settings.bg_color)
planets.draw(screen)
pygame.display.flip()
def test_exit_game(self, patch_pause, patch_keys):
"""Проверяем, работает ли пауза."""
patch_keys.return_value = {pygame.K_ESCAPE : True, pygame.K_RETURN : False}
patch_pause.return_value = 'paused'
try:
game.run_game()
except KeyError as e:
pass
self.assertTrue(patch_pause.called)
def play_map(map):
if data.playerData.isLocked(map):
return
global gui
if not gui == None:
gui.stop()
console.clear()
from game import run_game
run_game(map)
def main():
interface = InteractiveInterface()#Keyboard(), ExternalWindow())
p1 = Player(Color.WHITE, interface)
p2 = Player(Color.BLACK, interface)
game = HiveGame([p1, p2])
run_game(game)
return
def recur_calc(parameters_list,
pos,
parameters,
current_val,
nrun,
logfile,
player,
top_score=[]):
top_plays = top_score
min_value = parameters[parameters_list[pos]][0]
max_value = parameters[parameters_list[pos]][1]
for i in range(min_value, max_value):
current_val[parameters_list[pos]] = i
if len(parameters_list) - 1 != pos:
top_plays = recur_calc(parameters_list, pos + 1, parameters,
current_val, nrun, logfile, player,
top_plays)
else:
n = nrun
wins = 0
loses = 0
while n != 0:
world = World([Company(Director(player, current_val))],
hideoutput=True)
run_game(world)
if world.winner_is_here:
wins += 1
else:
loses += 1
n -= 1
strings.send_text(strings.AI_WIN_RESULT %
(wins, nrun, str(current_val), ''))
logfile.write(strings.AI_WIN_RESULT %
(wins, nrun, str(current_val), '\n'))
if top_plays:
if wins < top_plays[0]:
pass
else:
if len(top_plays) < 10:
top_plays.append(wins)
else:
top_plays[0] = wins
else:
top_plays.append(wins)
top_plays.sort()
return top_plays
def old_user():
countnum = 0
while countnum <= 2:
user = input("\033[1;37m%s\033[0m" % "username:"******"\033[1;37m%s\033[0m" % "password:"******"\033[0;31m%s\033[0m" %
"\nLogin incorrent,there are %s/3 chances left.\n" %
(3 - countnum))
else:
print("\033[0;31m%s\033[0m" % "\n%s Login successful!\n" % user)
os.system("say 'welcome to login,%s'" % user)
run_game()
break
def train_net_vs_simple(net_player):
net_player.color = PlayerColor.BLUE
players = {
PlayerColor.BLUE: net_player,
PlayerColor.RED: SimplePlayer(PlayerColor.RED)
}
global_map, players, fights, winning_player = game.init_game(
map_filename, players)
winner, global_map = game.run_game(False, global_map, players, fights,
winning_player)
owned_nodes = 0
owned_buildings = 0
owned_units = 0
for row in global_map:
for loc in row:
if loc and loc.unit_in_loc and loc.unit_in_loc.owner is net_player.color:
owned_units += 1
if isinstance(loc, Node):
if loc.owner is net_player.color:
owned_nodes += 1
if not loc.building.is_empty():
owned_buildings += 1
net_player.g.fitness = owned_units + 10 * owned_nodes + 20 * owned_buildings
if winner is net_player.color:
net_player.g.fitness += 10000
print("Genome: ", net_player.g.key, " Fitness: ", net_player.g.fitness)
def train_net_vs_other(net_player, other_net_player):
net_player.color = PlayerColor.BLUE
other_net_player.color = PlayerColor.RED
players = {PlayerColor.BLUE: net_player, PlayerColor.RED: other_net_player}
global_map, players, fights, winning_player = game.init_game(
map_filename, players)
winner, global_map = game.run_game(False, global_map, players, fights,
winning_player, max_game_time)
for row in global_map:
for loc in row:
if loc and loc.unit_in_loc:
if loc.unit_in_loc.owner is net_player.color:
net_player.g.fitness += 1
elif loc.unit_in_loc.owner is other_net_player.color:
other_net_player.g.fitness += 1
if isinstance(loc, Node):
if not loc.building.is_empty():
if loc.owner is net_player.color:
net_player.g.fitness += 100
elif loc.owner is other_net_player.color:
other_net_player.g.fitness += 100
if players.__contains__(winner):
players[winner].g.fitness += 1000
print("Genome: ", net_player.g.key, " Fitness: ", net_player.g.fitness,
"\tOther Genome: ", other_net_player.g.key, " Fitness: ",
other_net_player.g.fitness)
return winner
def eventLoop(message,left,all_sprites_list,block_list,monsta_list,pacman_collide,wall_list,gate):
while True:
# ALL EVENT PROCESSING SHOULD GO BELOW THIS COMMENT
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
pygame.quit()
if event.key == pygame.K_RETURN:
del all_sprites_list
del block_list
del monsta_list
del pacman_collide
del wall_list
del gate
run_game()
def run_script(heuristic,
type,
amount,
domain_file_name,
problem_file_name,
gen_flag=2):
player_init = player.Player(type, (11, 9), (1, 0), amount)
return game.run_game(heuristic, player_init, domain_file_name,
problem_file_name, gen_flag)
def run_menu(state=None, msg=None):
this_active = True
while this_active:
os.system('clear')
if msg is None:
print('\n Sokoban! Probably the best game in the world.')
else:
print(msg)
selection = get_menu_selection(state)
if selection is 'q':
os.system('clear')
sys.exit()
else:
try:
state = sokoban_load(int(selection))
this_active = False
except (FileNotFoundError, ValueError):
pass
game.run_game(state)
def main():
winning_players = []
players = {PlayerColor.BLUE: blue_player, PlayerColor.RED: red_player}
for map_iter in map_files:
global_map, players, fights, winning_player = game.init_game(
map_iter, players)
for _ in range(run_count):
winner, global_map = game.run_game(show_window, global_map,
players, fights, winning_player)
winning_players.append(winner)
wins[winner] += 1
print(wins)
print(winning_players)
def main(arguments):
parsed_arguments = parse_arguments(arguments)
model = Model()
model.create(7, 7)
model.save(parsed_arguments.model_dir)
for i in range(parsed_arguments.num_iterations):
exploration_factor = 0.75 - 0.5 * i / parsed_arguments.num_iterations
run_game(parsed_arguments.playgame_path, parsed_arguments.map_path,
parsed_arguments.log_dir, parsed_arguments.exe_path,
parsed_arguments.model_dir, parsed_arguments.turns,
parsed_arguments.games, exploration_factor)
games = load_games(parsed_arguments.log_dir, 1, parsed_arguments.games)
print(f'Iteration: {i + 1} of {parsed_arguments.num_iterations}')
print_score(games)
print(f'Exploration factor: {exploration_factor}')
for _ in range(3):
games = load_games(parsed_arguments.log_dir, 1,
parsed_arguments.games)
input, output = convert_experiences(experiences(games), model)
model.train(input, output)
model.save(parsed_arguments.model_dir)
def main():
if len(sys.argv) == 3 and sys.argv[1] == "--debug":
username, server_code = sys.argv[2].split(":")
player = Player(username,
server_code) #, url="http://localhost", port=51337)
else:
player = run_menu(surface, font, clock)
while True:
minigame_name = run_game(player, surface, font, clock)
# run a minigame
module = import_module('minigames.{}'.format(minigame_name))
minigame = getattr(module, 'main')
minigame(player, surface, font, clock)
class GameTests(unittest.TestCase):
@patch('game.stop_game')
def test_game_start(self, test_patch):
"""Проверяем работает ли остановка игры при health = 0"""
test_patch.return_value = 'win_test'
game.health2 = 0
self.assertEqual(game.run_game(), 'win_test')
@patch('pygame.key.get_pressed')
@patch('game.pause_game')
def test_exit_game(self, patch_pause, patch_keys):
"""Проверяем, работает ли пауза."""
patch_keys.return_value = {pygame.K_ESCAPE : True, pygame.K_RETURN : False}
patch_pause.return_value = 'paused'
try:
game.run_game()
except KeyError as e:
pass
self.assertTrue(patch_pause.called)
a.backProp(target_values2)
print rep
print input_values
print a.get_results()
a.to_string()
elif testing == "animal":
anim1 = animal.animal()
anim2 = anim1.reproduce()
anim1.brain_output()
# anim1.mutate()
# anim1.to_string()
# anim2.to_string()
elif testing == "game":
game.run_game()
elif testing == "simulator":
p1 = [0, 0]
p2 = [0, 90]
simulator.angle_between(p1, p2)
print simulator.polar_coordinates(90, 1)
elif testing == "simulation1":
turns = 0
attempts = 10000
best_animals = []
for sim in range(attempts):
animals = [animal.animal() for i in range(1)]
animals[0].health.value = 2.0
simulation_data = game.simulate_game(3000, animals)
company_list = []
for i in range(0, int(player_count)):
strings.send_text(strings.PLAYER_SELECT % (i + 1))
for j in range(0, len(players.players_list)):
strings.send_text('%d) %s' % (j + 1, players.players_list[j]))
selected_player = int(input(strings.INPUT_NUMBER)) - 1
visible_info = input(strings.SHOW_HIS_TURNS)
if visible_info == '1':
visible_info = True
else:
visible_info = False
company_list.append(
Company(Director(players.func_list[selected_player]),
visible_info))
world = World(company_list)
run_game(world)
elif answer == '2':
from calculation import calc
from players.semiai import semiai_command
calc(semiai_command, 100, {
'credit_sum': (70, 90),
'money_for_product_reserve': (0, 10)
})
else:
strings.send_text(strings.BYE)
try:
exit(0)
except SystemExit:
strings.send_text(strings.SYSTEMEXIT_EXCEPTION)
if sys.argv[1].startswith('create'):
nrows = int(get_param('rows'))
ncols = int(get_param('columns'))
filepath = get_param('file-path')
maze = Maze.create_maze(nrows, ncols)
draw_maze(maze, file_path=filepath)
elif sys.argv[1].startswith('solve'):
start = make_tuple(get_param('start'))
end = make_tuple(get_param('end'))
maze = Maze.load_from_file(get_param('file-path'))
path = astar_solver.solve_maze(maze, start, end)
print(path)
#draw_maze(maze, path)
elif sys.argv[1].startswith('play'):
game.run_game(get_param('file-path'))
elif sys.argv[1] == 'help':
print('Key controls')
print('z Highlight current location')
print('x Highlight destination')
print('t Show solution from current location')
print('c Decrease frame rate')
print('v Increase frame rate')
print('f Show frame rate')
print('Arrows or WASD for movement')
def begin(self):
tag = run_game()
qwin = queryWindow(tag)
self.windowList.append(qwin)
self.close()
qwin.show()
def begin(self):
tag = run_game()
the_window = queryWindow(tag)
self.windowList.append(the_window)
self.close()
the_window.show()
except:
return False
def split(self, hand):
if hand.cards[0].rank == 8 or hand.cards[0].rank == 'A':
return True
class Super_Cheater(GameStrategy):
def hit(self, hand):
try:
theoretical_hand = Hand( *hand.cards, self.player.table.deck[-1] )
for x in range(25):
if theoretical_hand.is_bust():
self.player.table.get_card()
theoretical_hand = Hand( *hand.cards, self.player.table.deck[-1] )
if not theoretical_hand.is_bust():
return True
else:
return False
except:
return False
def split(self, hand):
if hand.cards[0].rank == 8 or hand.cards[0].rank == 'A':
return True
if __name__ == '__main__':
game.run_game( Cheater )
#game.run_game( Super_Cheater )
#! /u/qaeng/anaconda3/bin/python3
import game
from cards import *
class inclass_strat(GameStrategy):
def double_down(self, hand):
return False
def split(self, hand):
return False
def hit(self, hand):
## Dealver Visible Card
dc = self.player.table.get_dealer_visible_card()
if dc.hard >= 2 and dc.hard <= 7:
if hand.score() >= 17:
return False
else:
return True
else:
return True
game.run_game(inclass_strat)
def main():
run_game()
from PIL import Image
except ImportError:
logger.warning("You chose a different size but Pillow is "
"not installed. Default size is going to "
"be used instead")
factor = 1
folderPath = join("cache", str(factor))
else: # Generate images
mkdir(folderPath)
from generate_images import generate_images
generate_images(factor)
logger.info("Cached images for a factor of %d" % factor)
# Copying from default
if factor == 1 and not exists(folderPath):
mkdir(folderPath)
from generate_images import NAMES as names
from shutil import copyfile
sourcePath = join("media", "default", "")
destPath = join(folderPath, "")
for name in names:
copyfile(sourcePath + name + ".gif", destPath + name + ".gif")
menuPath = join("media", "menu.gif")
copyfile(menuPath, destPath + "menu.gif")
logger.info("Cached images from default")
return factor, difficulty
if __name__ == "__main__":
from game import run_game
run_game(*prepare())
#!/usr/bin/python import game game = game.LightGame() game.run_game()
from game import run_game run_game()
a.backProp(target_values2)
print rep
print input_values
print a.get_results()
a.to_string()
elif testing == "animal":
anim1 = animal.animal()
anim2 = anim1.reproduce()
anim1.brain_output()
# anim1.mutate()
# anim1.to_string()
# anim2.to_string()
elif testing == "game":
game.run_game()
elif testing == "simulator":
p1 = [0,0]
p2 = [0,90]
simulator.angle_between(p1,p2)
print simulator.polar_coordinates(90,1)
elif testing == "simulation1":
turns = 0
attempts = 10000
best_animals = []
for sim in range(attempts):
animals = [animal.animal() for i in range(1)]
animals[0].health.value = 2.0
simulation_data = game.simulate_game(3000,animals)
