示例#1
0
    def __init__(self):
        pygame.init()

        self.manager = GameManager()
        self.enemy = Ai()

        pygame.display.set_caption("Tic Tac Toe")

        self.WIDTH = 540
        self.HEIGHT = 540
        self.screen = pygame.display.set_mode((self.WIDTH, self.HEIGHT))

        self.background = pygame.Surface((self.WIDTH, self.HEIGHT))
        self.background.fill(pygame.Color('#E3E3E3'))

        # FONTS
        self.playerFont = pygame.font.SysFont('arial', 70)
        self.resultFont = pygame.font.SysFont('arial', 60, bold=True)
        self.infoFont = pygame.font.SysFont('arial', 30, italic=True)

        # define cell dimensions
        self.cellWidth = self.WIDTH / 3
        self.cellHeight = self.HEIGHT / 3
        self.board = []

        # to create the 3x3 grid
        for i in range(3):
            for j in range(3):
                self.board.append(
                    Cell(self.cellWidth * i, self.cellHeight * j, self.cellWidth, self.cellHeight))

        self.manager.gameState = 'progress'

        self.running = True
示例#2
0
def setup_hotseat_game(players: {str: Player}):
    g = GameManager([players["Arva"], players["Buroad"]])
    player_controllers = [
        EncounterAiPlayerController(g, 0),
        LocalTextPlayerController(g, 1)
    ]
    return (g, player_controllers)
示例#3
0
def setup_encounter_game(players: {str: Player}):
    #setup the game management
    g = GameManager([players["Pack of Lupoforms"], players["Arva"]])
    player_controllers = [
        EncounterAiPlayerController(g, 0),
        LocalTextPlayerController(g, 1)
    ]
    return (g, player_controllers)
示例#4
0
文件: main.py 项目: Fat4eyes/Sapper
def main():
    app = QApplication(sys.argv)
    engine = QQmlApplicationEngine()
    width = 15
    height = 15
    gameManager = GameManager(width, height, 50)
    engine.rootContext().setContextProperty("gameManager", gameManager)
    engine.load('Views/Window.qml')
    window = engine.rootObjects()[0]
    window.setProperty("title", "Sapper")
    window.setProperty("width", width * 50 + 90)
    window.setProperty("height", height * 50 + 140)
    window.show()
    sys.exit(app.exec_())
示例#5
0
def setup():
    global client
    client = paho.Client(client_id="client-1",
                         clean_session=True,
                         userdata=None,
                         protocol=paho.MQTTv31)
    client.on_subscribe = on_subscribe
    client.on_message = on_message
    client.username_pw_set("stef", "stef")
    client.connect("rasberrypi.ddns.net", port=1883, keepalive=60)
    client.subscribe("project/#", qos=1)
    global gameManagerInstance
    if gameManagerInstance is None:
        gameManagerInstance = GameManager(client)
示例#6
0
class PlayMode(Runnable):
  def __init__(self):
    Runnable.__init__(self)
    self.gameManager = GameManager()
    self.statusViewers = [UnitStatusViewer(base, BASE_DEFAULT_HP, (700, 50 + i * 50)) for i, base in enumerate(self.gameManager.bases)] +\
                         [UnitStatusViewer(unit, UNIT_DEFAULT_HP, (700, 250 + i * 50)) for i, unit in enumerate(self.gameManager.units)]
  def step(self):
    self.gameManager.step()
    for statusViewer in self.statusViewers:
      statusViewer.step()
  def isValid(self):
    return self.gameManager.isValid()
  def draw(self, screen):
    screen.fill((0, 0, 0))
    self.gameManager.draw(Image(screen.getSurface().subsurface(((0, 0), (600, 600)))))
    for statusViewer in self.statusViewers:
      statusViewer.draw(screen)
  def end(self):
    self.gameManager.end()
    for statusViewer in self.statusViewers:
      statusViewer.end()
