def update_image(self, world):
xvel = Game.cutoff(self.vel[0], 0.01)
yvel = Game.cutoff(self.vel[1], 0.01)
if xvel != 0 or yvel != 0:
self.update_anim_timer(True, world)
if xvel < 0:
self.transition_to_anim_dir(0, world)
elif xvel > 0:
self.transition_to_anim_dir(2, world)
elif yvel < 0:
self.transition_to_anim_dir(1, world)
elif yvel > 0:
self.transition_to_anim_dir(3, world)
else:
if self.facing == Game.LEFT:
anim_dir = 0
else:
anim_dir = 1
self.transition_to_anim(0, anim_dir, world)
if self.anim_state != 0:
self.update_anim_timer(False, world)
self.img = self.body_images[self.anim_state][self.anim_dir]
self.hair_img = self.hair_images[self.anim_state][self.anim_dir]
self.tail_img = self.tail_images[self.anim_state][self.anim_dir]
def run():
n = 0
gameState = "run"
global game, menu, refresh
while True:
interact()
if Menu.gameWindow(menu):
gameState = Game.run(game, dt)
if gameState == "run":
if(n % 10):
#effacer la console
#sys.stdout.write("\033[2J")
Menu.show(menu)
Game.show(game)
elif gameState == "lose":
Menu.setCurrentWindow(menu, "lose")
Menu.show(menu)
gameState = "run"
elif gameState == "win":
Menu.setCurrentWindow(menu, "win")
Menu.show(menu)
gameState = "run"
else:
if refresh==True:
Menu.show(menu)
time.sleep(dt)
n += 1
def __init__(self, infile=None, void_color=VOID_COLOR):
if not infile is None:
board = []
for line in infile:
board.append(list(line.strip()))
self.board = np.array(board).transpose()
self.shape = self.board.shape
else:
board = real_world.split()
for i, line in enumerate(board):
board[i] = list(line.strip())
self.board = np.array(board).transpose()
self.shape = self.board.shape
self.void_color = void_color
self.game = None
self.sprites = {
'g': pygame.image.load(
Game.resource_path(Game.Game.SPRITES_LOCATION, 'grass.png')
).convert(),
'w': pygame.image.load(
Game.resource_path(Game.Game.SPRITES_LOCATION, 'water.png')
).convert(),
't': pygame.image.load(
Game.resource_path(Game.Game.SPRITES_LOCATION, 'tree.png')
).convert(),
}
def dungeonTest(self):
''' Set up dungeon test '''
from EriuMapTileClass import Forest
mt = Forest(3, 5)
d = A.MultiLevelArea(name = u"The Dungeons of Dread")
mt.setConnectedArea(d)
d.buildStartingLevel()
d.buildDungeon(4)
d1 = d.getLevels()[0]
self.player = P.Player()
d1.placeCreatureAtEntrance(self.player)
# orc1 = Cr.Orc()
# d1.placeCreatureAtRandom(orc1)
#
# orc2 = Cr.Orc()
# d1.placeCreatureAtRandom(orc2)
self.openShelf()
G.ui.setPlayer(self.player)
G.setCurrentLevel(d1)
self.play()
def AddPlayer(self, player):
print "Adding player "
game = self.getAvailableGames()
uuid = player.uuid
self.players[uuid] = player
player.Send({"action": "getUUID", "message": str(uuid)})
if not game is None:
player.inGame = True
self.games[game].addPlayer(player)
player.game = game
opponents = game.getOpponents(player)
if game.minPlayersConnected() == True:
player.inGame = True
# player.Send({"action": "inGameStart", "message": str(opponents[0].uuid)})
# self.other.Send({"action":"inGameStart", "message": str(uuid)})
for p in opponents:
p.Send({"action": "inGameStart", "message": str(uuid)})
self.players[p.uuid].inGame = True
else:
game = Game()
game.addPlayer(player)
self.games[game] = game
player.game = game
player.Send({"action": "isHost", "message": True})
self.other = player
def main():
#global donePlaying
#global titleScreen
#global howToPlay
#global mainGame
#global gameOver
#global creditScreen
#global startMenu
#global menu
#global clearSprites
while Globals.donePlaying != True:
print Globals.donePlaying
if Globals.titleScreen == True:
Title.title()
elif Globals.howToPlay == True:
Instructions.instructions()
elif Globals.mainGame == True:
Game.game()
elif Globals.pauseMenu == True:
PauseMenu.pausemenu()
elif Globals.gameOver == True:
GameOver.gameover()
elif Globals.creditScreen == True:
Credits.credits()
elif Globals.winScreen == True:
Win.win()
def evaluate(self, trials, games, xoro, testNet = False, goodNet = 0):
"""Tests the network and returns the results"""
if testNet: ###If there is another network to test with
answers = Game.run(1,trials, games, self, xoro, True, goodNet)
else: ###If running against a random guesser
answers = Game.run(1,trials,games,self, xoro)
return answers
def start_match(self):
# Reset player history
self.player_1.forget()
self.player_2.forget()
for iteration_count in range(self.iterations):
move_1 = self.player_1.get_move()
move_2 = self.player_2.get_move()
if Game.is_communication_failed():
move_1 = Game.opposite_move_from(move_1)
if Game.is_communication_failed():
move_2 = Game.opposite_move_from(move_2)
self.moves.append([move_1, move_2])
points_1, points_2 = Game.get_points(move_1, move_2)
self.move_points.append([points_1, points_2])
self.points[0] += points_1
self.points[1] += points_2
self.player_1.remember(opponent_move=move_2, my_move=move_1, opponent_points=points_2, my_points=points_1)
self.player_2.remember(opponent_move=move_1, my_move=move_2, opponent_points=points_1, my_points=points_2)
def interact():
global direction, refresh, game, menu
refresh = False
#gestion des evenements clavier
if isData(): #si une touche est appuyee
refresh = True
key = sys.stdin.read(1)
if Menu.gameWindow(menu): # si on est sur le fenetre de jeu alors ...
Game.interact(game, settings, key)
if key == "p":
Menu.setCurrentWindow(menu, "pause") # faire apparaitre le menu Pause
else:
if key == "z":
Menu.changeSelectedButton(menu, "buttonUp")
elif key == "s":
Menu.changeSelectedButton(menu, "buttonDown")
elif key == "d":
# Execute les commandes présentent dans la liste de commande à executer du bouton selectionne
buttonCmdList = Menu.getButtonList(menu, Menu.getIndexOfSelectedButton(menu, Menu.getButtonList(menu), Menu.getButtonSelected(menu,"name")),"cmd")
for cmd in buttonCmdList:
exec cmd
if key == "\x1b":
quit() # \x1b = touche echap / appel de la fonction qui permet de quitter le jeu
while isData():
sys.stdin.read(5)
def testMakeMove():
new = Game(4)
new.array = test_board
new.makeMove(Game.CONST_UP)
assert (new.array[0] == [4,4,16,4]) and
(np.array(new.array).sum() <= 32) and
(np.array(new.array).sum() >= 28)
def render_block(self, x, y, screen, viewport, background):
#don't render air
if background:
block = World.get_block_from_id(self.background_blocks[y][x])
else:
block = World.get_block_from_id(self.foreground_blocks[y][x])
if block["name"] != "air":
Game.get_world().render_block(block["id"], [Convert.chunk_to_world(x, self), y], block["connectedTexture"], screen, viewport, background, self)
def leaderboardMenu(display):
bg = pygame.image.load("menu/wallpaper.jpg").convert_alpha()
back = pygame.image.load("buttons/back.png").convert_alpha()
font = pygame.font.Font(None, 30)
loading = font.render("Loading...",0,(0,0,0))
stringsToRender = []
names = []
scores = []
bX = 10
bY = 560
rX = 200
rY = 700
while True :
pos = pygame.mouse.get_pos()
if collide(bX,bY,back,pos) :
pygame.mouse.set_cursor(*cursor.HAND_CURSOR)
else :
pygame.mouse.set_cursor(*cursor.ARROW_CURSOR)
for event in pygame.event.get():
if event.type == MOUSEBUTTONDOWN and event.button == 1 :
if collide(bX,bY,back,pos) :
Game.menu1(display)
if event.type == QUIT:
pygame.quit()
sys.exit()
if event.type == KEYDOWN :
if event.key == K_ESCAPE :
pygame.quit()
sys.exit()
display.blit(bg,(0,0))
#draw scores
for s in range(len(stringsToRender)):
# newSurf = pygame.Surface((300,100))
# newSurf.blit(stringsToRender[s],(0,0))
# newSurf.set_alpha(255)
# display.blit(newSurf, (200,50+(s*30)))
display.blit(stringsToRender[s],(300,30+(s*30)))
display.blit(back,(bX,bY))
if len(names)<=0:display.blit(loading,(400,300))
pygame.display.update()
if len(names)<=0:
scores = LeaderboardClient.getHighScores();
names = scores[0]
scores = scores[1]
for i in range(len(names)):
stringsToRender.append(font.render(str(i+1)+": "+str(names[i])+" - "+str(scores[i]),0,(0,0,0)))
return
def openGame(self):
rows=int(self.Rows.currentText())
columns=int(self.Columns.currentText())
if(self.OptionPlayerPc.isChecked()):
self.Ventana = Game(rows,columns,1)
else:
self.Ventana = Game(rows,columns,2)
self.close()
self.Ventana.show()
def test_player_turn_after_one_mark(self):
players = {"andy": "X", "nick": "O"}
board = Board(3)
game = Game(board, players)
if not game.board.is_marked(0, 0):
game.mark(0, 0)
self.assertEquals(game.player_in_turn, players.keys()[1], "wrong player in turn")
def test_str_to_move():
print("testing string to move conversion")
print("\tnormal move")
move = Game.str_to_move("a1a2")
assert move == ((0, 0), (1, 0))
print("\tpromotion")
move = Game.str_to_move("c7c8q")
assert move == ((6, 2), (7, 2), "q")
def test_if_game_has_finnished_by_board_completion(self):
b = Board(3)
p = {"andy": "X", "nick": "O"}
g = Game(b, p)
for i in range(3):
for j in range(3):
b.fill_position(i, j, choice(ascii_uppercase))
self.assertTrue(g.is_game_finnished(), "game is not finnished")
def update(self, world):
corner_empty = True
for piece in self.pieces:
if piece.pos == [self.pos[0] + 1, self.pos[1] + 1]:
corner_empty = False
solved = corner_empty and self.count_inversions() == 0
if solved:
Game.play_sound("sfx/puzzle/complete.ogg")
for piece in self.pieces:
piece.locked = True
def test_if_game_has_finnished_by_user_winning(self):
b = Board(3)
p = {"andy": "X", "nick": "O"}
g = Game(b, p)
for i in range(3):
for j in range(3):
b.fill_position(i, j, "X")
self.assertTrue(g.is_game_finnished(), "game is not finnished")
def test_board_creation(self):
g = Game()
assert len(g.get_open_squares()) == 4 * 4
assert len(g.board) == 4
assert len(g.board[0]) == 4
g2 = Game(5, 6)
assert len(g2.get_open_squares()) == 5 * 6
assert len(g2.board) == 5
assert len(g2.board[0]) == 6
def main():
pygame.init()
size = [SC_WIDTH, SC_HEIGHT]
screen = pygame.display.set_mode(size)
font = pygame.font.Font(None, 25)
pygame.display.set_caption('Donkey Kong')
game = Game()
game.gameLoop(screen, font)
def main(): """...""" evManager = EventManager() keyboardMouseGameContController = KeyboardMouseGameContController(evManager) controlMapper = ControlMapper(evManager) spinner = CPUSpinnerController(evManager) pygameView = PygameView(evManager) game = Game(evManager) game.start() spinner.run()
class WerewolfTagClient:
game = None
window = None
display = pygame.display
event = pygame.event
mixer = pygame.mixer #for sound
frameRate = 60
screenWidth = 640
screenHeight = 480
fullScreen = False
currentState = GameState.GAME
def __init__(self):
pygame.init()
self.window=self.display.set_mode([self.screenWidth, self.screenHeight], pygame.FULLSCREEN if self.fullScreen else pygame.RESIZABLE)
pygame.mouse.set_visible(False)
self.mixer.init()
self.game = Game(self)
self.game.init()
def run(self):
isDone = False
while isDone == False:
self.window.fill((0, 0, 0))
key = pygame.key.get_pressed()
for event in pygame.event.get():
if event.type==pygame.QUIT or (event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE):
isDone = True
if self.currentState == GameState.GAME:
self.game.update(key)
elif self.currentState == GameState.EXIT:
isDone = True
if self.currentState == GameState.GAME:
self.game.draw()
self.display.flip()
def setState(self, state):
#end current state
if self.currentState == GameState.GAME:
self.game.end()
#initialize next state
if state == GameState.GAME:
state = self.game.init()
#update current state
self.currentState = state
def end(self):
self.mixer.quit()
self.display.quit()
pygame.quit()
def render_block(self, block, pos, screen, viewport):
"""#fast render water
if block["name"] == "water":
screen.blit(World.block_images[block["id"]],
Convert.world_to_viewport([Convert.chunk_to_world(pos[0], self), pos[1]], viewport))"""
#don't render air
if block["name"] != "air":
#print(block["name"] + " " + str(block["id"]))
Game.get_world().render_block(block["id"], [Convert.chunk_to_world(pos[0], self), pos[1]], block["connectedTexture"], screen, viewport)
if Game.DEBUG:
#draw bounding box
pygame.draw.rect(screen, Game.BLACK, pygame.Rect(Convert.chunk_to_viewport(pos, self, viewport), (Game.BLOCK_SIZE * Game.SCALE, Game.BLOCK_SIZE * Game.SCALE)), 1)
def __init__(self, **kwargs):
self.questStatus = QuestStatus.NOT_STARTED
self.questName = None
self.startConversation = None
self.progressConversation = None
self.completedConversation = None
self.questGivingNPC = None
self.questReturnNPC = None
self.questRequirements = set()
Game.addQuest(self)
def startGame(self,playerID,playerLetter):
if (self.gameThreads[playerID]) is None:
return "0290 PLAYER NOT FOUND"
game = Game(False)
thread = GameThread(game)
#lock
self.gameThreads[playerID] = thread
#release
thread.start()
if game.start(playerLetter):
return "0210 GAME IS STARTED"
return "0999 UNKOWN ERROR"
def draw_tooltip(self, screen, name, description = []):
font = Game.get_font(False)
big_font = Game.get_font(True)
mouse_pos = pygame.mouse.get_pos()
name_image = GUI.render_string_array([name], big_font, 0, Game.WHITE)
desc_image = GUI.render_string_array(description, font, 0, Game.WHITE)
name_width = name_image.get_width()
name_height = name_image.get_height()
desc_width = desc_image.get_width()
desc_height = desc_image.get_height()
width = max(name_width, desc_width)
height = name_height
if desc_height > 0:
height += TOOLTIP_GAP + desc_height
corner = 4 * Game.SCALE
edge = 2 * corner
pos = (mouse_pos[0] + corner, mouse_pos[1])
#if too long, flip it to the other side of the mouse
if pos[0] + width + 2 * corner > Game.SCREEN_WIDTH:
pos = (max(pos[0] - width - 4 * corner, 0), pos[1]) #gap for mouse
if pos[1] + height + 2 * corner > Game.SCREEN_HEIGHT:
pos = (pos[0], pos[1] - height - 2 * corner)
#top border
screen.blit(Images.tooltip_pieces[0][0], pos)
for x in range(0, width, edge):
screen.blit(Images.tooltip_pieces[0][1], (pos[0] + corner + x, pos[1]))
screen.blit(Images.tooltip_pieces[0][2], (pos[0] + 3 * corner + x, pos[1]))
#middle
slices = math.ceil(height / edge)
for s in range(slices):
y = height * s // slices
screen.blit(Images.tooltip_pieces[1][0], (pos[0], pos[1] + corner + y))
for x in range(0, width, edge):
screen.blit(Images.tooltip_centers[((x + y) // edge) % 4], (pos[0] + corner + x, pos[1] + corner + y))
screen.blit(Images.tooltip_pieces[1][2], (pos[0] + 3 * corner + x, pos[1] + corner + y))
#bottom border
y = corner + height
screen.blit(Images.tooltip_pieces[2][0], (pos[0], pos[1] + y))
for x in range(0, width, edge):
screen.blit(Images.tooltip_pieces[2][1], (pos[0] + corner + x, pos[1] + y))
screen.blit(Images.tooltip_pieces[2][2], (pos[0] + 3 * corner + x, pos[1] + y))
#text
screen.blit(name_image, (pos[0] + corner, pos[1] + corner))
screen.blit(desc_image, (pos[0] + corner, pos[1] + corner + name_height + TOOLTIP_GAP))
def worldMapTest(self):
''' Set up world map test '''
self.worldMap = W.EriuWorldMap(width = C.WORLD_MAP_WIDTH, height = C.WORLD_MAP_HEIGHT, num_regions = C.NUM_REGIONS)
self.worldMap.buildMap()
self.player = P.Player()
self.worldMap.placePlayer(self.player)
self.openShelf()
G.ui.setPlayer(self.player)
G.setCurrentLevel(self.worldMap)
self.play()
def update(self, world):
if self.hurt_time > -1:
if self.hurt_time == 0:
self.hurt = False
self.hurt_time -= 1
self.knockback[0] = Game.cutoff(self.knockback[0], ent.DamageSource.KNOCKBACK_FALLOFF)
self.knockback[1] = Game.cutoff(self.knockback[1], ent.DamageSource.KNOCKBACK_FALLOFF)
if self.knockback[0] != 0:
self.vel[0] += self.knockback[0]
self.knockback[0] += math.copysign(ent.DamageSource.KNOCKBACK_FALLOFF, -self.knockback[0])
if self.knockback[1] != 0:
self.vel[1] += self.knockback[1]
self.knockback[1] += math.copysign(ent.DamageSource.KNOCKBACK_FALLOFF, -self.knockback[1])
super().update(world)
def townTest(self):
name = getPlaceName()
d = EriuTownLevel(tilesWide = 3, tilesHigh = 3, area = None, name = name, depth = 0)
d.buildLevel()
self.player = P.Player()
d.placeCreatureAtRandom(self.player, False)
self.openShelf()
G.ui.setPlayer(self.player)
G.setCurrentLevel(d)
self.play()
def main():
print('Marco Bros Starting')
pygame.init()
pygame.font.init()
win = pygame.display.set_mode((1280, 720))
pygame.display.set_caption('Marco Bros')
clock = pygame.time.Clock()
game = Game(win, clock)
game.gameloop()
print('exited game')
def reset(self):
del self.pygame
self.pygame = Game.Pygame2D()
obs = self.pygame.observe()
return obs
def main():
game = Game()
game.run()
def __init__(self):
cmd.Cmd.__init__(self)
self.prompt = "Enter your command: \n"
self.game = Game()
def setupdb(self):
# If you set this to 1, it will print out all data as it populates the datbase.
debugging = 0
# make a database connection to the game database
if debugging:
print('connecting to database')
conn = connect('./db/game.db')
# create our cursor
if debugging:
print('creating cursor')
cur = conn.cursor()
# create our armor table in the database
if debugging:
print('creating table for armor')
cur.execute(
'''CREATE TABLE IF NOT EXISTS armor (level INTEGER, class TEXT, name TEXT, type TEXT, basedef INTEGER, durability INTEGER)'''
)
# insert our armor table in the database
if debugging:
print('inserting armor into database')
with open('./csv/armor.csv', 'r') as fin:
dr = csv.reader(fin)
for i in dr:
if debugging:
print('inserting ' + str(i))
cur.execute('INSERT INTO armor VALUES (?,?,?,?,?,?);', i)
if debugging:
cur.execute('SELECT * FROM armor')
rows = cur.fetchall()
for row in rows:
print('QUERY ALL: ' + str(row))
# create our enemy table in the database
if debugging:
print('creating table for enemies')
cur.execute(
'''CREATE TABLE IF NOT EXISTS enemies(level INT, firstname TEXT, middlename TEXT, lastname TEXT, attack INTEGER, xp INTEGER, gold INTEGER, hp INTEGER, def INTEGER, status TEXT)'''
)
# insert our enemy table in the database
if debugging:
print('inserting enemies into database')
with open('./csv/enemies.csv', 'r') as fin:
dr = csv.reader(fin)
for i in dr:
if debugging:
print('inserting ' + str(i))
cur.execute(
'INSERT INTO enemies VALUES (?,?,?,?,?,?,?,?,?,?);', i)
if debugging:
cur.execute('SELECT * FROM enemies')
rows = cur.fetchall()
for row in rows:
print('QUERY ALL: ' + str(row))
# create our items table in the database
if debugging:
print('creating table for items')
cur.execute(
'''CREATE TABLE IF NOT EXISTS items(level INT, grade INT,name TEXT,effect INT,value INT)'''
)
# insert our items table in the database
if debugging:
print('inserting items into database')
with open('./csv/items.csv', 'r') as fin:
dr = csv.reader(fin)
for i in dr:
if debugging:
print('inserting ' + str(i))
cur.execute('INSERT INTO items VALUES (?,?,?,?,?);', i)
if debugging:
cur.execute('SELECT * FROM items')
rows = cur.fetchall()
for row in rows:
print('QUERY ALL: ' + str(row))
# create our levelnotes table in the database
if debugging:
print('creating table for levelnotes')
cur.execute(
'''CREATE TABLE IF NOT EXISTS levelnotes(Level INT,HP INT,ATK INT,DEF INT,xptonextlevel INT, dodge INT )'''
)
# insert our levelnotes table in the database
if debugging:
print('inserting levelnotes into database')
with open('./csv/levelnotes.csv', 'r') as fin:
dr = csv.reader(fin)
for i in dr:
if debugging:
print('inserting ' + str(i))
cur.execute('INSERT INTO levelnotes VALUES (?,?,?,?,?,?);', i)
if debugging:
cur.execute('SELECT * FROM levelnotes')
rows = cur.fetchall()
for row in rows:
print('QUERY ALL: ' + str(row))
# create our shields table in the database
if debugging:
print('creating table for shields')
cur.execute(
'''CREATE TABLE IF NOT EXISTS shields (level INT,class TEXT,name TEXT,type TEXT,basedef INT,durability INT)'''
)
# insert our shields table in the database
if debugging:
print('inserting shields into database')
with open('./csv/shields.csv', 'r') as fin:
dr = csv.reader(fin)
for i in dr:
if debugging:
print('inserting ' + str(i))
cur.execute('INSERT INTO shields VALUES (?,?,?,?,?,?);', i)
if debugging:
cur.execute('SELECT * FROM shields')
rows = cur.fetchall()
for row in rows:
print('QUERY ALL: ' + str(row))
# create our weapons table in the database
if debugging:
print('creating table for weapons')
cur.execute(
'''CREATE TABLE IF NOT EXISTS weapons ( level INTEGER ,class TEXT ,name TEXT ,type TEXT,baseattack INTEGER ,durability INTEGER ,power TEXT)'''
)
# insert our weapons table in the database
if debugging:
print('inserting weapons into database')
with open('./csv/weapons.csv', 'r') as fin:
dr = csv.reader(fin)
for i in dr:
if debugging:
print('inserting ' + str(i))
cur.execute('INSERT INTO weapons VALUES (?,?,?,?,?,?,?);', i)
if debugging:
cur.execute('SELECT * FROM weapons')
rows = cur.fetchall()
for row in rows:
print('QUERY ALL: ' + str(row))
# create our riddles table in the database
if debugging:
print('creating table for riddles')
cur.execute(
'''CREATE TABLE IF NOT EXISTS riddles (question TEXT ,answer TEXT)'''
)
# insert our riddles table in the database
if debugging:
print('inserting riddles into database')
with open('./csv/riddles.csv', 'r') as fin:
dr = csv.reader(fin)
for i in dr:
if debugging:
print('inserting ' + str(i))
cur.execute('INSERT INTO riddles VALUES (?,?);', i)
if debugging:
cur.execute('SELECT * FROM riddles')
rows = cur.fetchall()
for row in rows:
print('QUERY ALL: ' + str(row))
# commit the changes
conn.commit()
# close the database connection to let other operations use it
conn.close()
Game.centerprint('...Have fun')
server = ""
port = 5555
server_ip = socket.gethostbyname(server)
try:
s.bind((server, port))
except socket.error as e:
print(str(e))
s.listen(2)
print("Waiting for a connection")
game = Game()
connected = set()
games = {}
idCount = 0
def threaded_client(conn, p, gameId):
global idCount
# conn.send(str.encode(str(p)))
# print(conn)
while True:
try:
data = conn.recv(2048)
if gameId in games:
game = games[gameId]
skittles_agent2 = Agent(skittles_move)
skittles_agent2.S = LoadTable("TTT Skittles 2.json")
skittles_agent2.post = skittles_after
# ### Running the Game - Random vs Skittles 2
# In[14]:
W = []
L = []
T = []
n = []
total_games = 0
for i in range(100):
g = Game(number_of_games=1000)
g.display = False
result = g.run(random_agent, skittles_agent2)
SaveTable(skittles_agent1.S, "TTT Skittles 1.json")
SaveTable(skittles_agent2.S, "TTT Skittles 2.json")
percent_wins = sum([_ == 1 for _ in result]) / len(result) * 100
percent_losses = sum([_ == 2 for _ in result]) / len(result) * 100
percent_ties = sum([_ == 0 for _ in result]) / len(result) * 100
total_games += g.number_of_games
n.append(total_games)
W.append(percent_wins)
L.append(percent_losses)
T.append(percent_ties)
Game.clear()
print("INVALID OPTION!\nPlease type a number.")
input("PRESS ENTER TO CONTINUE...")
# Otherwise, process the user's selection
else:
# If 1, play the game
if choice == 1:
game()
# If 2, add custom words to CustomWords.txt
elif choice == 2:
add_words(custom_words)
break
# If 3, open Nick Lueth's LinkedIn page
elif choice == 3:
open_linkedin()
break
# If 4, quit the game
elif choice == 4:
exit(0)
# Otherwise, prompt the user again
else:
print("That value is not a valid option...")
sleep(1.5)
easy_words = Game.get_easy_words()
medium_words = Game.get_medium_words()
hard_words = Game.get_hard_words()
custom_words = Game.get_custom_words()
main_menu()
def test_game_isinstance_of_game_class(self):
game = Game_library.Game()
message = "Object is not instance of Game class"
self.assertIsInstance(game, Game_library.Game, message)
#!/usr/bin/python import random import sys import os import queue import Game from queue import Queue import PerfectBot os.environ["SDL_VIDEODRIVER"] = "dummy" # Main game loop Harta = [[0 for x in range(0, 3 + 1)] for y in range(0 + 3 + 1)] newGame = Game.Game() newGame.printMap() newGame.play()
def main():
""" Main Program """
pygame.init()
# Set the height and width of the screen
size = [SCREEN_WIDTH, SCREEN_HEIGHT]
screen = pygame.display.set_mode(size)
pygame.display.set_caption("State of the Art-ificial Intelligence")
# <insert large block of code at bottom if shit goes south>
# Loop until the user clicks the close button.
games = []
finishedGames = []
# game1 = Game(screen, 0)
# game2 = Game(screen, 1)
numGames = 1
for game in range(numGames):
tempGame = Game(screen, game)
games.append(tempGame)
done = False
# Used to manage how fast the screen updates
clock = pygame.time.Clock()
# -------- Main Program Loop -----------
while not done:
for game in games:
if game.isOver:
finishedGames.append(game)
games.remove(game)
# update players --> in update() tell players to think()
#in the think(), they should run the neural net once
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
"""
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
user_player.direction = "left"
user_player.executeAction(0)
if event.key == pygame.K_RIGHT:
user_player.direction = "right"
user_player.executeAction(1)
if event.key == pygame.K_UP:
user_player.executeAction(2)
if event.key == pygame.K_SPACE:
user_player.executeAction(4)
if event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT:
user_player.executeAction(3)
if event.key == pygame.K_RIGHT:
user_player.executeAction(3)
"""
if event.type == pygame.USEREVENT:
for game in games:
for player in game.entities:
if player.playerID == event.id:
eventPlayer = player
if event.action == "attack":
eventPlayer.executeAction(4)
elif event.action == "moveLeft":
eventPlayer.executeAction(0)
eventPlayer.direction = "left"
elif event.action == "moveRight":
eventPlayer.executeAction(1)
eventPlayer.direction = "right"
elif event.action == "jump":
eventPlayer.executeAction(2)
elif event.action == "stop":
eventPlayer.executeAction(3)
eventPlayer.direction = "none"
elif event.action == "damage":
eventPlayer.health -= 2
else:
print("unkown event: ", event)
# Update items in the level
for game in games:
game.level.update()
# game.active_sprite_list.update()
games[0].level.draw(screen)
games[0].level.drawBG(screen)
for game in games:
# game.active_sprite_list.draw(screen)
game.level.draw(screen)
game.player.updateHealth()
game.enemy.updateHealth()
#time.sleep(.05)
# mouse_pos = pygame.mouse.get_pos()
# for player in players:
# # draw the lines between point
# player.distanceToPoint(player.enemyPos, True, BLUE)
# # player.distanceToPoint((800,500),True, RED, "X")
# player.updateHealth()
# playerOne.updateHealth()
# playerTwo.updateHealth()
# ALL CODE TO DRAW SHOULD GO ABOVE THIS COMMENT
# Limit to 60 frames per second
clock.tick(60)
# Go ahead and update the screen with what we've drawn.
pygame.display.flip()
# Be IDLE friendly. If you forget this line, the program will 'hang'
# on exit.
pygame.quit()
def check_drunkeness(self, move):
if self.current_round >= self.START_BREATH_TEST and self.lawyer_is_drunk(
):
return Game.opposite_move(move)
return move
from Game import * Game = Game(5,5,"machine")
GameX = GameX.humanPlayerInput()
while not GameX:
GameX = PrevGameX.humanPlayerInput()
steps += 1
GameX.printGameState()
if GameX.utility == float('-inf'):
print(screeOutput_youWin)
elif GameX.utility == float('inf'):
print('Computer Wins')
print(screeOutput_youLose)
else:
print(screeOutput_tie)
input('press enter')
if __name__ == '__main__':
player = input('Do you want to start first ? \n[0-No ; 1-Yes]')
TicTacToGame = None
if player == '0' or player == '1':
TicTacToGame = Game.TicTacTo(
[[' ', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']], int(player))
play(TicTacToGame, 4)
else:
player = input('Invalid Input \n Press Enter to exit')
import Game as game game.Game()
def test_game_default_initializes_instance_game_deck_object_correct(self):
game = Game_library.Game()
message = "Game - Deck Object is not instance of Deck class"
self.assertIsInstance(game.game_deck, Deck_library.Deck, message)
# # player1 = Game.Computer.Player.Player(10,"Mike")
# player1 = Game.Computer.Computer(10,1)
# player2 = Game.Computer.Computer(10,2)
# player3 = Game.Computer.Computer(10,3)
# player4 = Game.Computer.Computer(10,4)
rock = 0
paper = 0
n = 100
for i in range(n):
players = []
nPlayers = 100
for i in range(nPlayers):
players.append(Game.Computer.Computer(1000,i+1))
game = Game.Game(players)
playersLeft = True
rnd = 1
while playersLeft:
cleanout = []
for player in game.players:
if player.health <= 0 :
cleanout.append(player)
for item in cleanout:
second = item
game.players.remove(item)
if len(game.players) <= 1:
print(game.players[0].getLimits())
rock += game.players[0].getLimits()[0]
""" Fichier main qui lance le programme """ from Game import * game = Game() game.play()
def main():
game = Game()
game.start()
def main():
file_name = os.path.abspath(sys.argv[1])
Game.Game(file_name)
import Game
if __name__ == "__main__":
game = Game.Game()
game.on_execute()
def async_Q(max_time_steps: int, reward: int, penalty: int,
checkpointFrequency: int, checkpoint_dir,
policyNetwork: List[NeuralNetwork], policySess,
targetNetwork: List[NeuralNetwork], targetSess, lock: Lock,
queue: Queue):
"""
:param max_time_steps:
:param reward:
:param penalty:
:param checkpointFrequency:
:param checkpoint_dir:
:param policyNetwork:
:param policySess:
:param targetNetwork:
:param targetSess:
:param lock:
:param queue:
:return:
"""
time_steps = 0
# Create random epsilon list
epsilon = [] # type: List[float]
for idx in range(Constants.numberOfSnakes):
while True:
e = np.random.normal(0.8, 0.1)
if e < 1:
epsilon.append(e)
break
while True:
g = Game.Game() # creates game object
#Start a Game
snake_list = g.snakes # contains list of Snake objects
episodeRunning = True # True if game is running, false if not
pastStateAlive = [True for i in range(Constants.numberOfSnakes)
] # keeps track if Snakes were alive
actions_taken = [0 for j in range(Constants.numberOfSnakes)
] # holds the actions last taken for each snake
initial_state = [0] * Constants.numberOfSnakes
# initialize lists
state = [[] for _ in range(Constants.numberOfSnakes)]
action = [[] for _ in range(Constants.numberOfSnakes)]
reward = [[] for _ in range(Constants.numberOfSnakes)]
next_state_Q = [[] for _ in range(Constants.numberOfSnakes)]
while episodeRunning: #Meaning in an episode
for idx in range(Constants.numberOfSnakes): # for each snake
# contains all snakes except the currently indexed one
pruned_snake_list = [
snake for snake in snake_list if snake != snake_list[idx]
]
if g.snakes[idx].alive:
# Get state of snake
initial_state[idx] = Agent.getState(g.snakes[idx],
pruned_snake_list,
g.food,
normalize=True)
# Choose action to take using epsilon greedy action
actions_taken[idx] = epsilon_greedy_action(
g.snakes[idx], policySess[idx], policyNetwork[idx],
initial_state[idx], epsilon[idx])
state[idx].append(
initial_state[idx]
) # keep track of state by appending it to list
action[idx].append([
actions_taken[idx]
]) # keep track of action by appending it to list
pastStateAlive[idx] = True
else:
actions_taken[idx] = None
pastStateAlive[idx] = False
# Try to move all snakes according to their computed actions
try:
# List[int] , bool
single_step_reward, episodeRunning = g.move(
actions_taken) # rewards for snake actions, game end state
except AssertionError:
print("Error making moves {} in game :\n{}".format(
actions_taken, g))
#Now we transition to the next state
time_steps += 1
lock.acquire()
T = queue.get()
T += 1
queue.put(T)
lock.release()
# Every 500 time steps...
if T % checkpointFrequency == 0:
# for each snake...
for idx in range(Constants.numberOfSnakes):
# Save policy and target network checkpoints
policyNetwork[idx].save_model(
policySess[idx],
"{}/policy_{}_{}.ckpt".format(checkpoint_dir, T, idx))
targetNetwork[idx].save_model(
targetSess[idx],
"{}/target_{}_{}.ckpt".format(checkpoint_dir, T, idx))
# for each snake...
for idx in range(Constants.numberOfSnakes):
# if snake is alive, append its reward to its reward list. (Keeps track of rewards for each snake)
if (pastStateAlive[idx]
): # To check if snake was already dead or just died
reward[idx].append([single_step_reward[idx]])
# contains all snakes except the currently indexed one
pruned_snake_list = [
snake for snake in snake_list
if snake != snake_list[idx]
]
# if the game is over or snake is dead...
if not episodeRunning or not g.snakes[
idx].alive: # train on terminal
next_state_Q[idx].append([0])
# thread waits here until thread lock is available
lock.acquire()
# Update agent policy
policyNetwork[idx].train(policySess[idx], state[idx],
action[idx], reward[idx],
next_state_Q[idx])
lock.release()
# clear lists
state[idx], action[idx], reward[idx], next_state_Q[
idx] = [], [], [], []
else:
# get snake state and get next best action to take
final_state = Agent.getState(g.snakes[idx],
pruned_snake_list,
g.food,
normalize=True)
next_state_best_Q = best_q(g.snakes[idx],
targetSess[idx],
targetNetwork[idx],
[final_state])
next_state_Q[idx].append([next_state_best_Q])
# Update agent policy
if time_steps % Constants.AQ_asyncUpdateFrequency == 0:
# for each snake
for idx in range(Constants.numberOfSnakes):
if pastStateAlive[idx] and g.snakes[
idx].alive and episodeRunning: # train only if non-terminal, since terminal case is handled above
lock.acquire()
# update agent policy
policyNetwork[idx].train(policySess[idx], state[idx],
action[idx], reward[idx],
next_state_Q[idx])
lock.release()
state[idx], action[idx], reward[idx], next_state_Q[
idx] = [], [], [], []
T = queue.get()
queue.put(T)
if T % Constants.AQ_globalUpdateFrequency == 0:
for idx in range(Constants.numberOfSnakes):
checkpoint_path = "{}/transfer_{}.ckpt".format(
checkpoint_dir, idx)
lock.acquire()
policyNetwork[idx].save_model(policySess[idx],
checkpoint_path)
targetNetwork[idx].restore_model(targetSess[idx],
checkpoint_path)
lock.release()
T = queue.get()
queue.put(T)
if T >= max_time_steps:
break
print("Episode done on thread {}. T = {}.".format(get_ident(), T))
T = queue.get()
queue.put(T)
# break out of loop when all time steps done
if T >= max_time_steps:
break
print("Thread {} complete.".format(get_ident()))
# save policy and target models
for idx in range(Constants.numberOfSnakes):
lock.acquire()
policyNetwork[idx].save_model(
policySess[idx],
"{}/policy_{}_{}.ckpt".format(checkpoint_dir, T + 1, idx))
targetNetwork[idx].save_model(
targetSess[idx],
"{}/target_{}_{}.ckpt".format(checkpoint_dir, T + 1, idx))
lock.release()
def graphical_inference(size_of_hidden_layer: int = 20,
load_dir="checkpoints",
load_time_step: int = 500,
play: bool = False,
scalingFactor: int = 9):
"""
To render graphics of the trained agents
:param size_of_hidden_layer:
:param load_dir:
:param load_time_step:
:param play:
:param scalingFactor:
:return:
"""
import pygame
import GraphicsEnv
numSnakes = Constants.numberOfSnakes # type: int
if play:
numSnakes += 1
colors = np.random.randint(0, 256, size=[numSnakes, 3])
if play: # user interacts with the agents
colors[0] = (0, 0, 0) # player's snake is always black
# Create Game Window
win = pygame.display.set_mode((scalingFactor * Constants.gridSize,
scalingFactor * Constants.gridSize))
screen = pygame.Surface(
(Constants.gridSize + 1, Constants.gridSize + 1)) # Grid Screen
pygame.display.set_caption("Snake Game")
crashed = False
targetNetwork = [] # type: List[NueralNetwork]
targetSess = [] # type: List[tf.Session]
if play:
targetNetwork.append(None)
targetSess.append(None)
length = Agent.getStateLength()
for idx in range(int(play), numSnakes):
targetNetwork.append(
FunctionApproximator.NeuralNetwork(
length, size_of_hidden_layer=size_of_hidden_layer))
targetSess.append(tf.Session(graph=targetNetwork[idx].graph))
targetNetwork[idx].init(targetSess[idx])
targetNetwork[idx].restore_model(
targetSess[idx],
"{}/target_{}_{}.ckpt".format(load_dir, load_time_step,
idx - int(play)))
g = Game.Game(numSnakes)
episodeRunning = True
while episodeRunning and not crashed:
for event in pygame.event.get():
if event.type == pygame.QUIT:
crashed = True
actionList = []
if play:
actionList.append(GraphicsEnv.manual_action(g.snakes[0], event))
for i in range(int(play), numSnakes):
snake = g.snakes[i]
if not snake.alive:
actionList.append(None)
continue
opponentSnakes = [
opponent for opponent in g.snakes if opponent != snake
]
state = Agent.getState(snake,
opponentSnakes,
g.food,
normalize=True)
action, _ = targetNetwork[i].max_permissible_Q(
targetSess[i], [state], snake.permissible_actions())
actionList.append(action)
singleStepRewards, episodeRunning = g.move(actionList)
GraphicsEnv.displayGame(g, win, screen, colors)
import Game Game.play()
from Game import *
MinimaxAI_win = 0
AlphaBetaAI_win = 0
for _ in range(1):
winner = Game().play('4', '5')
if winner == BLACK:
MinimaxAI_win += 1
elif winner == WHITE:
AlphaBetaAI_win += 1
winner = Game().play('5', '4')
if winner == BLACK:
AlphaBetaAI_win += 1
elif winner == WHITE:
MinimaxAI_win += 1
print('勝利数\n'
'MinimaxAI: %d \n'
'AlphaBetaAI: %d' % (MinimaxAI_win, AlphaBetaAI_win))
class Controller(cmd.Cmd):
def __init__(self):
cmd.Cmd.__init__(self)
self.prompt = "Enter your command: \n"
self.game = Game()
def start_game(self):
self.game.display_game_status()
def do_attack(self, line):
if self.game.attack():
print("\nYou killed the zombies")
self.game.display_game_status()
else:
print("\nNo zombie to attack\n")
def do_run(self, direction):
if self.game.run(direction):
print("\nYou ran away from the zombies. You lost 1 HP!")
self.game.display_game_status()
def do_cower(self, line):
if self.game.cower():
print("\nYou rested for a while")
self.game.display_game_status()
else:
print("\nYou must kill the zombies first\n")
def do_move(self, direction):
if self.game.move(direction):
print("\nYou are moving to " + direction)
self.game.display_game_status()
def do_get_totem(self, line):
if self.game.get_totem():
print("\nYou found the totem!")
self.game.display_game_status()
else:
print("\nNo totem in this zoom.\n")
def do_bury_totem(self, line):
if self.game.bury_totem():
print("\nTotem buried. You win the game!\n")
sys.exit()
else:
print("\nYou can't do that!\n")
def do_get_item(self, line):
if self.game.get_item():
self.game.display_game_status()
else:
print("\nNo item to get.\n")
def do_save(self, line):
if len(line) == 0:
print("You must type a file name")
else:
file = open("saves/" + line + ".data", "wb")
pickle.dump(self.game, file)
file.close()
print("File saved\n")
def do_load(self, line):
try:
file = open("saves/" + line + ".data", "rb")
self.game = pickle.load(file)
file.close()
print("File loaded\n")
self.game.display_game_status()
except (IOError, pickle.UnpicklingError):
print('Error! no such file or invalid save file')
def do_quit(self, line):
print("\n----------")
print("Game ended")
print("----------")
return 1
def do_help(self, line):
print("move <Direction> - Move player <Direction> \
run <Direction> - Escape zombies by running <Direction> \
attack - Attack zombies in current room \
cower - Hide in current room and not move this turn \
get_item - Retrieve weapon from current room \
get_totem - Retrieve totem (Only in Evil Temple) \
bury_totem - Bury totem (Only in graveyard) \
save - Save current game to <path> \
load - Load the saved game <path> \
quit - Quit game \
help - Display this help file")
def reset(self):
self.game = Game.Game()
from Piece import *
from Board import *
from Game import *
if __name__== "__main__":
res = {}
for d in range(1,3): # avoiding highest difficulty because it takes too long
for h in range(0,3):
res[(d,h)] = 0
for k in range(20):
g = Game(difficulty=d,heuristic=h,DEBUG=True)
g.play()
res[(d,h)] += g.winner
print(res)
def game():
"""
Initiates the game loop found in the Game.py file.
"""
Game.main()
## print("{} removed {} - {}".format(game.turn.ident, edge[0], edge[1]))
point_awarded = game.remove_bar(game.turn, edge[0], edge[1])
if not (game.extra_turn and point_awarded):
game.change_turns()
if game.player1.score > game.player2.score:
return game.player1.ident
elif game.player1.score < game.player2.score:
return game.player2.ident
else:
return 0
player1_wins = 0
player2_wins = 0
ties = 0
for i in range(num_trials):
game = Game(num_vertices, False)
game.graph.make_clique_graph()
winner = play_game(game)
if winner == game.player1.ident:
player1_wins += 1
elif winner == game.player2.ident:
player2_wins += 1
else:
ties += 1
print("Player 1 Wins: {}".format(player1_wins))
print("Player 2 Wins: {}".format(player2_wins))
print("Ties: {}".format(ties))
for hcard in pbo.hand:
if hcard.title == picked.title:
pb.hand.append(hcard)
pbo.hand.remove(hcard)
def clash_effect(self, game, pbidx):
pb = game.playerboards[pbidx]
card = pb.player.choosecardtodiscard(game, pbidx, ["hand", "recovery"])
pb.discard(card, ["hand", "recovery"])
if __name__ == '__main__':
import Game as G
import SimpleHumanPlayer as SHP
b = Bureaucrat()
g = G.Game(3)
for p in range(3):
shp = SHP.SimpleHumanPlayer("SHP " + str(p+1))
g.playerboards[p].player = shp
c1 = C.Card("Not this one", 500)
c2 = C.Card("Not this one either", 501)
c3 = C.Card("Yes this one", 503)
g.addtocardlist(c1)
g.addtocardlist(c2)
g.addtocardlist(c3)
g.addtocardlist(b)
g.sendcardlisttoboards()
g.playerboards[0].readytoplay(b)
print("When prompted, choose one of the cards.")
# g.playallcards()
g.playcards()
