def main():
print('Playing Monopoly!')
game = Game()
game.run([Player(1), Player(2)])
############################################################## # Name: Bryan Francis # Project : GoStop Python # Class : OPL Spring 2020 # Date : 3/27/2020 ############################################################## from Game import Game game = Game() game.startGame()
def setUp(self):
from Game import Game
self.g = Game(5)
from Game import Game
from Table import Table
if __name__ == '__main__':
table = Table()
game = Game(table)
game.play()
df = pd.DataFrame(columns = ['players'])
for player in players:
df.loc[player.idno] = player
for epoch in range(nepochs):
epoch_start = time.time()
# Assigning players randomly to different games
print('Assigning Players')
players = df.players.values.copy()
gameplayers = [np.random.choice(players, size = 4, replace=False) for i in range(ngames)]
print('Running games')
# Running the games
t0 = time.time()
for i in range(ngames):
game = Game(players = gameplayers[i])
game.run_game()
print(f'Running {ngames} games in {time.time() - t0:.2f}s')
game.plot_card_play(savefig = True, savefig_name = f'../images/epoch_{epoch}_game_{i}_cardplay.pdf')
game.plot_bidding(savefig = True, savefig_name = f'../images/epoch_{epoch}_game_{i}_bidding.pdf')
print('Generating new Players')
# Adding scores to dataframe
df['score'] = 0
for player in players:
df.loc[player.idno,'score'] = player.score
df = df.sort_values('score', ascending=False)
# Selecting only players with positive scores
def Evaluation(player1, player2):
victories1 = 0
victories2 = 0
for _ in range(100):
# print("Game number", _ + 1)
game = Game()
who_won = None
number_of_moves = 0
current_player = game.player_turn
is_over = False
while not is_over:
# moves = game.available_moves()
game.deck = game.create_new_deck()
if current_player == 1:
# Get the card from either the top deck or the discard pile.
# Choose whether to take card from discard or rack'o deck.
game.deck = game.create_new_deck()
# print("player1_rack_before", game.player1_rack)
top_card = discard_or_deck(game)
player1_rack_copy = deepcopy(game.player1_rack)
# print("player1_rack", game.player1_rack)
game.player1_rack = player1.get_action(game, top_card,
game.player1_rack)
# print("Rack copy player 1", player1_rack_copy)
# print("game rack player 1", game.player1_rack)
if player1_rack_copy != game.player1_rack:
swapped_card = get_swapped_card(player1_rack_copy,
game.player1_rack)
game.append_to_discard(swapped_card)
else:
game.append_to_discard(top_card)
current_player = 2 # Change the current player.
game.player_turn = 2
else:
game.deck = game.create_new_deck()
# print("player2_rack_before", game.player2_rack)
top_card = discard_or_deck(game)
player2_rack_copy = deepcopy(game.player2_rack)
# print("player2_rack", game.player2_rack)
game.player2_rack = player2.get_action(game, top_card,
game.player2_rack)
# print("Rack copy player 2", player2_rack_copy)
# print("game rack player 2", game.player2_rack)
if player2_rack_copy != game.player2_rack:
swapped_card = get_swapped_card(player2_rack_copy,
game.player2_rack)
game.append_to_discard(swapped_card)
else:
game.append_to_discard(top_card)
current_player = 1
game.player_turn = 1
# if chosen_play == 'n':
# if current_player == 1:
# current_player = 2
# else:
# current_player = 1
# print('Chose: ', chosen_play)
# # game.print_board()
# game.play(chosen_play)
# game.print_board()
number_of_moves += 1
if game.check_racko(game.player1_rack) is True:
who_won = 1
is_over = True
if game.check_racko(game.player2_rack) is True:
who_won = 2
is_over = True
# It is advisable to increase the number of moves. Initial value was 100.
if number_of_moves >= 1000:
is_over = True
who_won = -1
victories1 = -1
victories2 = -1
fitness1 = -1
fitness2 = -1
# print('No Winner!')
if who_won == 1:
victories1 += 1
if who_won == 2:
victories2 += 1
# print(victories1, victories2)
# print('Player 1: ', victories1 / (victories1 + victories2))
# print('Player 2: ', victories2 / (victories1 + victories2))
if victories1 > victories2:
fitness1 = 1
fitness2 = -1
if victories1 < victories2:
fitness1 = -1
fitness2 = 1
if victories1 == victories2:
fitness1 = -1
fitness2 = -1
fitness = [fitness1, fitness2]
# score1 = 0
# score2 = 0
# try:
# score1 = victories1 / (victories1 + victories2)
# except:
# score1 = -np.inf
# try:
# score2 = victories2 / (victories1 + victories2)
# except:
# score2 = -np.inf
score1 = victories1 / (victories1 + victories2)
score2 = victories2 / (victories1 + victories2)
victories = [victories1, victories2, score1, score2]
print("Fitness values are ", fitness)
return victories
def start(self):
Game(self.player, self.r)
def update(self):
if self.game.gameOverStatus:
self.menu.updateHighScore(self.game.score)
self.keyboard.menu = True
self.game = Game(1200, 800)
self.game.newRound(1)
self.mousePos = self.getMousePos()
if (len(self.game.enemies) == 0):
self.handleGameWin()
for explosion in self.explosions:
explosion.update()
if explosion.isFinished():
self.explosions.remove(explosion)
continue
for enemy in self.game.enemies:
enemy.update(self.game.player)
self.addProjectile(enemy, "shell",
enemy.turret.aim(self.game.player))
for item in self.game.terrain.pickupItems:
item.update()
if self.game.player.pickUpItem(item):
self.game.terrain.pickupItems.remove(item)
for projectile in self.projectiles:
projectile.update()
if not projectile.isWithinRange() or self.hitWall(projectile):
self.addExplosion(projectile)
continue
# colliding with shield
if (projectile.isColliding(
(self.game.player.pos.getP(), self.game.player.shieldSize))
and self.game.player.shieldStatus > 0):
self.addExplosion(projectile)
self.game.player.shield.receiveHit(projectile.pos)
self.game.player.decreaseShield(projectile.getType())
continue
# colliding with the actual player
if (projectile.isColliding((self.game.player.getPosAndRadius()))):
self.addExplosion(projectile)
self.game.player.decreaseHealth(projectile.getType())
if self.game.player.health <= 0:
self.game.playerDeath()
break
continue
for enemy in self.game.enemies:
if projectile.isColliding(enemy.getPosAndRadius()):
self.addExplosion(projectile)
enemy.decreaseHealth(projectile.getType())
if (enemy.health <= 0):
self.addProjlessExplosion(enemy.pos)
self.game.enemies.remove(enemy)
self.game.score += 2
for trail in self.trails:
if (trail.isFinished()):
self.trails.remove(trail)
else:
trail.update()
self.checkRightClick()
self.checkSpacebar()
for line in self.game.terrain.lines:
if (self.game.player.isCollidingWithLine(line)
and not self.currentlyColliding[(self.game.player, line)]):
self.game.player.collide(line)
self.currentlyColliding[(self.game.player, line)] = True
elif (self.game.player.isCollidingWithLineTipA(line)
and not self.currentlyColliding[(self.game.player, line)]):
self.game.player.collideTip(line.pA)
self.currentlyColliding[(self.game.player, line)] = True
elif (self.game.player.isCollidingWithLineTipB(line)
and not self.currentlyColliding[(self.game.player, line)]):
self.game.player.collideTip(line.pB)
self.currentlyColliding[(self.game.player, line)] = True
else:
self.currentlyColliding[(self.game.player, line)] = False
self.game.player.update(self.keyboard.forwards,
self.keyboard.backwards, self.keyboard.left,
self.keyboard.right, self.mousePos.getP())
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.game = Game()
def addGame(self, newWeek, newHomeTeamRank, newAwayTeamRank, newDateTime):
newGame = Game(newWeek, newHomeTeamRank, newAwayTeamRank, newDateTime)
self.allGames.append(newGame)
self.backwards = False
elif (key == simplegui.KEY_MAP['a']):
self.left = False
elif (key == simplegui.KEY_MAP['d']):
self.right = False
elif (key == simplegui.KEY_MAP['space']):
self.startselect = False
self.space = False
self.menu = False
elif (key == simplegui.KEY_MAP['p']):
self.p = not self.p
elif (key == simplegui.KEY_MAP['c']):
self.showControls = not self.showControls
self.controlselect = False
elif (key == simplegui.KEY_MAP['h']):
self.showHighScore = not self.showHighScore
self.highScoreSelect = False
game = Game(1200, 800)
i = Interaction(Keyboard(), game)
simplegui.pygame.mouse.set_visible(False)
# Frame initialisation
frame = simplegui.create_frame('Tanks', WIDTH, HEIGHT)
frame.set_mouseclick_handler(i.mouseClickHandler)
frame.set_draw_handler(i.drawHandler)
frame.set_keyup_handler(i.keyUpHandler)
frame.set_keydown_handler(i.keyDownHandler)
frame.start()
def main():
print()
print('遊戲開始')
game = Game()
game.Run()
def game_funct(kol_game, policy_estimator, higth_weel_g, width_weel_g, width_racet_g, max_point_weel_g, kol_point,
min_len_between_point, list_rolout_score):
list_images = [] # Список массивов Изображений серии игр
list_muvies = [] # Список Действий Агента
list_scores = [] # Список Результатов серии игр
data_set = {} # Дата Сет для нейросети
rollout_score = 0
# Сама Игра
for num_game in range(kol_game):
game_list_images = []
game_list_muvies = []
game_list_scores = []
episode_list_images = []
episode_list_muvies = []
episode_list_scores = []
episode_list_game_count = []
episode_list_str_count = []
num_episode = 0
len_episode = 0
G = Game(higth_weel_g, width_weel_g, width_racet_g, max_point_weel_g, kol_point, min_len_between_point,
list_col_point=[0.5, 0.5])
# Основной Цикл Игры
done = False
while done == False:
# Запоминаем состояние награды на начало эпизода
old_count_game = G.get_score()
image = G.get_weel_state()
# Блок выбора действия для Агента
image_tensor = torch.Tensor(np.expand_dims([image], axis=0)).float()
prediction = policy_estimator.predict(image_tensor) # Предсказываем
if policy_estimator.device_in == 'cpu':
action = np.argmax(prediction.cpu().detach().numpy()) # Получаем решение, что делать 'cpu'
else:
action = torch.max(prediction.detach(), 1)[1].item() # Получаем решение, что делать 'cuda'
done = G.act_pg(action) # выполняем действие
episode_list_images.append(image)
episode_list_muvies.append(action) # Заносим в список действие агента в эпизоде
episode_list_str_count.append(G.get_str_score()) # Заносим в список кол-во пойманных точек в эпизоде
episode_list_game_count.append(G.get_score()) # Заносим в список кол-во счет игры на момент эпизода
episode_list_scores.append(0) # Добавляем нулевое значение в список наград эпизода
len_episode += 1
# Проверяем Изменеие Счета в Игре
if old_count_game != G.get_score():
# Формирование награды на конец эпизода
new_count_game = G.get_score()
# Заполнение списка наград за весь эпизод
mas = np.zeros((len(episode_list_scores)))
mas[:] = new_count_game - old_count_game
mas[:] = discount_correct_rewards(mas[:])
episode_list_scores = mas.tolist() # присваиваем всем значения награды в эпизоде награду эпизода
# Фиксируем списки эпизода в списке игры
game_list_images.extend(episode_list_images)
game_list_muvies.extend(episode_list_muvies)
game_list_scores.extend(episode_list_scores)
# Очищаем списки эпизода
episode_list_images = []
episode_list_muvies = []
episode_list_scores = []
episode_list_str_count = []
episode_list_game_count = []
len_episode = 0
num_episode += 1
# Оценка Серии результатов Игр
rollout_score = rollout_score + G.get_score()
list_images.extend(game_list_images)
list_muvies.extend(game_list_muvies)
list_scores.extend(game_list_scores)
data_set_loc = {'image': np.array(list_images),
'muvie': np.array(list_muvies),
'score': np.array(list_scores)}
data_set_out = copy.deepcopy(data_set_loc)
# print('Результат серии = ', rollout_score)
# print('Кол-во примеров = ', len(list_images))
list_rolout_score.append(rollout_score)
data_set_loc.clear() # Словарь с ДатаСетом
list_images.clear() # Список массивов Изображений серии игр
list_muvies.clear() # Список Действий Агента
list_scores.clear() # Список Результатов серии игр
return data_set_out['image'], data_set_out['muvie'], data_set_out['score']
def main():
my_game = Game()
my_game.start()
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Tak client')
parser.add_argument('ip', metavar='0.0.0.0', type=str, help='Server IP')
parser.add_argument('port', metavar='10000', type=int, help='Server port')
parser.add_argument('exe',
metavar='run.sh',
type=str,
help='Your executable')
parser.add_argument('-n',
dest='n',
metavar='N',
type=int,
default=5,
help='Tak board size')
parser.add_argument('-mode',
dest='mode',
type=str,
default='GUI',
help='How to render')
args = parser.parse_args()
game = Game(args.n, args.mode)
if args.mode != 'GUI':
game_loop(game, args)
else:
from threading import Thread
Th = Thread(target=lambda: game_loop(game, args))
Th.start()
game.init_display()
game.display.mainloop()
from StartFrame import StartFrame
from Game import Game
import logging
logging.getLogger().setLevel(logging.INFO)
logging.info("Starting main script...")
#create game window
window = Tk()
# Set full screen
window.attributes('-fullscreen', True)
window.configure(bg='black', cursor='none')
#set title
window.title("BATTLESHIP: PI EDITION")
# Create game object
game = Game(window)
try:
# Start main loop
window.mainloop()
except KeyboardInterrupt:
game.exitFlag = True
game.nethandler.exitFlag = True
game.gpioHandler.exitFlag = True
game.nethandler.isock.close()
game.nethandler.osock.close()
if game.nethandler.machineType == 'host':
game.nethandler.oconnection.close()
game.nethandler.iconnection.close()
import numpy as np
from Board import GameBoard, BoardStates
from Player import AI
from Game import Game
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.figure import Figure
from matplotlib import colors
from tkinter import *
from GameDisplay import GameDisplay
if __name__ == "__main__":
player_one = AI()
player_two = AI()
game = Game(player_one, player_two)
root = Tk()
game_display = GameDisplay(game, root)
root.mainloop()
# chargement du fond de fenètre
# redimensionnement du fond de la fenètre
background = pygame.image.load("Image/space_bg.gif")
background = pygame.transform.scale(background, (1080, 720))
# chargement du premier monstre
image = pygame.image.load("Image/monstre1.png")
# chargement de la bande blanche
# redimensionnement de la bande blanche
grande_bande_haut = pygame.image.load("Image/bande blanche.png")
grande_bande_haut = pygame.transform.scale(grande_bande_haut, (1080, 10))
# chargement du jeu
game = Game(image)
# initialisation du score
score = 0
# initialisation de la variable boucle du jeu
running = True
# boucle du jeu
while running:
# print(game.pressed, game.player.all_projectile)
# gamediplay.fill((0, 0, 0, 0))
# afficher le fond de la fenètre
gamediplay.blit(background, (0, 0))
# initialisation du nombre maximum de projectile
rewardFunction = lambda x: math.sqrt(x) if x >= 0 else 0
LearningPlayer.init("NNs/trained_DuelNetwork",
DuelNetwork,
savePath="NNs/learned_DuelNetwork",
initialPoints=points,
decisionFunction=boltzmannInstance(.1),
rewardFunction=rewardFunction)
players = []
# players.append(DataPlayer(UserPlayer(), name="player1"))
# players.append(DataPlayer(SocketPlayer(50000), name="player2"))
# players.append(UserPlayer())
# players.append(NNPlayer("NNs/learned_NN_MSE"))
path = "NNs/learned_DuelNetwork"
players.append(VisualPlayer(NNPlayer(path, DuelNetwork)))
numOpponents = 2
for _ in range(numOpponents):
players.append(NNPlayer(path, DuelNetwork))
# initLearningPlayer()
# numPlayers = 16
# for _ in range(numPlayers):
# players.append(LearningPlayer())
print("starting game")
game = Game(100, players, timerDelay=0)
game.run()
def handle_gamestart(self, gameName, season=None):
if self.menu: self.menu.hide()
if self.loadmenu: self.loadmenu.hide()
if self.game: self.game.deleteLater()
self.game = Game(self, gameName, season)
from Game import Game new_game = Game() new_game.start()
def initialize_game():
level_id = world.level_ids[min(level_i, len(world.level_ids))]
world_id = worlds[min(world_i, len(worlds))]
return Game(world.levels[level_i], f"{world_id}-{level_id}", True,
world.solutions[level_i])
def update_map(self, state):
self.game = Game(state)
from Board import Board
from Game import Game
if __name__ == '__main__':
_game: Game = Game()
_game.start()
def __init__(self, sound, generate_window, card1=None, card2=None):
self.sound = sound
self.game = Game(self.sound)
self.game.player1 = Player(None, [0, 2], [0, 0], [0, 4], [0, 1],
[0, 3])
self.game.player2 = Player(None, [4, 2], [4, 0], [4, 4], [4, 1],
[4, 3])
self.sound = sound
self.score = 0
self.generate_window = generate_window
self.game.player1.goal = card1
self.game.player2.goal = card2
#self.game.player1.goal = generate_pos()
#self.game.player2.goal = generate_pos()
print("player1.goal = " + str(self.game.player1.goal))
print("player2.goal = " + str(self.game.player2.goal))
print(self.game.to_GUI())
com_num = self.game.same_cards()
# ("Number of common cards", "You have " + str(com_num) + " cards in common")
if [2, 2] in self.game.player1.goal:
color = 'dodger blue'
else:
color = 'white'
entry = Label(self.generate_window,
width="20",
height="9",
text="You have " + str(com_num) +
"\n positions in common",
bg=color)
entry.grid(row=2, column=2)
self.generate_window.update()
self.sound.com(com_num)
time.sleep(2)
self.generate_window.geometry("+0+100")
super(WindowGameAI, self).__init__()
self.geometry("+800+100")
labels = []
for r in range(5):
row = []
for i in range(5):
if (r + i) % 2 == 0:
color = 'white'
else:
color = 'black'
entry = Label(self, width="20", height="9", bg=color)
entry.grid(row=r, column=i)
row.append(entry)
labels.append(row)
self.possible_clicks = []
self.img_player1_captain = ImageTk.PhotoImage(
image=Image.open('images and sounds\\image1.png'),
master=self) # PIL solution
self.img_player1_pilote1 = ImageTk.PhotoImage(
image=Image.open('images and sounds\\image2.png'),
master=self) # PIL solution
self.img_player1_pyramid1 = ImageTk.PhotoImage(
image=Image.open('images and sounds\\image0.png'),
master=self) # PIL solution
self.img_player2_pyramid1 = ImageTk.PhotoImage(
image=Image.open('images and sounds\\image3.png'),
master=self) # PIL solution
self.img_player2_pilot1 = ImageTk.PhotoImage(
image=Image.open('images and sounds\\image4.png'),
master=self) # PIL solution
self.img_player2_captain = ImageTk.PhotoImage(
image=Image.open('images and sounds\\image5.png'),
master=self) # PIL solution
self.player1_captain = Button(self,
width="144",
height="139",
bg="dodger blue",
text="player1_capitain",
command=self.clicking_player1_captain,
image=self.img_player1_captain)
self.player1_captain.image = self.img_player1_captain
self.player1_pyramid1 = Button(self,
width="144",
height="139",
bg="dodger blue",
text="player1_pyramid1",
command=self.clicking_player1_pyramid1,
image=self.img_player1_pyramid1)
self.player1_pyramid1.image = self.img_player1_pyramid1
self.player1_pyramid2 = Button(self,
width="144",
height="139",
bg="dodger blue",
text="player1_pyramid2",
command=self.clicking_player1_pyramid2,
image=self.img_player1_pyramid1)
self.player1_pyramid2.image = self.img_player1_pyramid1
self.player1_pilot1 = Button(self,
width="144",
height="139",
bg="dodger blue",
text="player1_pilot1",
command=self.clicking_player1_pilot1,
image=self.img_player1_pilote1)
self.player1_pilot1.image = self.img_player1_pilote1
self.player1_pilot2 = Button(self,
width="144",
height="139",
bg="dodger blue",
text="player1_pilot2",
command=self.clicking_player1_pilot2,
image=self.img_player1_pilote1)
self.player1_pilot2.image = self.img_player1_pilote1
self.player2_captain = Button(self,
width="144",
height="139",
bg="red",
text="player2_capitain",
command=self.clicking_player2_captain,
image=self.img_player2_captain)
self.player2_captain.image = self.img_player2_captain
self.player2_pyramid1 = Button(self,
width="144",
height="139",
bg="red",
text="player2_pyramid1",
command=self.clicking_player2_pyramid1,
image=self.img_player2_pyramid1)
self.player2_pyramid1.image = self.img_player2_pyramid1
self.player2_pyramid2 = Button(self,
width="144",
height="139",
bg="red",
text="player2_pyramid2",
command=self.clicking_player2_pyramid2,
image=self.img_player2_pyramid1)
self.player2_pyramid2.image = self.img_player2_pyramid1
self.player2_pilot1 = Button(self,
width="144",
height="139",
bg="red",
text="player2_pilot1",
command=self.clicking_player2_pilot1,
image=self.img_player2_pilot1)
self.player2_pilot1.image = self.img_player2_pilot1
self.player2_pilot2 = Button(self,
width="144",
height="139",
bg="red",
text="player2_pilot2",
command=self.clicking_player2_pilot2,
image=self.img_player2_pilot1)
self.player2_pilot2.image = self.img_player2_pilot1
self.player1_pions = [
self.player1_captain, self.player1_pyramid1, self.player1_pyramid2,
self.player1_pilot2, self.player1_pilot1
]
self.player2_pions = [
self.player2_captain, self.player2_pyramid1, self.player2_pyramid2,
self.player2_pilot2, self.player2_pilot1
]
self.update_GUI()
self.AI = SimpleAI(self.game)
if self.game.turn == 1:
self.sound.play_blue_first()
else:
self.sound.play_red_first()
self.AI.make_a_move()
self.update_GUI()
self.protocol("WM_DELETE_WINDOW", self.on_closing_game)
def simulate(strat=None,
recomb=0.3,
pop_size=10,
mut=0.7,
bound_rad=3,
num_weights=6,
iters=200,
plotDataFile="PlotData.txt",
FlappyDataFile='FlappyData.txt',
dataFolder='../data/'):
plotDataFile = dataFolder + plotDataFile + \
"rec" + str(recomb) + \
"pop" + str(pop_size) + \
"mut" + str(mut) + \
"brad" + str(bound_rad) + \
"wnum" + str(num_weights) + \
"strat" + str(strat)
FlappyDataFile = dataFolder + FlappyDataFile
genetic_params = {
"recombination": recomb, #0.3,
"pop_size": pop_size, #23,
"mutation": mut, #0.7, # try 0.2
"bound_rad": bound_rad #3
}
bounds = [(-genetic_params["bound_rad"], genetic_params["bound_rad"])
] * num_weights
game = Game(MANUAL_PLAY=False,
AI_PLAY=True,
plotDataFile=plotDataFile,
flappyDataFile=FlappyDataFile)
with open(FlappyDataFile, 'a') as file:
output = "---------- Simulation number " + str(1) + \
" with bound radius: " + str(genetic_params["bound_rad"]) + \
" recombination: " + str(genetic_params["recombination"]) + \
" pop size: " + str(genetic_params["pop_size"]) + \
" mutation: " + str(genetic_params["mutation"]) + \
" gap size: " + str(PIPEGAPSIZE) + \
" num weights: " + str(num_weights) + \
" strat: " + str(strat) + \
" ----------\n"
file.write(output)
result = differential_evolution(
game.main,
bounds,
maxiter=iters,
disp=True,
recombination=genetic_params["recombination"],
popsize=genetic_params["pop_size"],
mutation=genetic_params["mutation"],
strategy=strat)
print(result)
print("Done with de")
return result, plotDataFile
def main():
Game(5, 5)
from Game import Game
if __name__ == "__main__":
g = Game()
g.set_game()
def setUp(self):
self.game = Game(1)
# Script main permettant de lancer le jeu.
from Game import Game
from Player import *
import pickle
NB_STICKS = 15
cpu1 = CPUPlayer("CPU_1", "hard", NB_STICKS)
cpu2 = CPUPlayer("CPU_2", "hard", NB_STICKS)
for i in range(1, 20000):
Game(NB_STICKS).start(cpu1, cpu2, False)
with open("data",'wb') as output: pickle.dump(cpu1.getNeuronNetwork(), output, pickle.HIGHEST_PROTOCOL)