示例#7
0
    def __init__(self, parent):
        super().__init__(parent)

        logFile = "errors.log"
        logging.basicConfig(filename=logFile, level=logging.DEBUG)

        self._controller = GameController()
        self._screenreader = SpeechUtil()
        self._zoneOptions = ("hand", "land", "creatures", "other spells",
                             "graveyard", "exile", "library")
        self._zones = (self._controller.player.hand,
                       self._controller.player.lands,
                       self._controller.player.creatures,
                       self._controller.player.otherSpells,
                       self._controller.player.graveyard,
                       self._controller.player.exile,
                       self._controller.player.library)
        self._commandParser = CommandParser(self, self._controller,
                                            self._screenreader)
        self._zoneTree = ZoneTree()
        self._commandInput = CommandInputBox()
        self._commandOutput = CommandOutputBox()
        self._gameManager = GameManager(self, self._controller, self._zoneTree,
                                        self._screenreader)
        self._sizer = wx.BoxSizer(wx.VERTICAL)

        # Create the UI elements
        self._zoneTree.createZoneTree(self, self._zoneOptions, self._zones,
                                      "Zones", self._screenreader)
        self._commandInput.createCommandInputBox(self, wx.TE_PROCESS_ENTER,
                                                 "Command:",
                                                 self._screenreader,
                                                 self._commandParser,
                                                 self._commandOutput)
        self._commandOutput.createCommandOutputBox(self, "Output",
                                                   self._screenreader)

        self._zoneTree.SetSelection(1)

        panelShortcuts = []
        zoneTreeShortcuts = []

        # Panel keyboard shortcuts
        panelShortcuts.append(
            self.createShortcut(
                wx.NewId(),
                (lambda event: self._screenreader.nextSpeechHistory()),
                keys=wx.WXK_PAGEDOWN))
        panelShortcuts.append(
            self.createShortcut(
                wx.NewId(),
                (lambda event: self._screenreader.previousSpeechHistory()),
                keys=wx.WXK_PAGEUP))
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.loadDeckMenu,
                                mods=wx.ACCEL_CTRL,
                                keys=ord("L")))
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.createToken,
                                mods=wx.ACCEL_CTRL,
                                keys=ord("K")))
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.shuffle,
                                mods=wx.ACCEL_CTRL,
                                keys=ord("H")))
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.draw,
                                mods=wx.ACCEL_CTRL,
                                keys=ord("D")))
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.drawHand,
                                mods=wx.ACCEL_CTRL | wx.ACCEL_SHIFT,
                                keys=ord("D")))
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.cleanup,
                                mods=wx.ACCEL_CTRL | wx.ACCEL_SHIFT,
                                keys=ord("C")))
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.untapBattlefield,
                                mods=wx.ACCEL_CTRL,
                                keys=ord("U")))
        # view hand
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.viewHand,
                                mods=wx.ACCEL_CTRL,
                                keys=ord("1")))
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.viewVerboseHand,
                                mods=wx.ACCEL_CTRL | wx.ACCEL_SHIFT,
                                keys=ord("1")))
        # view lands
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.viewLands,
                                mods=wx.ACCEL_CTRL,
                                keys=ord("2")))
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.viewVerboseLands,
                                mods=wx.ACCEL_CTRL | wx.ACCEL_SHIFT,
                                keys=ord("2")))
        # view creatures
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.viewCreatures,
                                mods=wx.ACCEL_CTRL,
                                keys=ord("3")))
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.viewVerboseCreatures,
                                mods=wx.ACCEL_CTRL | wx.ACCEL_SHIFT,
                                keys=ord("3")))
        # view Other Spells
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.viewOtherSpells,
                                mods=wx.ACCEL_CTRL,
                                keys=ord("4")))
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.viewVerboseOtherSpells,
                                mods=wx.ACCEL_CTRL | wx.ACCEL_SHIFT,
                                keys=ord("4")))
        # view graveyard
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.viewGraveyard,
                                mods=wx.ACCEL_CTRL,
                                keys=ord("5")))
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.viewVerboseGraveyard,
                                mods=wx.ACCEL_CTRL | wx.ACCEL_SHIFT,
                                keys=ord("5")))
        # view exile
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.viewExile,
                                mods=wx.ACCEL_CTRL,
                                keys=ord("6")))
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.viewVerboseExile,
                                mods=wx.ACCEL_CTRL | wx.ACCEL_SHIFT,
                                keys=ord("6")))
        # view library
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.viewLibrary,
                                mods=wx.ACCEL_CTRL,
                                keys=ord("7")))
        panelShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.viewVerboseLibrary,
                                mods=wx.ACCEL_CTRL | wx.ACCEL_SHIFT,
                                keys=ord("7")))

        # Zone Tree keyboard shortcuts
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.autoMove,
                                keys=wx.WXK_RETURN))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.moveToGraveyard,
                                keys=wx.WXK_BACK))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.moveToExile,
                                mods=wx.ACCEL_SHIFT,
                                keys=wx.WXK_BACK))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.moveToHand,
                                mods=wx.ACCEL_SHIFT,
                                keys=wx.WXK_RETURN))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.moveToLibrary,
                                mods=wx.ACCEL_CTRL,
                                keys=wx.WXK_RETURN))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.getCardManaCost,
                                keys=ord("1")))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.getCardPowerAndToughness,
                                keys=ord("2")))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.getCardText,
                                keys=ord("3")))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.getCardType,
                                keys=ord("4")))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.getCardFlavor,
                                keys=ord("5")))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.getCardRarity,
                                keys=ord("6")))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.getCardRulings,
                                keys=ord("7")))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.getCardPrintings,
                                keys=ord("8")))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.getCardWatermark,
                                keys=ord("9")))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.getCardLoyalty,
                                keys=ord("0")))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.viewCard,
                                keys=ord("V")))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.addCounter,
                                keys=ord(">")))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.subtractCounter,
                                keys=ord("<")))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.addPlus1Counter,
                                mods=wx.ACCEL_CTRL,
                                keys=ord(">")))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.subtractPlus1Counter,
                                mods=wx.ACCEL_CTRL | wx.ACCEL_SHIFT,
                                keys=ord(">")))

        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.addMinus1Counter,
                                mods=wx.ACCEL_CTRL,
                                keys=ord("<")))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.subtractMinus1Counter,
                                mods=wx.ACCEL_CTRL | wx.ACCEL_SHIFT,
                                keys=ord("<")))

        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.toggleTappedState,
                                keys=wx.WXK_SPACE))
        zoneTreeShortcuts.append(
            self.createShortcut(wx.NewId(),
                                self._gameManager.transformCard,
                                mods=wx.ACCEL_CTRL,
                                keys=ord("T")))

        self._panelKeyTable = wx.AcceleratorTable(panelShortcuts)
        self._zoneTreeKeyTable = wx.AcceleratorTable(zoneTreeShortcuts)
        self.SetAcceleratorTable(self._panelKeyTable)
        self._zoneTree.SetAcceleratorTable(self._zoneTreeKeyTable)
        self._sizer.Add(self._zoneTree, 1, wx.SHAPED, 0)
        self._sizer.Add(self._commandInput, 1, wx.SHAPED, 0)
        self._sizer.Add(self._commandOutput, 4, wx.EXPAND | wx.ALIGN_BOTTOM, 0)

        self._sizer.SetSizeHints(self)
        self.SetSizer(self._sizer)
        self._commandOutput.Bind(wx.EVT_KEY_DOWN, self.onKeyDownInOutput)
