def Update(self):
self.counter += 1
self.auxillaryCounter += 1
self.level.Update()
timeLeft = self.GetTimeLeft()
if timeLeft == 0:
self.next = GamePlay.LoseScene(self)
self.UpdateCamera()
self.EnsureSelectionValid()
self.progress = self.level.GetProgress()
if self.specializer.Shortcircuited(
self.levelSeed.specialName
) or self.specializer.MoveToNextLevel(self.counter, self.progress):
self.next = GamePlay.LevelUpTransition(self)
messages = self.specializer.ShouldShowMessage(self.counter,
self.progress)
if messages != None:
self.next = ShowMessageOverlay(messages[0], messages[1:], self)
self.specializer.DoSomethingInteresting(self.counter,
self.auxillaryCounter,
self.progress, self,
self.level)
if self.progress == 0 and self.levelSeed.specialName != 'level1':
self.next = GamePlay.LoseScene(self)
def maximin(board, depth, alpha, beta, bestaction, player, enemy):
initial_eval = evaluate.evaluate(board)
if ((initial_eval == -9999999) or (initial_eval == 9999999) or (initial_eval == -0.005) or (depth == 0)):
return initial_eval
else:
hashes_seen = set()
val = evaluate.MAXVAL
for x in range(0, 6):
for y in range(0, 6):
if (isAvailable(board, x, y)):
for box in range(1, 5):
for direction in ["R", "L"]:
a = GamePlay.Action(x, y, box, direction)
temp = deepcopy(board)
new_board = GamePlay.take_action(temp, a, enemy)
if isUnique(symmetricBoards(new_board), hashes_seen):
hashes_seen.add(hash(str(new_board)))
val2 = minimax(
new_board, depth - 1, alpha, beta, bestaction, False, player, enemy)
if (val2 < val):
val = val2
beta = min(beta, val)
if alpha >= beta:
return val
return val
def Update(deltaTime):
for event in pygame.event.get():
if event.type == pygame.QUIT:
return False
GamePlay.ProcessEvent(event)
GamePlay.Update(deltaTime)
return True
def mousePressed(event):
canvas = event.widget.canvas
eventx = event.x
eventy = event.y
if canvas.data["state"] == "mainMenu":
if canvas.data["displayHelpScreen"] == True:
mainMenu.mousePressedInHelp(canvas,eventx,eventy)
else:
mainMenu.mousePressedInMenu(canvas,eventx,eventy)
if canvas.data["state"] == "creation":
teamCreation(canvas)
if canvas.data["state"] == "creation":
if canvas.data["teamSelectionProcess"]== True:
teamCreationGraphics.mousePressedPlayerSelection(canvas,eventx,eventy)
elif canvas.data["fixLineupOrder"] == True:
teamCreationGraphics.fixLineupOrderPlayerSelection(canvas,eventx,eventy)
if canvas.data["state"] == "game":
GamePlay.soundChanger(canvas, eventx, eventy)
gameGraphics.clickdrawHelpButton(canvas,eventx,eventy)
if canvas.data["Player1Pause"] == True or canvas.data["Player2Pause"] == True:
GamePlay.clickPlayerPause(canvas, eventx,eventy)
if canvas.data["state"] == "endGame":
endGame.mousePressedInMenu(canvas,eventx,eventy)
if canvas.data["exportTeams"] == True:
setUpTeams(canvas)
canvas.data["exportTeams"] = False
if canvas.data["state"] == "creation":
teamCreation(canvas)
if canvas.data["meanScoreReport"] == True:
while True:
message = "How many trials do you want to run?\n"
message += "Minimum of 500 trials are required.\n"
message += "There is a maximum of 10000 trials.\n"
message += "These trials may take a while to run.\n"
title = "Prompt"
response = tkSimpleDialog.askstring(title, message)
# make sure we get an integer response
try:
if response == None:
break
response = int(response)
if response >= 500 and response <= 10000:
canvas.data["gameCounter"] = response
break
except:
pass
canvas.data["meanScoreReport"] = False
if response != None:
simulateResults(canvas)
redrawAll(canvas)
def doubleMousePressed(event):
canvas = event.widget.canvas
eventx = event.x
eventy = event.y
if canvas.data["state"] == "creation":
if canvas.data["teamSelectionProcess"]== True:
teamCreationGraphics.doubleMousePressedPlayerSelect(canvas,eventx,eventy)
elif canvas.data["state"] == "game":
if canvas.data["changePitcher"] == True:
GamePlay.changePitcherClick(canvas,eventx,eventy)
if canvas.data["changeBatter"] == True:
GamePlay.changeBatterClick(canvas,eventx,eventy)
redrawAll(canvas)
def __init__(self):
pygame.init()
#start off with the basic aspects of the instacne
self.screen_width = 1920
self.screen_height = 1080
self._clock = pygame.time.Clock()
self._screen = pygame.display.set_mode((self.screen_width//2,self.screen_height//2), pygame.HWSURFACE|pygame.DOUBLEBUF, 32)
pygame.display.set_caption("AIr Words")
self._done = False
self._kinect = PyKinectRuntime.PyKinectRuntime(PyKinectV2.FrameSourceTypes_Color | PyKinectV2.FrameSourceTypes_Body)
self._frame_surface = pygame.Surface((self._kinect.color_frame_desc.Width, self._kinect.color_frame_desc.Height), 0, 32)
self._bodies = None
self.gamePlay = GamePlay() #start the other game loop eventually
self.drawingSurface = pygame.Surface((self._kinect.color_frame_desc.Width, self._kinect.color_frame_desc.Height), 0, 32)
self.drawingSurface.fill((255,255,255))
def generate_quick_best(board, player):
actions = []
hashes_seen = set()
for x in range(0, 6):
for y in range(0, 6):
if isAvailable(board, x, y):
for box in range(1, 5):
for direction in ["R", "L"]:
a = GamePlay.Action(x, y, box, direction)
temp = deepcopy(board)
new_board = GamePlay.take_action(temp, a, player)
if isUnique(symmetricBoards(new_board), hashes_seen):
hashes_seen.add(hash(str(new_board)))
initial_eval = evaluate.evaluate(board)
actions.append((a, initial_eval))
actions.sort(key=operator.itemgetter(1), reverse=True)
return actions
def Update(self):
self.counter += 1
if self.counter == 3:
#self.PlaySound('phase_complete.ogg')
levelseed = GamePlay.LevelSeed('next',
self.prevPlayScene.levelSeed,
self.prevPlayScene.level)
if levelseed.won:
self.next = GamePlay.WinScene(self.prevPlayScene)
else:
self.nextPlayScene = GamePlay.PlayScene(levelseed)
elif self.counter == 69:
self.next = self.nextPlayScene
camOff = self.next.level.initCameraOffset
if camOff != None:
self.next.cameraX = self.prevPlayScene.cameraX + camOff[0] * 32
self.next.cameraY = self.prevPlayScene.cameraY + camOff[1] * 32
def minimax(board, depth, alpha, beta, bestaction, is_top):
initial_eval = evaluate.evaluate(board)
if ((initial_eval == -9999999) or (initial_eval == 9999999)
or (initial_eval == -0.005) or (depth == 0)):
return initial_eval
val = evaluate.MINVAL
if is_top:
actions = generate_quick_best(board)
for (a, _) in actions:
temp = deepcopy(board)
new_board = GamePlay.take_action(temp, a, "AI")
val2 = maximin(new_board, depth - 1, alpha, beta, bestaction)
if (val2 > val):
val = val2
bestaction.x_coordinate = a.x_coordinate
bestaction.y_coordinate = a.y_coordinate
bestaction.square_index = a.square_index
bestaction.direction = a.direction
alpha = max(alpha, val)
if alpha >= beta:
return val
return val
else:
hashes_seen = set()
for x in range(0, 6):
for y in range(0, 6):
if isAvailable(board, x, y):
for box in range(1, 5):
for direction in ["R", "L"]:
a = GamePlay.Action(x, y, box, direction)
temp = deepcopy(board)
new_board = GamePlay.take_action(temp, a, "AI")
if isUnique(symmetricBoards(new_board),
hashes_seen):
hashes_seen.add(hash(str(new_board)))
val2 = maximin(new_board, depth - 1, alpha,
beta, bestaction)
if (val2 > val):
val = val2
alpha = max(alpha, val)
if alpha >= beta:
return val
return val
def __init__(self, levelSeed):
GameSceneBase.__init__(self)
self.tileWidth = levelSeed.width
self.tileHeight = levelSeed.height
self.level = GamePlay.Level(levelSeed)
self.levelSeed = levelSeed
self.selection_indicator = Resources.ImageLibrary.Get(
'selection_indicator.png')
self.cameraX = 0
self.cameraY = 0
self.dragStart = None
self.selection = []
self.topmenu = pygame.Surface((640, 20))
self.topmenu.fill((40, 40, 40))
pygame.draw.rect(self.topmenu, (128, 128, 128),
pygame.Rect(0, 18, 640, 2))
self.topmenu.set_alpha(200)
self.cursorLogicalPosition = (0, 0)
self.cursorScreenPosition = (0, 0)
self.suppressDragDraw = True
self.counter = 0
self.progress = 0.0
self.specializer = GamePlay.GetSpecializer(self.levelSeed.specialName)
self.auxillaryCounter = 0
self.seconds = -1
try:
self.seconds = self.levelSeed.minutes
if self.seconds != -1:
self.seconds = self.seconds * 60
except:
pass
self.font_white = Resources.GetFont(255, 255, 255)
self.font_red = Resources.GetFont(255, 0, 0)
self.font_orange = Resources.GetFont(255, 128, 0)
self.font_yellow = Resources.GetFont(255, 255, 0)
self.font_green = Resources.GetFont(0, 255, 0)
self.font_blue = Resources.GetFont(0, 170, 255)
self.specializer.DoSetup(self, self.level)
self.CenterCameraOnColorSprites()
def run(self):
while not self._done:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self._done = True
#call the appropriate method depending on the game mode
while not self.gamePlay.gameOver:
if self.gamePlay.mode == "startScreen":
self.gamePlay.handleStartScreen(self)
elif self.gamePlay.mode == "chooseHand":
self.gamePlay.chooseHand(self)
elif self.gamePlay.mode == "chooseDifficulty":
self.gamePlay.chooseDifficulty(self)
elif self.gamePlay.mode == "chooseMode":
self.gamePlay.chooseMode(self)
elif self.gamePlay.mode == "instructions":
self.gamePlay.displayInstructions(self)
elif self.gamePlay.mode == "playClassic":
self.gamePlay.handleClassicMode(self)
elif self.gamePlay.mode == "playAI":
self.gamePlay.handleAIMode(self)
#once game over, handle these events once
if self.gamePlay.mode == "gameOver":
self.gamePlay.handleGameOver(self)
if self.gamePlay.playAgain != None:
if self.gamePlay.playAgain:
self.gamePlay = GamePlay()
else:
self.gamePlay.endGame(self)
self._done = True
self._kinect.close()
pygame.quit()
def InitializeTiles(self, columns, rows, map_data):
tiles = []
x = 0
while x < columns:
y = 0
column = []
while y < rows:
#print x, y, len(map_data.grid), len(map_data.grid[0])
column.append(GamePlay.MakeTile(map_data.grid[x][y], x, y))
y += 1
tiles.append(column)
x += 1
self.tiles = tiles
def host_menu():
host_net.start_connection(host_net.server)
host_ip = _font.render("Server created. Your IP: " + host_net.get_ip(),
True, white)
r_id = str(random.randint(1000, 9999))
room_id = _font.render("Room ID: " + r_id, True, white)
room_id_sent = False
while True:
connected = host_net.is_connected()
for g_event in event.get():
if g_event.type == QUIT:
return
if connected:
if g_event.type == MOUSEBUTTONDOWN:
if g_event.button == 1:
if start_button.contains_mouse(Vector2(
mouse.get_pos())):
# send start game command to the client
host_net.send("Start_game")
# get random player side and send the other side to client
p_color = random.randint(0, 1)
print("My side:", p_color)
host_net.send(str(1 - p_color))
return GamePlay(bool(p_color), True)
# drawing
screen.fill(black)
screen.blit(game_background, (0, 300, 603, 783))
game_title.render()
screen.blit(host_ip, dest=((603 - host_ip.get_rect().width) / 2, 200))
screen.blit(room_id, dest=((603 - room_id.get_rect().width) / 2, 240))
status = _font.render(
"Opponent found." if connected else "Waiting for opponent...",
True, white)
screen.blit(status, dest=((603 - status.get_rect().width) / 2, 280))
if not connected:
host_net.listen()
else:
start_button.render(Vector2(mouse.get_pos()))
if not room_id_sent:
host_net.send(r_id)
room_id_sent = True
display.flip()
def LoadNextImage(self):
if self.cacheExists:
start = time.time()
end = start
while end - start < .02:
notdone = Resources.ImageLibrary.LoadNextCache()
progress = Resources.ImageLibrary.CacheLoadProgress()
if notdone and progress == 100:
progress = 99
end = time.time()
else:
progress = GamePlay.LoadNextThing()
return progress
def simulateResults(canvas):
import tkMessageBox
import scrape
gameCounter = 0
team1Scores = []
team2Scores = []
team1Wins = 0
team2Wins = 0
while True:
if gameCounter > canvas.data["gameCounter"]:
break
setUpTeams(canvas)
canvas.data["isSoundOn"] = False
while canvas.data["isGameOver"] == False:
GamePlay.runHalfInning(canvas)
if canvas.data["Player1TotalRuns"] > canvas.data["Player2TotalRuns"]:
team1Wins += 1
else:
team2Wins += 1
team1Scores.append(canvas.data["Player1TotalRuns"])
team2Scores.append(canvas.data["Player2TotalRuns"])
gameCounter+= 1
canvas.data["state"] = "endGame"
canvas.data["displayFinalScoreBoard"] = False
(team1StDev,team1Mean) = scrape.standardDev(team1Scores)
(team2StDev,team2Mean) = scrape.standardDev(team2Scores)
team1WinPercentage = round(float(team1Wins)/gameCounter,5)*100
team2WinPercentage = round(float(team2Wins)/gameCounter,5)*100
message = "The average runs scored per game for " + canvas.data["player1TeamName"] + " is " + str(round(team1Mean,3)) + ".\n"
message += "The standard deviation of the runs scored per game for " + canvas.data["player1TeamName"] + " is " + str(round(team1StDev,3)) + ".\n"
message += "The average runs scored per game for " + canvas.data["player2TeamName"] + " is " + str(round(team2Mean,3)) + ".\n"
message += "The standard deviation of the runs scored per game for " + canvas.data["player2TeamName"] + " is " + str(round(team2StDev,3)) + ".\n"
message += "The winning percentage for " + canvas.data["player1TeamName"] + " is " + str(team1WinPercentage) + "%.\n"
message += "The winning percentage for " + canvas.data["player2TeamName"] + " is " + str(team2WinPercentage) + "%.\n"
title = "Statistics"
tkMessageBox.showinfo(title, message)
def selectCat2() :
array = []
if(os.stat("Categories/category2.txt").st_size==0):
tkMessageBox.showinfo("Error", "Empty category file. Game will now shutdown.")
os.system("./killAllPython.sh")
else:
with open("Categories/category2.txt","r") as ins:
lines = ins.readlines()
for line in lines:
words = line.split()
for word in words:
array.append(word)
ChosenWord=random.choice (array)
#open file which will save entries
outf = open('Categories/category2.txt', 'w')
#send each user entry into the file
print>>outf, ' '.join(array)
outf.close()
outf = open('drawThis.txt', 'w')
print >>outf, ChosenWord
outf.close()
os.system('./SendMessage.py')
GamePlay.main()
def perfectPlay():
# set up new game
board = GamePlay.new_board()
depth = input("To what depth would you like the AI to search? ")
while (valid(depth, 4) == False):
depth = input("invalid depth, please input a non-negative integer ")
game_over = False
AI_turn = True
while not game_over:
if AI_turn:
action = minimax.getBestAction(board, int(depth))
board = GamePlay.take_action(board, action, "AI")
print("The AI has taken action: x=" + str(action.x_coordinate) +
", y=" + str(action.y_coordinate) + ", box=" +
str(action.square_index) + ", direction=" +
str(action.direction))
print("The new board is: ")
GamePlay.printBoard(board)
else:
ternaryBoard = boardTernaryConversion.boardConvertToTernary(board)
perfectTernaryBoard = request.takeBoardReturnReponseBoard(
ternaryBoard)
board = boardTernaryConversion.ternaryConvertToBoard(
perfectTernaryBoard)
print("The perfect pentago bot took action. The new board is: ")
GamePlay.printBoard(board)
if evaluate.evaluate(board) in [9999999, -9999999, -.005]:
final_score = evaluate.evaluate(board)
game_over = True
board_full = True
for x in range(6):
for y in range(6):
if board[x][y] == " ":
board_full = False
if board_full:
game_over = True
final_score = -.006
AI_turn = not AI_turn
if final_score == 9999999:
print("Game over, the AI has won")
if final_score == -9999999:
print(":( the perfect pentago bot won")
if final_score == -.005:
print("Its a tie!")
if final_score == -.006:
print("The board is full, its a tie!")
def DoSomethingInteresting(self, counter, auxCounter, conversionProgress,
playScene, level):
maple = level.citizens[0]
if counter == 41:
self.lapis = level.citizens[1]
maple.targetX = 15 * 32
maple.targetY = 10 * 32
self.lapis.targetX = 9 * 32
self.lapis.targetY = 3 * 32
elif counter == 120: # when lapis reaches the door
level.citizens = level.citizens[:1]
level.sprites = level.sprites[:1]
elif counter == 145:
level.tiles[15][9] = GamePlay.MakeTile('int/phonograph', 15, 9)
level.tiles[15][9].SetMinColorIntensity(255)
elif counter == 175:
pygame.mixer.music.load(
os.path.join('Media', 'Music', '98time.mp3'))
pygame.mixer.music.set_volume(0.5)
pygame.mixer.music.play(-1)
elif counter >= 220 and counter <= 220 + 255:
v = counter - 220
maple.color = v
elif counter >= 220 + 255 and counter <= 220 + 255 + 255: # 730
v = (counter - 220 - 255) // 2
y = 2
while y <= 11:
x = 3
while x <= 16:
level.tiles[x][y].SetMinColorIntensity(v)
x += 1
y += 1
elif counter == 829:
self.lapis.direction = 'down'
level.citizens.append(self.lapis)
level.sprites.append(self.lapis)
def ProcessInput(self, events):
for event in events:
if event.type == pygame.MOUSEBUTTONUP and event.button == 1:
x = event.pos[0] + self.cameraX
y = event.pos[1] + self.cameraY
pressed = pygame.key.get_pressed()
if pressed[pygame.K_LCTRL] or pressed[
pygame.K_RCTRL] or pressed[pygame.K_LSHIFT] or pressed[
pygame.K_RSHIFT]:
#TODO: figure out why this gets called even when shift/ctrl isn't pressed
#self.ToggleSelection(self.dragStart, (x, y))
self.SetSelection(self.dragStart, (x, y))
else:
self.SetSelection(self.dragStart, (x, y))
self.dragStart = None
elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
x = event.pos[0] + self.cameraX
y = event.pos[1] + self.cameraY
self.dragStart = (x, y)
self.suppressDragDraw = False
elif event.type == pygame.MOUSEMOTION:
self.cursorScreenPosition = event.pos
x = event.pos[0] + self.cameraX
y = event.pos[1] + self.cameraY
self.cursorLogicalPosition = (x, y)
elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 3:
self.MoveSelectionToTarget(event.pos[0] + self.cameraX,
event.pos[1] + self.cameraY)
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.next = Menus.GamePauseMenu(self)
if event.key == pygame.K_F7:
for sprite in self.level.citizens:
sprite.Decolorize()
if event.key == pygame.K_F8:
self.next = GamePlay.WinScene(self)
def join_menu():
ip_heading = _font.render("IP:", True, white)
typing = False
ip_field = ""
first_menu = True
while first_menu:
mouse_pos = Vector2(mouse.get_pos())
for g_event in event.get():
if g_event.type == QUIT:
return
if g_event.type == MOUSEBUTTONDOWN:
if g_event.button == 1:
typing = Rect(150, 200, 300, 50).contains(
(mouse_pos.x, mouse_pos.y, 0, 0))
if join_button.contains_mouse(mouse_pos):
join_server.connect(ip_field)
if join_server.is_connected():
first_menu = False
if g_event.type == KEYDOWN:
if not typing:
break
if g_event.key == K_BACKSPACE:
ip_field = ip_field[:-1]
else:
ip_field += g_event.unicode
if len(ip_field) > 15:
ip_field = ip_field[:-1]
screen.fill(black)
screen.blit(game_background, (0, 300, 603, 783))
game_title.render()
draw.rect(screen, white if typing else grey, Rect(150, 200, 300, 50))
screen.blit(ip_heading, dest=(110, 210))
ip_text = _font.render(ip_field, True, black)
screen.blit(ip_text, dest=(160, 207))
find_button.render(mouse_pos)
display.flip()
second_menu = True
room_id = join_server.receive(4)
room_id = _font.render("Room ID: " + room_id, True, white)
status = _font.render("Waiting for the host to start game.", True, white)
while second_menu:
for g_event in event.get():
if g_event.type == QUIT:
return
# wait for start game command from the host
cmd = join_server.receive(10)
if cmd == "Start_game":
side = int(join_server.receive(1))
return GamePlay(bool(side), False)
screen.fill(black)
screen.blit(game_background, (0, 300, 603, 783))
game_title.render()
screen.blit(room_id, dest=((603 - room_id.get_rect().w) / 2, 240))
screen.blit(status, dest=((603 - status.get_rect().w) / 2, 280))
display.flip()
def __init__(self, levelseed):
self.width = levelseed.width
self.height = levelseed.height
self.OMGHAX = None
self.pixelWidth = self.width * 32
self.pixelHeight = self.height * 32
self.InitializeTiles(self.width, self.height, levelseed.map)
self.sprites = []
self.police = []
self.counter = 0
self.randomDirections = [(1, 0), (-1, 0), (0, 1), (0, -1)]
self.citizens = []
for citizen in levelseed.map.citizens:
x = citizen[0]
y = citizen[1]
tx = citizen[4]
ty = citizen[5]
sprite = GamePlay.Citizen(32 * citizen[0] + 16,
32 * citizen[1] + 16, citizen[2],
citizen[3])
if levelseed.map.isCrowdLevel:
sprite.Crowdify()
if x != tx or y != ty:
sprite.SetWaypoint(tx * 32, ty * 32)
fx = sprite.X
fy = sprite.Y
while self.TileNotPassable(fx // 32, fy // 32):
fy += 1
sprite.X = self.OMGHAX[0] * 32 + 16
sprite.Y = self.OMGHAX[1] * 32 + 16
self.sprites.append(sprite)
self.citizens.append(sprite)
self.citizens[0].color = 255
for police in levelseed.map.police:
sprite = GamePlay.Police(32 * police[0] + 16, 32 * police[1] + 16,
police[2])
self.sprites.append(sprite)
self.police.append(sprite)
if levelseed.map.isCrowdLevel:
sprite.Crowdify()
self.spriteGraph = SpriteGraph(self.width, self.height)
self.PreColorize(levelseed.map.colorize_these)
self.initCameraOffset = None
spriteCarryOver = levelseed.map.spriteCarryOver
if spriteCarryOver == None:
spriteCarryOver = levelseed.map.carryoversprites
if spriteCarryOver != None:
x = spriteCarryOver[0]
y = spriteCarryOver[1]
self.initCameraOffset = (x, y)
self.CarryOverSprites(x, y, levelseed.map.previousLevel)
levelseed.map.previousLevel = None
def Render(screen):
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
GamePlay.Render(screen)
Border.Render(screen)
pygame.display.flip()
def keyPressed(event):
canvas = event.widget.canvas
if canvas.data["state"] == "creation":
################
#### This is for team name creation purposes
if canvas.data["team1Made"] == False:
if (event.char >= "a" and event.char <= "z") or (event.char >= "A" and event.char <= "Z"):
canvas.data["team1Name"] += event.char
elif event.keysym == "BackSpace":
if len(canvas.data["team1Name"]) > 0:
canvas.data["team1Name"] = canvas.data["team1Name"][:len(canvas.data["team1Name"])-1]
elif event.keysym == "Return":
if len(canvas.data["team1Name"]) != 0:
canvas.data["team1Made"] = True
elif canvas.data["team1Made"] == True and canvas.data["teamsNamesMade"] == False:
if (event.char >= "a" and event.char <= "z") or (event.char >= "A" and event.char <= "Z"):
canvas.data["team2Name"] += event.char
elif event.keysym == "BackSpace":
if len(canvas.data["team2Name"]) > 0:
canvas.data["team2Name"] = canvas.data["team2Name"][:len(canvas.data["team2Name"])-1]
elif event.keysym == "Return":
if len(canvas.data["team2Name"]) != 0:
canvas.data["teamsNamesMade"] = True
canvas.data["teamSelectionProcess"] = True
elif canvas.data["teamSelectionProcess"] == True:
# go to the next page for player selection
if event.keysym == "Down" and canvas.data["playerSelectionPage"]< canvas.data["playersPages"]:
canvas.data["playerSelectionPage"] += 1
elif event.keysym == "Up" and canvas.data["playerSelectionPage"] > 0 :
canvas.data["playerSelectionPage"] -= 1
elif event.keysym == "Return":
# Check if player selection has been made and proceed to next pick
if canvas.data["team1Picked"] == False and canvas.data["team1Roster"][canvas.data["positionPicking"]] != ("Empty",""):
#we also to remove the player for the next player
teamCreationGraphics.removeLastPlayerPicked(canvas)
canvas.data["team1Picked"] = True
canvas.data["playerSelectionPage"] = 0
canvas.data["CurrentPlayerSelected"] = None
elif canvas.data["team1Picked"] == True and canvas.data["team2Roster"][canvas.data["positionPicking"]] != ("Empty",""):
# Set the table for the next position pick
canvas.data["team1Picked"] = False
canvas.data["playersAvailable"] = None
canvas.data["positionPicking"] += 1
canvas.data["playerSelectionPage"] = 0
canvas.data["CurrentPlayerSelected"] = None
if canvas.data["positionPicking"] == canvas.data["ammountOfPlayers"]:
canvas.data["teamSelectionProcess"] = False
canvas.data["fixLineupOrder"] = True
elif canvas.data["fixLineupOrder"] == True:
if canvas.data["currentPlayerForLineupFixing"] != None:
# Allows us to change the lineup order
if event.keysym == "Down" and canvas.data["currentPlayerForLineupFixing"] < 8:
teamCreationGraphics.movePlayerOnRoster(canvas,"down")
elif event.keysym == "Up" and canvas.data["currentPlayerForLineupFixing"] > 0:
teamCreationGraphics.movePlayerOnRoster(canvas,"up")
if event.keysym == "Return":
if canvas.data["player1FixingLineup"] == True:
canvas.data["player1FixingLineup"] = False
canvas.data["currentPlayerForLineupFixing"] = None
else:
canvas.data["fixLineupOrder"] = False
canvas.data["exportTeams"] = True
if canvas.data["state"] == "game":
if canvas.data["isGameOver"] == False:
if canvas.data["duringGameHelpScreen"] == True:
if event.keysym == "Return":
canvas.data["duringGameHelpScreen"] = False
else:
if event.keysym == "Return" and (canvas.data["changePitcher"] == True or canvas.data["changeBatter"] == True):
canvas.data["Player1Pause"] = False
canvas.data["Player2Pause"] = False
canvas.data["changePitcher"] = False
canvas.data["changeBatter"] = False
elif event.char == "q" and canvas.data["Player2Pause"] == False and(canvas.data["changePitcher"] == False and canvas.data["changeBatter"] == False):
if canvas.data["Player1Pause"] == True:
canvas.data["Player1Pause"] = False
else:
canvas.data["Player1Pause"] = True
elif event.char == "p" and canvas.data["Player1Pause"] == False and (canvas.data["changePitcher"] == False and canvas.data["changeBatter"] == False):
if canvas.data["Player2Pause"] == True:
canvas.data["Player2Pause"] = False
else:
canvas.data["Player2Pause"] = True
elif event.keysym == "Right" and canvas.data["Player2Pause"] == False and canvas.data["Player1Pause"] == False:
GamePlay.runHalfInning(canvas)
if canvas.data["isGameOver"] == True:
canvas.data["state"] = "endGame"
createMainMenu(canvas)
redrawAll(canvas)
class RunGame(object):
def __init__(self):
pygame.init()
#start off with the basic aspects of the instacne
self.screen_width = 1920
self.screen_height = 1080
self._clock = pygame.time.Clock()
self._screen = pygame.display.set_mode((self.screen_width//2,self.screen_height//2), pygame.HWSURFACE|pygame.DOUBLEBUF, 32)
pygame.display.set_caption("AIr Words")
self._done = False
self._kinect = PyKinectRuntime.PyKinectRuntime(PyKinectV2.FrameSourceTypes_Color | PyKinectV2.FrameSourceTypes_Body)
self._frame_surface = pygame.Surface((self._kinect.color_frame_desc.Width, self._kinect.color_frame_desc.Height), 0, 32)
self._bodies = None
self.gamePlay = GamePlay() #start the other game loop eventually
self.drawingSurface = pygame.Surface((self._kinect.color_frame_desc.Width, self._kinect.color_frame_desc.Height), 0, 32)
self.drawingSurface.fill((255,255,255))
def draw_color_frame(self, frame, target_surface):
target_surface.lock()
address = self._kinect.surface_as_array(target_surface.get_buffer())
ctypes.memmove(address, frame.ctypes.data, frame.size)
del address
target_surface.unlock()
#basis for the game loop, on the outer level
def run(self):
while not self._done:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self._done = True
#call the appropriate method depending on the game mode
while not self.gamePlay.gameOver:
if self.gamePlay.mode == "startScreen":
self.gamePlay.handleStartScreen(self)
elif self.gamePlay.mode == "chooseHand":
self.gamePlay.chooseHand(self)
elif self.gamePlay.mode == "chooseDifficulty":
self.gamePlay.chooseDifficulty(self)
elif self.gamePlay.mode == "chooseMode":
self.gamePlay.chooseMode(self)
elif self.gamePlay.mode == "instructions":
self.gamePlay.displayInstructions(self)
elif self.gamePlay.mode == "playClassic":
self.gamePlay.handleClassicMode(self)
elif self.gamePlay.mode == "playAI":
self.gamePlay.handleAIMode(self)
#once game over, handle these events once
if self.gamePlay.mode == "gameOver":
self.gamePlay.handleGameOver(self)
if self.gamePlay.playAgain != None:
if self.gamePlay.playAgain:
self.gamePlay = GamePlay()
else:
self.gamePlay.endGame(self)
self._done = True
self._kinect.close()
pygame.quit()
def redrawAll(canvas):
canvas.delete(ALL)
if canvas.data["state"] == "mainMenu":
mainMenu.drawBackground(canvas)
mainMenu.drawBoxes(canvas)
if canvas.data["displayHelpScreen"] == True:
mainMenu.makeHelpScreen(canvas)
elif canvas.data["state"] == "creation":
teamCreationGraphics.drawBackground(canvas)
if canvas.data["teamsNamesMade"] == False:
teamCreationGraphics.teamNameCreation(canvas)
elif canvas.data["teamSelectionProcess"]== True:
teamCreationGraphics.pickTeam(canvas)
teamCreationGraphics.currentPlayerSelected(canvas)
teamCreationGraphics.displayRoster(canvas)
elif canvas.data["fixLineupOrder"] == True:
teamCreationGraphics.fixLineupOrder(canvas)
elif canvas.data["exportTeams"] == True:
# lets start the game
teamCreationGraphics.exportTeams(canvas)
if canvas.data["startRightAway"] == True:
teamCreationGraphics.startGame(canvas)
setUpTeams(canvas)
canvas.data["exportTeams"] = False
return
canvas.data["exportTeams"] = False
elif canvas.data["state"] == "game":
gameGraphics.drawBackground(canvas)
gameGraphics.drawScoreBoard(canvas)
gameGraphics.drawField(canvas)
gameGraphics.drawBattingScore(canvas)
gameGraphics.drawLastPlay(canvas)
gameGraphics.drawCurrentPitcher(canvas)
gameGraphics.drawHitAndOutColors(canvas)
gameGraphics.drawOuts(canvas)
gameGraphics.drawSound(canvas)
gameGraphics.drawHelpButton(canvas)
if canvas.data["duringGameHelpScreen"] == True:
gameGraphics.drawHelpMenu(canvas)
if canvas.data["Player1Pause"] == True:
if canvas.data["changePitcher"] == True:
GamePlay.drawChangePitcher(canvas,1)
elif canvas.data["changeBatter"] == True:
GamePlay.drawChangeBatter(canvas,1)
else:
GamePlay.drawPlayerPause(canvas,1)
if canvas.data["Player2Pause"] == True:
if canvas.data["changePitcher"] == True:
GamePlay.drawChangePitcher(canvas,2)
elif canvas.data["changeBatter"] == True:
GamePlay.drawChangeBatter(canvas,2)
else:
GamePlay.drawPlayerPause(canvas,2)
elif canvas.data["state"] == "endGame":
endGame.drawBackground(canvas)
if canvas.data["displayFinalScoreBoard"] == True:
gameGraphics.drawScoreBoard(canvas)
endGame.drawBoxes(canvas)
def move_pieces(self, G):
i = 0
while True:
try:
time.sleep(0.5)
G = self.trace[i]
self.update_grid(G)
i += 1
except IndexError:
break
def start_simulation(G):
root=tk.Tk()
root.resizable(0,0)
DrawBoard(root,G)
root.mainloop()
game = gp.Game()
# game.value_iteration(100)
game.load_values_from_text()
game.play_game()
grid = game.grid_states[:]
# grid = [[[0, 4, 0, 3, 0, 3, 0, 3], [3, 0, 3, 0, 3, 0, 3, 0], [0, 3, 0, 3, 0, 3, 0, 3], [1, 0, 1, 0, 1, 0, 1, 0],
# [0, 1, 0, 1, 0, 1, 0, 1], [2, 0, 2, 0, 2, 0, 2, 0], [0, 2, 0, 2, 0, 2, 0, 2], [2, 0, 2, 0, 2, 0, 5, 0]]]
if __name__ == "__main__":
start_simulation(grid)
def new_game():
board = GamePlay.new_board()
depth = input("To what depth would you like the AI to search? ")
while (valid(depth, 4) == False):
depth = input("invalid depth, please input a non-negative integer ")
turn = input('Would you like to go first? (y/n) ')
while turn != 'y' and turn != 'n':
print(
'You have entered an invalid input. Type either y or n and then press enter'
)
turn = input('Would you like to go first? (y/n) ')
if turn == 'y':
GamePlay.printBoard(board)
turn = 0
if turn == 'n':
turn = 1
game_over = False
while not game_over:
if turn == 0:
x = input(
"Please input the x coordinate where you would like to place your marble "
)
while (valid(x, 1) == False):
x = input(
"Invalid input, please select a number between 0 and 5 ")
y = input("Please input the y coordinate ")
while (valid(y, 1) == False):
y = input(
"Invalid input, please select a number between 0 and 5 ")
while not (minimax.isAvailable(board, int(x), int(y))):
print(
"There is already a marble on the location you selected. Please choose another one"
)
x = input(
"Please input the x coordinate where you would like to place your marble "
)
while (valid(x, 1) == False):
x = input(
"Invalid input, please select a number between 0 and 5 "
)
y = input("Please input the y coordinate ")
while (valid(y, 1) == False):
y = input(
"Invalid input, please select a number between 0 and 5 "
)
s = input(
"Please input the index of the square you would like to rotate "
)
while (valid(s, 2) == False):
s = input(
"Invalid input, please enter an integer between 1 and 4 ")
d = input(
"Please input the direction you would like to rotate the sqaure "
)
while (valid(d, 3) == False):
d = input("Invalid input, please enter R or L ")
action = GamePlay.Action(int(x), int(y), int(s), d)
board = GamePlay.take_action(board, action, "Player")
print("The new board is:")
GamePlay.printBoard(board)
turn = 1
else:
##minimax.minimax(board, 3, action)
action = minimax.getBestAction(board, int(depth))
board = GamePlay.take_action(board, action, "AI")
print("The AI has taken action: x=" + str(action.x_coordinate) +
", y=" + str(action.y_coordinate) + ", box=" +
str(action.square_index) + ", direction=" +
str(action.direction))
print("The new board is: ")
GamePlay.printBoard(board)
turn = 0
if evaluate.evaluate(board) in [9999999, -9999999, -.005]:
final_score = evaluate.evaluate(board)
game_over = True
board_full = True
for x in range(6):
for y in range(6):
if board[x][y] == " ":
board_full = False
if board_full:
game_over = True
final_score = -.006
if final_score == 9999999:
print("Game over, the AI has won")
if final_score == -9999999:
print("Congratulations! You won!")
if final_score == -.005:
print("Its a tie!")
if final_score == -.006:
print("The board is full, its a tie!")
again = input('Would you like to play again? (y/n) ')
while again != 'y' and again != 'n':
print(
'You have entered an invalid input. Type either y or n and then press enter'
)
again = input('Would you like to play again? (y/n) ')
if again == 'y':
new_game()
import math, pygame, random, sys, os, Menu, GameOver, GamePlay
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
PATH = sys.path[0]
import numpy as np
if __name__ == "__main__":
pygame.init()
SIZE = (1280, 720)
screen = pygame.display.set_mode(SIZE)
choice = Menu.Menu1(SIZE, screen)
if choice != 'gameover':
if choice == 'single':
result = GamePlay.gameplay(SIZE, screen, 'single')
elif choice == 'double':
result = GamePlay.gameplay(SIZE, screen, 'double')
elif choice == 'computer':
pass
elif choice == 'learn':
pass
pygame.quit()
def GetPlayScene(self):
global _registeredSeeds
_registeredSeeds = None
levels = []
width = 28
height = 24
if self.mapSize == 2:
width = 42
height = 36
elif self.mapSize == 3:
width = 64
height = 48
swidth = width
sheight = height
for i in range(9):
if i == 5:
width = swidth
height = sheight
levels.append((width, height))
width = int(width * 1.6)
height = int(height * 1.6)
if self.startZoom < 5:
levels = levels[:5]
else:
levels = levels[5:]
isCrowd = self.args['isCrowd']
lastWidth = levels[-1][0]
lastHeight = levels[-1][1]
lastLevel = MapGen.Generator(lastWidth, lastHeight, True, isCrowd)
while not lastLevel.IsDone():
lastLevel.DoNextTask()
commands = lastLevel.commands
lastLevel = MapGen.BuildMapFromCommands(commands, width, height, None,
None, None)
# Generate tiles for big map
# generate empty maps for smaller maps
maps = []
for level in levels:
#print level
mp = MapGen.BuildMapFromCommands([], level[0], level[1], None,
None, None)
#print 'map instance:', len(mp.grid), len(mp.grid[0])
maps.append(mp)
maps[-1] = lastLevel
# determine top left coordinate of smaller map where it is in big map
offsets = []
for level in levels:
x = (lastWidth - level[0]) // 2
y = (lastHeight - level[1]) // 2
offsets.append((x, y))
# blit big map onto smaller maps
for i in range(len(offsets) - 1):
x = offsets[i][0] - offsets[i + 1][0]
y = offsets[i][1] - offsets[i + 1][1]
maps[i + 1].spriteCarryOver = (x, y)
for i in range(len(levels) - 1):
offset = offsets[i]
xOffset = offset[0]
yOffset = offset[1]
level = maps[i]
size = levels[i]
width = size[0]
height = size[1]
#print i, width,height
y = 0
while y < height:
x = 0
while x < width:
level.grid[x][y] = lastLevel.grid[x + xOffset][y + yOffset]
x += 1
y += 1
addTheseSprites = []
# blast out a bunch of sprites. PlayScene will automatically move sprites if they aren't standing in a valid place (like on a roof)
for i in range(100):
rx = int(random.random() * lastWidth - 4) + 2
ry = int(random.random() * lastHeight - 4) + 2
addTheseSprites.append((rx, ry))
# sprites in previous level zone move to previous level
for i in range(len(levels)):
size = levels[i]
offset = offsets[i]
level = maps[i]
newSpriteList = []
for sprite in addTheseSprites:
if sprite[0] < offset[0] or sprite[
0] >= offset[0] + size[0] or sprite[1] < offset[
1] or sprite[1] >= offset[1] + size[1]:
newSpriteList.append(sprite)
else:
x = sprite[0] - offset[0]
y = sprite[1] - offset[1]
level.citizens.append((x, y, random.random() < .5,
random.choice([1, 2, 3, 4]), x, y))
addTheseSprites = newSpriteList
# add a sprite to each border region of each level
for level in maps:
level.citizens.append((1, 1, True, 1, 1, 1))
levels = levels[self.startZoom:]
maps = maps[self.startZoom:]
offsets = offsets[self.startZoom:]
seeds = []
for i in range(len(levels)):
#print 'level',i,levels[i][0], levels[i][1], len(maps[i].grid), len(maps[i].grid[0])
seeds.append(
GamePlay.LevelSeed(
None, {
'map': maps[i],
'width': levels[i][0],
'height': levels[i][1],
'isCrowd': isCrowd,
'mode': ('individual', 'crowd')[isCrowd],
'progress': True,
'minutes': self.minutes
}))
_registeredSeeds = seeds
first = _registeredSeeds[0]
_registeredSeeds = _registeredSeeds[1:]
if not self.doProgress:
_registeredSeeds = []
return GamePlay.PlayScene(first)
def findAvailableAction(board):
for x in range(0, 6):
for y in range(0, 6):
if isAvailable(board, x, y):
return GamePlay.Action(x, y, 1, "L")
import GamePlay import welcome welcome.welcome() GamePlay.GamePlay()
import GamePlay
import time
#Best settings :
#Settings for 12x12 grid totaltrails = 101000, testtrails = 1000, gamma = 0.2, epnum = 1000, lrnum = 10
#Settings for 18x18 grid, 250000,1000,0.2,1000,10 : Ans : 12.23 hits
#Settings for 16x16 grid, 175000,1000,0.2,1000,10 : Ans : 10.02 hits
gammaTest = [0.7]
epnumTest = [1000]
lrnumTest = [10]
for gamma in gammaTest:
for epnum in epnumTest:
for lrnum in lrnumTest:
start_time = time.time()
QL = GamePlay.GamePlay(101000, 1000, gamma, epnum, lrnum)
QL.QPlay()
print("gamma: ", gamma, " epnum: ", epnum, " lrnum: ", lrnum,
" avg : ", QL.answer)
print("Time: ", time.time() - start_time, " s")
