def init(self, server, numPlayers=4):
#### Server details ####
self.whoAmI = 0
self.server = server
self.otherStrangers = 0
self.pokerMove = None # the move that is to be sent
#### Game Details ####
self.screen = 'splash' # 'game', 'gameOver', 'help', 'credits'
# 'help-game'
self.timerDelay = 0
self.tickSpeed = 10
self.font = pygame.font.Font(pygame.font.get_default_font(), 12)
self.players = [Player(i) for i in range(numPlayers)]
self.boardImage = getBoardImage(self.width, self.height)
self.statusBoardImage = getStatusBoardImage(self, 4)
self.cardScale = 30 # changes size of cards
self.cardImages = getCardImages(self.cardScale)
self.drawPlayerPositions = getDrawPlayerPositions(self, numPlayers)
self.buttonImages = getButtonImages()
self.status = GameController(numPlayers, self.players)
self.buttonPositions = dict()
#### Multiplayer Specific Fixes ####
self.status.server = self.server
self.status.firstClick = False
def read_message(self, message):
if message.startswith("DECK:"):
self.rerender = True
self.cards_to_load = message[len("DECK:"):].split(",")
if len(self.cards_to_load) > 0:
self.check_current()
else:
print "EMPTY DECK!!"
self.main.client.close()
elif message.startswith("CARDFILE:"):
self.rerender = True
s1 = message[len("CARDFILE:"):]
s2 = s1[:s1.index(":")]
#print "RECEIVED CARD "+s2+"/"+str(len(self.cards_to_load))
self.current_message = s2 + "/" + str(len(self.cards_to_load))
index = int(s2)
s3 = s1[len(s2) + 1:]
#print s3[:1000]
self.main.master_deck.unpickle_and_add_card(s3)
print "'" + self.main.master_deck.cards[-1].name + "' downloaded."
if CLIENT_PRERENDER_DECK:
self.card_img = pygame.transform.smoothscale(
self.main.master_deck.cards[-1].get_image(),
self.card_size)
self.add_to_collage()
self.check_next()
elif message.startswith("CARDFILE_ATTRIBUTES:"):
self.rerender = True
s1 = message[len("CARDFILE_ATTRIBUTES:"):]
s2 = s1[:s1.index(":")]
#print "RECEIVED CARD ATTRIBUTES "+s2+"/"+str(len(self.cards_to_load))
self.current_message = s2 + "/" + str(len(self.cards_to_load))
index = int(s2)
s3 = s1[len(s2) + 1:]
if self.matching_card.pc_attributes != s3:
#Our attributes file varies from theirs, so we have to download the entire card... poop.
self.main.client.send("REQUEST_CARDFILE:" +
str(self.card_index))
else:
self.main.master_deck.cards.append(self.matching_card)
if CLIENT_PRERENDER_DECK:
self.card_img = pygame.transform.smoothscale(
self.main.master_deck.cards[-1].get_image(),
self.card_size)
self.add_to_collage()
self.check_next()
elif message == "CLIENT_READY":
print "DURATION:", round(self.main.time - self.start_time, 3)
self.rerender = True
self.main.play_sound("connected")
import GameController
self.main.controller = GameController.GameController(self.main)
else:
return False
return True
def eval_genomes(self, genomes, config):
for genome_id, genome in genomes:
self.final_score = 0
self.inputs = []
self.net = neat.nn.FeedForwardNetwork.create(genome, config)
game = GameController.GameController(self)
while game.playing_game:
pass
self.final_score = game.score
genome.fitness = self.final_score
if self.num % self.numPerGen == 0:
self.num = 1
self.gen += 1
self.num += 1
def __init__ (self): self.lll = LowLevelLib () self.inputmanager = InputManager (self) #self.display = Display () self.viewspace = ViewSpace () self.curmap = Map (40) # just for test self.curmap.heights.setHeight(2,3,-1) self.curmap.heights.setHeight(2,5,1) self.curmap.heights.setHeight(4,5,-1) self.gfxengine = GFXEngine (self.lll, self.viewspace, self.curmap) self.gamecontroller = GameController (self) self.running = False self.starttime = 0
def __init__(self, address="0.0.0.0", port=5000):
super(Server, self).__init__()
self.CONNECTION_LIST = [] # list of socket client connected
self.port = port
self.ipaddr = address
# create a new socket
self.sockfd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sockfd.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sockfd.bind((self.ipaddr, self.port))
self.sockfd.listen(5)
self.CONNECTION_LIST.append(self.sockfd)
self.gameServer = GameController()
self.msServer = MessageController()
print "Game server started on port " + str(self.port)
def init(self, numPlayers=4):
self.hideCards = True
self.screen = 'splash' # 'game', 'gameOver', 'help', 'credits'
# 'help-game'
self.timerDelay = 0; self.tickSpeed = 10
self.font = pygame.font.Font(pygame.font.get_default_font(), 12)
self.players = [Player(i) for i in range(numPlayers)]
self.boardImage = getBoardImage(self.width, self.height)
self.statusBoardImage = getStatusBoardImage(self, 4)
self.cardScale = 30 # changes size of cards
self.cardImages = getCardImages(self.cardScale)
self.drawPlayerPositions = getDrawPlayerPositions(self,numPlayers)
self.buttonImages = getButtonImages()
self.status = GameController(numPlayers, self.players)
self.buttonPositions = dict()
self.status.chooseStartCards(self.players)
self.aiList = [None] + [AI(i) for i in range(1,numPlayers)]
self.aiDiff = 'easy'
def newGame(playerID, player):
#Makes a new game for the player.
game_sessions = open("../game_sessions/sessionlist", writeback=True)
# create a new entry in game_sessions
gameID = sha256(repr(time()).encode()).hexdigest()
game_sessions[gameID] = [player]
index = 0
player_list = game_sessions[gameID]
game_sessions.close()
#print(list(game_sessions.keys()))
# create a game, create a GameController for it and add the player
game = open("../game_sessions/sess_" + gameID, writeback=True)
gc = GameController()
gc.joinGame(player)
game["GameController"] = gc
game.close()
# make player session
makePlayerSession(playerID, gameID, index)
return str([pl._name for pl in player_list])
def main():
pygame.init()
done = False
# Start the clock
clock = pygame.time.Clock()
# Lock cursor to window
#pygame.event.set_grab(True)
# Build Game Controller
gameController = GameController.GameController()
# Loop Start
while not done:
gameController.handleInput()
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
done = True
gameController.update()
gameController.draw()
# Throttle frame rate
clock.tick(const.FRAME_RATE)
# Uncomment below to output fps to console
#print(clock.get_fps())
# Flip to user
pygame.display.flip()
#Loop End
pygame.quit()
sys.exit()
counter += 1
view_label(game_screen, (start_x, start_y), 'Stats: ')
closeWindow = False
pos = [0, 0]
win_coord = [0, 0]
game_screen = set_window_settings(screen_size, 'My PyGame Windows')
camera = Camera(1000, 1000)
all_mobs = pygame.sprite.Group()
all_items = pygame.sprite.Group()
all_static = pygame.sprite.Group()
game_controller = GameController(game_screen, camera, all_mobs, all_items,
all_static)
game_map = MapObject('map_test', game_screen, game_controller, (50, 50),
map_cell_size, 45, 25)
game_map.create_map_from_file('test_map_3.txt')
mob_creator = MobCreator(game_screen, game_map, game_controller)
item_creator = ItemCreator(game_screen, game_map, game_controller)
mob_creator.create_goblin('first goblin', (41, 5), 3)
mob_creator.create_goblin('second goblin', (19, 6), 3)
mob_creator.create_goblin('third goblin', (37, 20), 3)
mob_creator.create_goblin('fourth goblin', (30, 12), 3)
mob_creator.create_goblin('fifth goblin', (8, 13), 3)
for i in range(12, 20):
from GameController import * controller = GameController() controller.startNewGame() mainloop()
import cocos from model/game import GameModel from view/game import GameModel from controller/game import GameController def get_scene() scene = cocos.scene.Scene() model = GameModel() view = GameView(model) controller = GameController(model) return scene
#! /usr/bin/python3
import pygame
import GameView
import GameController
import GameMenu
import GameModel
import GameOptions
if __name__ == "__main__":
deep1 = input("Player1's deep: ")
deep2 = input("Player2's deep: ")
deep1 = int(deep1)
deep2 = int(deep2)
deep = (deep1, deep2)
pygame.mixer.pre_init(44100, -16, 2, 4096)
pygame.mixer.init()
pygame.init()
gameModel = GameModel.GameModel()
gameMenu = GameMenu.GameMenu()
gameView = GameView.GameView(gameMenu.screen, gameModel)
gameOptions = GameOptions.GameOptions(gameMenu.screen)
gameController = GameController.GameController(gameView, gameMenu,
gameOptions, deep)
gameController.main_menu()
import argparse
from GameController import *
# Main program logic follows:
if __name__ == '__main__':
# Process arguments
parser = argparse.ArgumentParser()
parser.add_argument('-c', '--clear', action='store_true', help='clear the display on exit')
args = parser.parse_args()
print ('Press Ctrl-C to quit.')
if not args.clear:
print('Use "-c" argument to clear LEDs on exit')
GAME_CONTROLLER = GameController() #create game controller object
try:
GAME_CONTROLLER.gameLoop()
except KeyboardInterrupt:
if args.clear:
GAME_CONTROLLER.gameOver()
#except:
#GAME_CONTROLLER.GameOver()
def start_game(self):
import GameController
GameController.GameController(self)
def letsPlay(self):
"""
Function to menage the game and the wigets like
functional buttons:
"HINT", "SKIP", "EXCHANGE ALL" "EXCHENGE ONE", "END MOVE"
and labels:
turn label, score label, information about points for letters
and visualisation of the player's rack.
:return: void - only creating tkinter wigets
"""
b = [['' for columns in range(15)]
for rows in range(15)] #represetation of the board
GameContr = GameController(self.root, self.mainframe, self.sack,
self.player1, self.player2)
board = BoardVisual(self.root, self.mainframe,
b) #visualization of the board
emptyLabel = Label(self.mainframe,
text=" ").grid(column=19,
row=1) #just for good placing
#fuctional buttons
skipB = Button(self.mainframe, text="SKIP", width=12)
skipB["command"] = lambda: GameContr.skip(PScoreLabel, ScoreLabel,
TurnLabel, PRackButtons)
exchangeAllB = Button(self.mainframe, text="EXCHANGE ALL", width=12)
exchangeAllB["command"] = lambda: GameContr.exchangeAll(PRackButtons)
exchangeOneB = Button(self.mainframe, text="EXCHANGE ONE", width=12)
exchangeOneB["command"] = lambda: GameContr.exchangeOne(
PRackButtons, board.board, exchangeAllB, exchangeOneB, skipB)
hintButton = Button(self.mainframe,
text="HINT",
width=12,
state="disabled")
hintButton["command"] = lambda: GameContr.hint(
board, PScoreLabel, ScoreLabel, TurnLabel, PRackButtons)
endMoveButton = Button(self.mainframe, text="END MOVE", width=12)
endMoveButton["command"] = lambda: GameContr.endTurn(
PScoreLabel, ScoreLabel, TurnLabel, PRackButtons, board.board,
hintButton, exchangeAllB, exchangeOneB, skipB)
skipB.grid(column=20, row=7)
exchangeAllB.grid(column=20, row=8)
exchangeOneB.grid(column=20, row=9)
hintButton.grid(column=20, row=10)
endMoveButton.grid(column=20, row=11)
#displaying who's turn it is and the score
TurnLabel = Label(self.mainframe,
text="IT'S " + str(self.player1.name).upper() +
"'S TURN")
PScoreLabel = Label(self.mainframe,
text=str(self.player1.name).upper() + "'S SCORE:")
ScoreLabel = Label(self.mainframe, text=str(self.player1.score))
TurnLabel.grid(column=20, row=2)
PScoreLabel.grid(column=20, row=3)
ScoreLabel.grid(column=21, row=3)
#displaying info about points for letters (letter=points)
infoL = Label(self.mainframe, text="POINTS\n" "FOR LETTERS:")
infoL.grid(column=30, row=1)
letters = Letters()
bag = letters.bag
i = 0
for key, val in bag.items():
if i <= 12:
LettersL = Label(self.mainframe,
text=str(key) + " = " + str(val[0]) + " ")
LettersL.grid(column=31, row=2 + i)
else:
LettersL = Label(self.mainframe,
text=str(key) + " = " + str(val[0]))
LettersL.grid(column=32, row=2 + i - 13)
i += 1
PRackButtons = [] #buttons representing player's rack
playerRack = self.player1.rack.getRack()
emptyL2 = Label(self.mainframe,
text=" ").grid(column=22, row=1) #just for placing
for i in range(len(playerRack)): #visualizing the rack
button = Button(self.mainframe,
height=3,
width=3,
bg="bisque",
fg="gray1",
text=str(playerRack[i]))
button.grid(column=23 + i, row=9)
PRackButtons.append(button)
for i in range(len(PRackButtons)
): #enable letters (buttons) to be moved to the board
PRackButtons[i]["command"] = lambda x=i: GameContr.makeMove(
x, board.board, PRackButtons, exchangeAllB, exchangeOneB, skipB
)
def createGameFrame(self, frame):
self.gameController = GameController(frame)
#add callback funtion so that user can return from game to main menu
self.gameController.addReturnCallBack(self.mainMenu)
def setUp(self):
self.gameController = GameController()
import GameController
import pygame
import numpy as np
if __name__ == '__main__':
pygame.init()
game = GameController.GameController()
game.main_game_loop()
#! /usr/bin/python3
import pygame
import GameView
import GameController
import GameMenu
import GameModel
if __name__ == "__main__":
pygame.mixer.pre_init(44100, -16, 2, 4096)
pygame.mixer.init()
pygame.init()
gameModel = GameModel.GameModel()
gameMenu = GameMenu.GameMenu()
gameView = GameView.GameView(gameMenu.screen, gameModel)
gameController = GameController.GameController(gameView, gameMenu)
gameController.main_menu()
import pygame
from time import sleep
wiringpi.wiringPiSetupGpio()
pygame.init()
TableConfig.setupPinModes()
SkeletonManager.setupPinModes()
JankyWindow.init()
LightBoard.init()
LightBoard.clearBoard()
soundManager = SoundManager.SoundManager()
lobbyController = LobbyController.LobbyController(soundManager)
gameController = GameController.GameController(soundManager)
SkeletonManager.skeletonDown()
soundManager.playLobbyMusic()
while True:
print("Start Lobby")
lobbyController.runLobby()
activeTableNumbers = lobbyController.activeTableNumbers
soundManager.stopMusic()
lobbyController.runStartingSequence()
print("Start Game")
soundManager.playGameMusic()
gameController.setupNewGameWithTableNumbers(activeTableNumbers)
gameController.runGame()
from GameController import *
g1 = GameController("gens.exe")
g1.startGame()
#Main application to test image viewer
import tkinter as tk
from tkinter import ttk
import TerminalFrame as tf
import ChatFrame as cf
import ServerFrame as sf
import GameController as gc
import KeyInfoFrame as kif
# CREATE THE CHALLENGE VARIABLE
gameController = gc.GameController()
root = tk.Tk()
root.geometry("800x500")
root.title("Central Intelligence Aggies")
tabControl = ttk.Notebook(root)
tab1 = ttk.Frame(tabControl)
terminalFrame = tf.TerminalFrame(tab1)
terminalFrame.setGC(gameController)
tab2 = ttk.Frame(tabControl)
chatFrame = cf.ChatFrame(tab2)
chatFrame.setGC(gameController)
tab3 = ttk.Frame(tabControl)
serverFrame = sf.ServerFrame(tab3)
serverFrame.setGC(gameController)
import sys
sys.path.append('../')
from GameController import *
from User import *
newGame = GameController()
player1 = User()
newGame.hostGame(player1, socket.gethostbyname(''), 10000)
#Images
images = {}
for image in [f for f in os.listdir("images\\") if f.endswith('.png')]:
key = image[0:len(image) - 4]
images[key] = pygame.image.load("images\\" + image).convert()
#SET TILE SIZE - Each tile must be same size for this system.
tileSize = 60
#Create fresh board
boards = []
for i in range(9):
if i % 3 == 0:
boards.append([])
boards[len(boards) - 1].append(
Board([[Square(row, col, images, i) for col in range(3)]
for row in range(3)], i % 3,
len(boards) - 1, images))
#Squares are objects respresented in a 2D array in each board.
#Squares are individually selected/playable spots
#Boards are objects represented in a 2D array in gamecontroller
#Boards are combination of squares that have a win condition
#Game controller is a combination of boards with a win conditon
#Start screen have options between 2-Player, AI
gc = GameController(boards) #Initialize gameController
gc.main_menu(screen) #Beginning start menu
while gc.playing:
gc.update(
screen
) #Update gamecontroller which updates the entire game including taking in input