示例#8
0
import pygame
from gameManager import GameManager

pygame.init()
screenSize = (400, 400)
surface = pygame.display.set_mode(screenSize)

theGame = GameManager(surface)

clock = pygame.time.Clock()

while True:
    clock.tick(30)

    theGame.draw()
    theGame.doTurn()
示例#9
0
文件: main.py 项目: Greymerk/PyChess
import pygame
from gameManager import GameManager


pygame.init()
screenSize = (640, 640)
surface = pygame.display.set_mode(screenSize)

theGame = GameManager(surface)

clock = pygame.time.Clock()

while True:
    clock.tick(30)
    
    theGame.draw()    
    theGame.doTurn()
示例#10
0
    def __init__(self):

        self.manager = GameManager()
示例#11
0
class Ai:
    def __init__(self):

        self.manager = GameManager()

    def minimax(self, board, OPlayer, alpha, beta, depth=float('inf')):
        # return the static evaluation of the final possible game
        # X wins: -1
        # O wins: +1
        # tie: 0

        if depth == 0 or self.manager.checkWin(board) or self.manager.checkTie(
                board):
            if self.manager.checkWin(board, True) == 'X':
                return -1
            elif self.manager.checkWin(board, True) == 'O':
                return 1
            elif self.manager.checkTie(board):
                return 0
            else:
                # depth not working properly
                return 0

        if OPlayer:
            maxValue = float('-inf')
            for cell in board:
                if cell.state == '':
                    cell.state = 'O'
                    value = self.minimax(board,
                                         False,
                                         alpha,
                                         beta,
                                         depth=depth - 1)
                    cell.state = ''
                    maxValue = max(maxValue, value)
                    alpha = max(alpha, value)
                    if beta <= alpha:
                        break

            return maxValue

        if OPlayer == False:
            minValue = float('inf')
            for cell in board:
                if cell.state == '':
                    cell.state = 'X'
                    value = self.minimax(board,
                                         True,
                                         alpha,
                                         beta,
                                         depth=depth - 1)
                    cell.state = ''
                    minValue = min(minValue, value)
                    beta = min(beta, value)
                    if beta <= alpha:
                        break
            return minValue

    def play(self, board):
        # choose a cell to play

        # initializing move to store the best cell to move
        bestCell = None
        bestScore = float('-inf')

        for cell in board:
            if cell.state == '':
                cell.state = 'O'
                score = self.minimax(board, False, float('-inf'), float('inf'))
                cell.state = ''

                if score > bestScore:
                    bestScore = score
                    bestCell = cell

        bestCell.changeState('O')
