def main():
print("\t\tWelcome to Blackjack!\n")
names = []
number = None
while not number:
number = Games.ask_number("How many players? (1-7): ", low = 1, high = 8)
for i in range(number):
name = None
while not name:
name = input("Enter player name: ")
names.append(name)
print()
game = BJ_Game(names)
again = None
while again != "n" and game.players:
game.play()
if not game.players:
print("\nNo more players left!")
else:
again = Games.ask_yes_no("\nDo you want to play again? (Y/N): ")
def create_room(self, conn):
if socks[conn].get_status() > 1:
conn.send(self.generator.create_room_fail("Status error"))
return
if len(available_ids) == 0:
new_id = len(rooms) + 1
else:
new_id = heapq.heappop(available_ids)
room = Games.Room(new_id, self.resolver.get_id(), socks[conn].get_name()) # no password version
rooms[new_id] = room
socks[conn].in_room(new_id)
socks[conn].ready()
# user status changes, need broadcast
conn.send(self.generator.create_room_suc(new_id))
fr_li = socks[conn].get_friend_list()
for i in fr_li:
if fr_li[i][1] == 1:
try:
socks[users[names[i]]].friend_in_room(socks[conn].get_name())
users[names[i]].send(self.generator.friend_in_room(socks[conn].get_name()))
except:
pass
# room list changes, need broadcast
for user in users:
try:
users[user].send(self.generator.new_room(new_id, socks[conn].get_name()))
except:
# user outline
pass
def main():
print("\t\tWelcome to Blackjack!\n")
names = []
number = Games.ask_number("How many players? (1 - 7): ", low=1, high=8)
for i in range(number):
name = input("Enter player name: ")
names.append(name)
print()
game = BJ_Game(names)
again = None
while again != 'n':
game.play()
again = Games.ask_yes_no("\nDo you want to play again?: ")
def play(list_of_players, rng, v=False):
pathData = os.path.join('data', 'simulations')
game = Games.PrisonersDilemma('Joshua')
action_space = game.actionSpace
L = len(list_of_players)
avgScoreM = np.zeros([L, L])
for i in range(5):
if v:
print(i)
for k in list_of_players:
if k.name[:6] == 'Neural':
k.prepThread(len(list_of_players), 16)
else:
k.clearHistory(len(list_of_players))
game.tournament(list_of_players, 200, rng, True)
for j in range(L):
for k in range(L):
avgScoreM[j, k] += np.sum(
list_of_players[j].lastScore[k, :]) / 200
try:
list_of_players[j].resetState()
except:
pass
#print(avgScoreM/100)
df = {}
#arr = np.array(list_avgScore)
for i in range(avgScoreM.shape[0]):
df[list_of_players[i].name] = avgScoreM[i, :] / 5
df = pd.DataFrame(df)
df.to_csv(os.path.join(pathData, 'Matrix_avgPlayers_rng.csv'))
def play(self):
# check if the card has enough cards if not repopulate and reshuffle
if len(self.deck) <= 12:
self.repopulate_deck()
# deal initial 2 cards to everyone
self.deck.deal(self.players + [self.dealer], per_hand=2)
self.dealer.flip_first_card() # hide the dealer's first card
for player in self.players:
while (1):
player.bet_amount = Games.ask_number(
'{} How much would you like to bet: ({} - {}): '.format(
player.name, 10, player.Bank.total),
low=10,
high=player.Bank.total + 1)
if player.bet(player.bet_amount):
break
player.Bank.total = player.Bank.total - player.bet_amount
for player in self.players:
print(player)
print(self.dealer)
# deal additional cards
for player in self.players:
self.__additional_cards(player)
self.dealer.flip_first_card() # reveal dealer's first card
if not self.still_playing:
# since all players have busted show dealers hand
print(self.dealer)
else:
# deal additional cards
print(self.dealer)
self.__additional_cards(self.dealer)
if self.dealer.is_busted():
# everyone still playing wins
for player in self.still_playing:
player.win()
else:
# compare each player still playing to he dealer
for player in self.still_playing:
if player.total > self.dealer.total:
player.win()
elif player.total < self.dealer.total:
player.lose()
else:
player.push()
# remove everyones cards
for player in self.players:
player.clear()
self.dealer.clear()
def main():
print("\nWelcome to the Python Highest Card game.\n")
names = []
number = Games.askForNumber("How many players? (2-7): ", low=2, high=8)
print()
i = 1
for i in range(number):
name = input("Enter player name: ")
if name == "":
names.append("Anon")
print()
i += 1
else:
names.append(name)
print()
i += 1
game = Highest_Game(names)
again = "Y"
while again == "y" or again == "Y":
game.play()
again = Games.askYesNo("\nDo you want to play again?: ")
def main():
print("\t\tWelcome to War!\n")
names = []
for i in range(2):
name = input(f"Enter player {i + 1}'s name: ")
names.append(name)
again = None
while again != "n":
game = WarGame(names)
game.play()
again = G.askYesNo("\nDo you want to play again? (Y/N)")
def start_server(self):
self.sock.bind(('', 14290))
self.sock.listen(100)
self.sock.setblocking(False)
res = conn_db.get_user_list()
print(res)
'''get names'''
for r in res:
names[r[1]] = r[0]
res = conn_db.get_card()
print(res)
for r in res:
cards[r[0]] = Games.Card(r[0], r[1], r[2], r[3])
sel.register(self.sock, selectors.EVENT_READ, self.accept)
def log(self, conn):
"""in this function, user_id is integer!
first we check the basic information, then we determine whether this user has been logged or not,
if yes, out the former
return the basic information, if the user is in game(reconnect), return the room information"""
res = conn_db.log(int(self.resolver.get_id()), self.resolver.get_password())
if res == -1:
conn.send(self.generator.log_refuse('user id not exists'))
sel.unregister(conn)
conn.close()
elif res == -2:
conn.send(self.generator.log_refuse('Wrong password'))
sel.unregister(conn)
conn.close()
else:
user_info = conn_db.get_user_info(self.resolver.get_id())
# the first element of user_info is the total game number, the second is the rate
print("info: ", user_info)
fr_li = conn_db.get_friend_list(int(self.resolver.get_id()))
print("friends: ", fr_li)
# multi-log covers
player = Games.Player(self.resolver.get_id(), conn, self.resolver.get_time(), user_info[0], fr_li)
for i in fr_li:
if fr_li[i][1] == 1:
try:
users[names[i]].send(self.generator.friend_online(player.get_name()))
socks[users[names[i]]].friend_online(player.get_name())
except:
# means user i log out
pass
try:
u = users[self.resolver.get_id()]
if u != conn:
u.send(b'another one is using this account')
socks[conn] = socks[u]
users[self.resolver.get_id()] = conn
sel.unregister(u)
u.close()
del socks[u]
except:
users[self.resolver.get_id()] = conn
socks[conn] = player
try:
un = undetermined_list[self.resolver.get_id()]
print("un: ", un)
except:
un = []
conn.send(self.generator.log_success(user_info, fr_li, un))
def __on_event(event):
if event.type == pygame.QUIT:
App.__running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_DOWN:
App.__options = (App.__options + 1) % 3
elif event.key == pygame.K_UP:
App.__options = (App.__options - 1) % 3
elif event.key == pygame.K_RETURN or event.key == pygame.K_SPACE:
if App.__options == 0:
App.__game = Games.Game(App.__display_surf)
App.__game.on_execute()
elif App.__options == 1:
print("How to Play")
elif App.__options == 2:
App.__running = False
def stability(nReplicates, epochs, gamma, v=False):
game = Games.PrisonersDilemma('Joshua')
action_space = game.actionSpace
pathData = os.path.join('data', 'simulations')
avgScoreM = np.zeros(epochs * nReplicates)
avg_op = np.zeros(epochs * nReplicates)
avg_me = np.zeros(epochs * nReplicates)
avg_switches_op = np.zeros(epochs * nReplicates)
avg_switches_me = np.zeros(epochs * nReplicates)
f = 0
for i in range(nReplicates):
player1 = strat.Neural203Agent(name='Neural',
actionSpace=game.actionSpace)
player1.gamma = gamma
player3 = strat.TitF2tatAgent(name='TitF2Tat')
list_of_players = [player1, player3]
if v:
print('process id:', os.getpid(), '\tReplicat nr:', i)
for j in range(epochs * i, epochs * i + epochs):
for k in list_of_players:
if k.name == 'Neural':
k.prepThread(len(list_of_players) - 1 + f, 10)
else:
k.clearHistory(len(list_of_players) - 1 + f)
game.tournament(list_of_players, 200, 0.05, False)
avgScoreM[j] = np.sum(list_of_players[0].lastScore) / (200)
avg_op[j] = np.sum(list_of_players[0].lastOp) / (200)
avg_me[j] = np.sum(list_of_players[0].lastMe) / (200)
avg_switches_op[j] = countSwitches(
list_of_players[0].lastOp[0]) / (200)
avg_switches_me[j] = countSwitches(
list_of_players[0].lastMe[0]) / (200)
for j in list_of_players:
if j.name == 'Neural':
j.train()
df = {}
df['avgScore'] = avgScoreM
df['avgOp'] = avg_op
df['avgMe'] = avg_me
df['avgSOp'] = avg_switches_op
df['avgSMe'] = avg_switches_me
df = pd.DataFrame(df)
df.to_csv(os.path.join(pathData, 'Stability_data_gamma{}'.format(gamma)))
def main():
print("\nWelcome to the Highest Card game.\n")
names = []
number = Games.askForNumber("How many players? (2-7): ", low=2, high=8)
print()
i = 1
for i in range(number):
name = input("Enter player name: ")
if name == "":
names.append("Anon")
print()
i += 1
else:
names.append(name)
print()
i += 1
game = BJ_Game(names)
game.play()
def train(list_of_players, rng=0.0, v=False):
pathData = os.path.join('data', 'training')
pathModel = 'model'
game = Games.PrisonersDilemma('Joshua')
action_space = game.actionSpace
list_avgScore = []
noise = 0.2
bestScore = 0
for i in range(1000):
if v:
print(i)
if i % 10 == 0:
noise *= 0.9
noise = np.max([noise, 0.05])
for k in list_of_players:
if k.name[:6] == 'Neural':
k.prepThread(len(list_of_players) - 1, 16)
else:
k.clearHistory(len(list_of_players) - 1)
game.tournament(list_of_players, 200, noise)
avgScore = []
for j in list_of_players:
avgScore.append(
np.sum(j.lastScore) / (200 * (len(list_of_players) - 1)))
if j.name[:6] == 'Neural':
j.train()
try:
j.resetState()
except:
pass
list_avgScore.append(avgScore)
if (bestScore < avgScore[0]):
list_of_players[0].saveModel(path=pathModel)
bestScore = avgScore[0]
df = {}
arr = np.array(list_avgScore)
for i in range(arr.shape[1]):
df[list_of_players[i].name] = arr[:, i]
df = pd.DataFrame(df)
df.to_csv(os.path.join(pathData, list_of_players[0].name + '.csv'))
def main():
print("\t\tWelcome to War!\n")
names = []
for i in range(2):
name = None
while not name:
name = input("Enter player "+str(i+1)+ "'s name: ")
names.append(name)
print()
game = War_Game(names)
again = None
while again != "n" and game.players:
game.play()
again = Games.ask_yes_no("\nDo you want to play again? (Y/N): ")
def is_hitting(self):
if self.has_blackjack():
return False
response = Games.ask_yes_no("\n" + self.name +
", do you want to hit? (Y/N): ")
return response.lower() == "y"
def is_hitting(self):
response = Games.ask_yes_no("\n" + self.name + ", do you want a hit? (Y/N):")
return response == "y"
import Games
if __name__ == "__main__":
Games.main()
def test_Games_smoke():
#Smoke_test
obt = Games.Games_object()
def test_Games_object_fizz():
#test the fizz_function
obj = Games.Games_object()
output = obj.fizz()
npt.assert_equal(output, "buzz")
# Simple Game
# Demos importing modules
import Games, random
print("Welcome to the world's simplest game!\n")
again = None
while again != "n":
players = []
num = Games.ask_number(question = "How many players? (2-5): ", low = 2,
high = 5)
for i in range(num):
name = input("Player name: ")
score = random.randrange(100) + 1
player = Games.Player(name, score)
players.append(player)
print("\nHere are the game results:")
for player in players:
print(player)
again = Games.ask_yes_no("\nDo you want to play again? (y/n): ")
input("\n\nPress the enter key to exit.")
import discord
import Games
import config
from collections import deque
from discord.ext import commands
Games.init()
client=commands.Bot(command_prefix='$',status=discord.Status.online,activity=discord.Game('$help'))
client.load_extension('Cogs.GamePlay')
client.load_extension('Cogs.Bot_Commands')
client.run(config.token)
import tkinter as tk import Games GnG = Games.Game() GnG.new_game() tk.mainloop()
BoydSocialTitForTat,
BoydTitForTat,
# RLABitRandom,
# RLAEGS,
# RLAlwaysCooperate,
# RLAlwaysDefects,
# RLAlwaysRandom,
# RLRandomTitForTat,
# RLTitForTat,
twoStageRLbased
]
results = {}
mresults = {}
sresults = {}
games = Games()
# tournament 1 - mvspt
def TournaMent(lst, gameHere):
score = {} # for overall score
mscore = {} # for material score
sscore = {} # for social score
for i in range(len(lst)):
if lst[i] not in score:
score[lst[i]] = 0
if lst[i] not in mscore:
mscore[lst[i]] = 0
if lst[i] not in sscore:
sscore[lst[i]] = 0
# score.append(float(0))
"look": 6,
"hunt for treasure": 7,
"lit fire": 8
}
e = {"look": 5}
f = {"look": 6}
g = {"look": 7}
h = {"look": 8}
i = {"look": 9000}
def help():
print "THIS AND THAT AND DO THIS AND THAT MENU SOMETHING"
game = Games.game()
#print rooms in gridsystem
def room_Gridsystem():
rooms = [
"hotel", "north market", "tavern", "gate", "market center", "dock",
"capital", "south market", "shanty town"
]
print rooms
#print game.gridSystem.get("north market").view_NPCs()
#intp = raw_input("enter a name ")
#for x in game.gridSystem.get("north market").view_NPCs():
# print x.compare(intp)
import SARSA as sarsa
import QLearning as qlearning
import DeepQLearning as deepQLeaning
import Random as random
import DQN_Continuo as DQNCon
import DDQN_Continuo as DDQNCon
import A2C_Discreto as A2C_D
import A2C_Continuo as A2C_C
import Games as games
seed = 1234
env = games.Tiger(seed)
A2C_D.TrainEpisodic(env,
seed,
gamma=0.75,
lmbda=0.95,
alpha=0.001,
beta=0.001,
clip=[0.1, 0.9],
normalizar=True,
Max_episodes=10000)
A2C_D.TrainOneStep(env,
seed,
gamma=0.75,
lmbda=0.95,
alpha=0.001,
beta=0.001,
clip=[0.1, 0.9],
normalizar=True,
Max_episodes=10000)
# cDDCDspite,
# dCDCDspite,
# dDDCDspite,
# cCDDCspite,
# cDDDCspite,
# dCDDCspite,
# dDDDCspite,
# cCDDDspite,
# cDDDDspite,
# dCDDDspite, # winning - 24
# dDDDDspite # winning - 25
]
games = Games(None, None, None, None)
# one generation
def getPayoffMatrix(lst, gameHere):
payoffs = [[0.0 for j in range(len(lst))] for i in range(len(lst))]
for i in range(len(lst)):
for j in range(len(lst)):
a1 = lst[i](gameHere)
b1 = lst[j](gameHere)
[scA, scB] = IteratedPD(a1, b1, gameHere)
payoffs[i][j] = scA/gameHere.Iter_N
# payoffs[j][i] = scB/gameHere.Iter_N
return payoffs
# Create new directory to save the figures
now = datetime.datetime.now()
def main():
bank = 100
wagers = 100
wagerunit = 10
wins = 0
loses = 0
push = 0
x = 0
result = dict()
even = 0
odd = 0
## end_result = stat_collector('test', 0)
while x <= wagers:
# Game 1 Blackjack
result = Games.blackJack()
if result == 'win':
wins = wins + 1
elif result == 'lose':
loses = loses + 1
elif result == 'push':
push = push + 1
x = x + 1
print("run:" + str(x))
print("wins:" + str(wins))
print("Loses:" + str(loses))
print("Push:" + str(push))
print("chance of winning:", wins / wagers)
print("chance of loses:", loses / wagers)
print("chance of push:", push / wagers)
'''
## Game 2 Roulette
##
mynumber = Games.roulette()
result = Games.roulette()
print('the winner is:' + repr(result))
if result == mynumber:
end_result.append(win, 1)
elif result != mynumber:
end_result.append(lose, 1)
#if (result[0] %2) == 0:
#even
even =+ 1
#elif result:
#odd
odd =+ 1
## push = push + 1
## x = x + 1
# print("run:" + str(x))
'''
## game3 = Games.craps()
## game4 = Games.oddsgame(.5)
## while (wagers > 0) and (bank >0):
## game
plt.plot(result)
plt.ylabel('')
plt.xlabel(' ')
plt.show()
def is_hitting(self):
response = Games.ask_yes_no("\n" + self.name + ", do you want to hit? (Y/N): ")
return response == "y"
#Simple Game
#Demonstrates importing modules
#Evan Piercy
#6.5.15
import Games, random
print("Welcome to the world's simplest game!\n")
again = None
while again !="n":
players = []
num = Games.ask_number(question = "How many players? (2 - 5): ", low = 2, high = 5)
for i in range(num):
name = input("Player name: ")
score = random.randrange(100) + 1
player = Games.Player(name, score)
players.append(player)
print("\nHere are the game results: ")
for player in players:
print(player)
again = Games.ask_yes_no("\nDo you want to play again? (y/n)")
input("\n\nPress the enter key to exit.")
import Setups.TableSetup as tbl import Games from Variables import Rounds Table = tbl.TableSetup() Results = Games.Craps(Table, Rounds) print(Results)
# score[lst[j]] += scB
sortedDic = sorted(score.items(), key=lambda score: score[1], reverse=True)
print sortedDic, 'dic'
for ele in score:
if ele not in OverallScore:
OverallScore[ele] = 0.0
OverallScore[ele] += score[ele]
winning = sortedDic[0][0]
if winning not in results.keys():
results[winning] =0
results[winning] += 1
NN = 0
# games(learning rate, discount factor, game length, memory length for the RL agent)
games = Games(None, None, None, None) # game setting choice for parameter investigation
# 50 trials
while(NN < 50):
# OverallScore = []
RoundrobinTour(lst, games)
NN += 1
print NN
print results # shows the winning strategy
for eleme in OverallScore:
OverallScore[eleme] = OverallScore[eleme]/50.0
# print OverallScore
# sortedos = sorted(OverallScore.items(), key=lambda OverallScore: OverallScore[1], reverse=True)
# print sortedos