示例#12
0
文件: main.py 项目: Greymerk/PyTTT
'''
Created on April 12, 2014

@author: Clayton
'''

import pygame
pygame.init()
screenSize = (320, 318)
surface = pygame.display.set_mode(screenSize)


from display import Display 
from gameManager import GameManager

gameManager = GameManager()
display = Display(gameManager)

clock = pygame.time.Clock()

winner = None
while winner is None:
	clock.tick(30)
	winner = gameManager.doTurn()
	display.draw(surface)	

if winner:
	print "You Won!"
else:
	print 'You Lost!'
示例#13
0
print("Starting score tracker...")
from scoreTracker import ScoreTracker

scoreTracker = ScoreTracker()

# Now we can start up the display with a disover sequence
print("Discovering initial clients...")
game.discover_clients()

# Prepare for game loop
import sys
from time import sleep
from screenRenderer import ScreenRenderer
from gameManager import GameManager

manager = GameManager(game, scoreTracker)
renderer = ScreenRenderer(screen, manager)

# State variables for game stuffs
from communication.utils import *

lastTick = millis()

# Start game loop
print("Starting game loop...")
gameRunning = True
maxRenderTime = 0
timesOver1s = 0


def closeAll():
示例#14
0
class MainGUI:
    def __init__(self):
        pygame.init()

        self.manager = GameManager()
        self.enemy = Ai()

        pygame.display.set_caption("Tic Tac Toe")

        self.WIDTH = 540
        self.HEIGHT = 540
        self.screen = pygame.display.set_mode((self.WIDTH, self.HEIGHT))

        self.background = pygame.Surface((self.WIDTH, self.HEIGHT))
        self.background.fill(pygame.Color('#E3E3E3'))

        # FONTS
        self.playerFont = pygame.font.SysFont('arial', 70)
        self.resultFont = pygame.font.SysFont('arial', 60, bold=True)
        self.infoFont = pygame.font.SysFont('arial', 30, italic=True)

        # define cell dimensions
        self.cellWidth = self.WIDTH / 3
        self.cellHeight = self.HEIGHT / 3
        self.board = []

        # to create the 3x3 grid
        for i in range(3):
            for j in range(3):
                self.board.append(
                    Cell(self.cellWidth * i, self.cellHeight * j, self.cellWidth, self.cellHeight))

        self.manager.gameState = 'progress'

        self.running = True

    def displayGrids(self):

        # horizontal lines
        for i in range(2):
            # pygame.draw.line(surface, color, start_pos, end_pos, width = 1)
            start_pos = (0, int(self.cellHeight * (i + 1)))
            end_pos = (self.WIDTH, int(self.cellHeight * (i + 1)))
            pygame.draw.line(self.background, (0, 0, 0),
                             start_pos, end_pos, 2)

        # vertical lines
        for i in range(2):
            # pygame.draw.line(surface, color, start_pos, end_pos, width = 1)
            start_pos = (int(self.cellWidth * (i + 1)), 0)
            end_pos = (int(self.cellWidth * (i + 1)), self.HEIGHT)
            pygame.draw.line(self.background, (0, 0, 0),
                             start_pos, end_pos, 2)

        for cell in self.board:
            player = self.playerFont.render(cell.state, True, (0, 0, 0))
            x, y = self.playerFont.size(cell.state)
            self.screen.blit(
                player, (int((cell.x + cell.w / 2) - x / 2), int((cell.y + cell.h / 2) - y / 2)))

    def endGameMsg(self, result):
        # rectangle that the message will be drawn
        w = self.WIDTH
        h = 150
        x = 0
        y = int(self.HEIGHT / 2 - h / 2)

        pygame.draw.rect(self.screen, pygame.Color(
            '#4D4D4D'), pygame.Rect(x, y, w, h))

        # result text
        if self.manager.result == 'tie':
            resultText = "It's a tie!"
            result = self.resultFont.render(resultText, True, (0, 0, 0))
        else:
            resultText = f"{self.manager.result} won!"
            result = self.resultFont.render(resultText, True, (0, 0, 0))

        x, y_txt = self.resultFont.size(resultText)

        self.screen.blit(result, (int(w / 2 - x / 2), int(y + 5)))

        # info text
        infoText = "Press R to restart the game!"
        info = self.infoFont.render(infoText, True, (0, 0, 0))

        x, y_txt = self.infoFont.size(infoText)

        self.screen.blit(info, (int(w / 2 - x / 2), int(y + 100)))

    def run(self):
        while self.running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.running = False

                # check mouse down
                if event.type == pygame.MOUSEBUTTONDOWN:
                    if self.manager.gameState == 'progress':
                        for cell in self.board:
                            if self.manager.currentPlayer == 'X' and cell.checkUserCLicked(pygame.mouse.get_pos()) and cell.state == '':
                                # cause the O player is the AI
                                cell.changeState('X')
                                self.manager.changeTurn()

                # check keys pressed
                if event.type == pygame.KEYDOWN:
                    # restart the game
                    if event.key == pygame.K_r and self.manager.gameState == 'over':
                        self.manager.currentPlayer = 'X'
                        for cell in self.board:
                            cell.state = ''
                        self.manager.gameState = 'progress'

                    # recolorize the background
                    self.background.fill(pygame.Color('#ffffff'))

            # to check if there's a win
            if self.manager.checkWin(self.board):
                self.manager.currentPlayer = ''
                self.manager.gameState = 'over'
                self.manager.result = self.manager.checkWin(self.board, True)

            # to check if there's a tie
            if self.manager.checkTie(self.board):
                self.manager.currentPlayer = ''
                self.manager.gameState = 'over'
                self.manager.result = 'tie'

            # check if it's AI turn
            if self.manager.currentPlayer == 'O' and self.manager.gameState == 'progress':
                self.enemy.play(self.board)
                self.manager.changeTurn()

            # UI
            self.screen.blit(self.background, (0, 0))

            if self.manager.gameState == 'over':
                # if tie, paint te background gray
                if self.manager.result == 'tie':
                    self.background.fill(pygame.Color('#9DA897'))
                elif self.manager.result == 'X':
                    self.background.fill(pygame.Color('#7AFF77'))
                elif self.manager.result == 'O':
                    self.background.fill(pygame.Color('#F53920'))

                self.displayGrids()
                self.endGameMsg(self.manager.result)

            if self.manager.gameState != 'over':
                self.displayGrids()

            pygame.display.update()
示例#15
0
for n in range(5):
    enemyShip = pygame.image.load('../assets/enemyShip00.png')
    enemyShip = pygame.transform.scale(enemyShip, (32, 32))
    randomSpeed = random.randint(50, 250)
    randomPosX = random.randint(64, width - 64)
    e = Enemy(enemyShip, [randomPosX, -64], display, randomSpeed)
    game_objects.append(e)

backgroundClouds = pygame.image.load('../assets/clouds00.png')
playerShip = pygame.transform.scale(playerShip, (width, height * 2))
# projectile = Projectile(projectileImg, [64, -128], display, 50, DEEP_BLUE)
#
# game_objects.append(projectile)
bgPosy = -600
bgPosy2 = -1200
game_manager = GameManager(game_objects, display)
# main loop

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
            print(event)

    t = pygame.time.get_ticks()
    deltaTime = (t - getTicksLastFrame) / 1000.0
    getTicksLastFrame = t

    gameDisplay.fill(WARM_WHITE)
    bgPosy += deltaTime * 200
    bgPosy2 += deltaTime * 200
示例#16
0
import asyncio
import uuid
from uuid import UUID

import sanic
from Chessnut.game import InvalidMove
from sanic import response
from sanic.request import Request
from websockets.protocol import WebSocketCommonProtocol
from classes import ChessGame, GameOptions
from config import baseurl, default_port
from gameManager import GameManager

app = sanic.Sanic(name="Neos Chess Websocket")
gm = GameManager()


@app.route(f"{baseurl}/newgame", methods=["POST"])
async def new_game(request: Request):
    """
    takes body json for the ai's piece color, and the AI's difficulty, as in `{'ai_is_white': false, 'ai_diff': 10}`
    """
    opts = GameOptions(**request.json)

    uid = uuid.uuid4()
    gm.start_game(uid, opts)
    move = ""
    if opts.ai_is_white:
        move = await gm.do_ai_move(uid)
    return response.text(f"{uid} {move}")
示例#17
0
print("Starting score tracker...")
from scoreTracker import ScoreTracker

scoreTracker = ScoreTracker()

# Now we can start up the display with a disover sequence
print("Discovering initial clients...")
game.discover_clients()

# Prepare for game loop
import sys
from time import sleep
from screenRenderer import ScreenRenderer
from gameManager import GameManager

manager = GameManager(game, scoreTracker)
renderer = ScreenRenderer(screen, manager)

# State variables for game stuffs
from communication.utils import *

lastTick = millis()

# Start game loop
print("Starting game loop...")
gameRunning = True
maxRenderTime = 0
timesOver1s = 0

def closeAll():
    print("Close requested")
def main():
    tk = Tk()
    tk.title('Snake')
    tk.resizable(0, 0)
    tk.wm_attributes('-topmost', 1)

    manager = GameManager()
    settings = GameSettings()

    canvas = Canvas(tk,
                    width=settings.width,
                    height=settings.height,
                    bd=0,
                    highlightthickness=0,
                    background='black')
    canvas.pack()

    textLabel = Label(
        tk, text='Press ENTER to begin.\nPress ESCAPE at anytime to exit.')
    textLabel.pack()

    tk.update()

    canvas.bind_all("<Return>", manager.startGame)
    canvas.bind_all("<space>", manager.pauseGame)
    canvas.bind_all("<Escape>", manager.closeGame)

    while manager.gameRunning:
        while manager.inStartMenu:
            if not manager.gameRunning:
                break
            tk.update_idletasks()
            tk.update()
            sleep(settings.gameSpeed)

        canvas.delete("all")

        food = Food(canvas, settings)
        manager.foodPlaced = False
        snake = Snake(canvas, settings)
        textID = canvas.create_text(
            settings.width - 45,
            20,
            text=f'Segments: {str(len(snake.segments))}',
            fill='yellow')

        while not manager.inStartMenu:
            if not manager.gameRunning:
                break
            elif manager.gameOver:
                manager.inStartMenu == True
            elif not manager.gamePaused:
                textLabel.configure(text='Press SPACE to pause game!')
                gameLoop(tk, canvas, manager, settings, snake, food)
                canvas.itemconfig(textID,
                                  text=f'Segments: {str(len(snake.segments))}')
            else:
                textLabel.configure(text='GAME PAUSED!')
                tk.update_idletasks()
                tk.update()
                sleep(settings.gameSpeed)
        textLabel.configure(
            text='GAME OVER!\nPress ENTER to start a new game!')
    tk.destroy()
示例#19
0
def main():
    GameManager()
示例#20
0
#!/usr/bin/python3.6
#coding:utf-8
from gameManager import GameManager
import sys

if __name__ == '__main__':
    gm = GameManager()

    if len(sys.argv) > 1:
        if sys.argv[1] == "False":
            sys.argv[1] = False
        elif sys.argv[1] == "True":
            sys.argv[1] = True
        else:
            sys.argv[1] = None

    if len(sys.argv) == 2:
        gm.start(sys.argv[1])
    elif len(sys.argv) == 3:
        gm.start(sys.argv[1], int(sys.argv[2]))
    else:
        gm.start()
示例#21
0
 def __init__(self):
   Runnable.__init__(self)
   self.gameManager = GameManager()
   self.statusViewers = [UnitStatusViewer(base, BASE_DEFAULT_HP, (700, 50 + i * 50)) for i, base in enumerate(self.gameManager.bases)] +\
                        [UnitStatusViewer(unit, UNIT_DEFAULT_HP, (700, 250 + i * 50)) for i, unit in enumerate(self.gameManager.units)]