def _handle_beatsaber_event(self, event): if event["event"] == "songStart": self._current_score = ScoreKeeper(player_name=self._current_player, advanced=True) self._current_songdata = { "meta": { "songStartLocal": time.time(), "player": self._current_player, }, "events": [], } print("Player %s started %s - %s (%s)" % (self._current_player, event["status"]["beatmap"]["songAuthorName"], event["status"]["beatmap"]["songName"], event["status"]["beatmap"]["difficulty"])) if self._current_songdata is not None: self._current_songdata["events"].append(event) if self._current_score is not None: if self._current_score.process(event): self._local_server.change_event() if (self._current_songdata is not None) and ( (event["event"] == "finished") or (event["event"] == "failed")): self._finish_song() self._current_score = None self._local_server.change_event()
def setup(self, startWindow=None, playerName=None): self.score = 0 self.scoreKeeper = ScoreKeeper() self.scoreKeeper.setFile('snakeScore.txt') self.params = GameParams() # To be filled by user input width = 800 height = 600 font = sf.Font.from_file("rust.ttf") if startWindow is None: # startWindow is None unless this is a restart startWindow = sf.RenderWindow(sf.VideoMode(width, height), "Snake") startWindow.framerate_limit = 60 startWindow.clear(sf.Color.BLACK) #Display Welcome welcomeText = utils.drawText(startWindow, string="Snake", size=60, font=font, position='center') startWindow.display() while(True): setup = False for event in startWindow.events: if type(event) is sf.CloseEvent: exit() elif (type(event) is sf.MouseButtonEvent or type(event) is sf.KeyEvent): setup = True if setup: break #TODO Choose PlayerName if playerName is None: playerName = utils.textInput(startWindow, "Enter Name:", font, maxLength=10) self.params.setPlayerName(playerName) #Choose Difficulty difficulty = utils.selectOptions(startWindow, ["Easy", "Medium", "Hard"], [0, 1, 2], font) frameRates = [20, 25, 30] self.params.setDifficulty(difficulty) self.params.setFrameRate(frameRates[difficulty]) #Choose Board Size boardSize = utils.selectOptions(startWindow, ["Small", "Medium", "Large"], [(40,30), (50,40), (60,50)], font) self.params.setBoardSize(boardSize) self.params.setSquareSize(15) self.params.setFont(font) self.snake = Snake(5, self.params.squareSize, sf.Vector2(10,10)) self.board = Board(width=self.params.boardWidth, height=self.params.boardHeight, squareSize=self.params.squareSize, frameRate=self.params.frameRate) self.board.initSnake(self.snake) startWindow.close() self.playGame()
def __init__(self): score = ScoreKeeper() grid = ColorGrid(GameConstants.instance().get("gridSize")) gameData = {} gameData["grid"] = grid gameData["score"] = score self.gameData = gameData self.currentState = ReadyState(gameData)
def _parse_history(self, filename): if filename.endswith(".gz"): with gzip.open(filename) as f: history = json.load(f) else: with open(filename) as f: history = json.load(f) sk = ScoreKeeper(advanced=True) sk.process_all(history["events"]) if sk.gamehash is None: print("No gamehash: %s" % (filename)) else: player = history["meta"]["player"] starttime_local_timet = history["meta"]["songStartLocal"] self.add_scorekeeper_results( player=player, starttime_local_timet=starttime_local_timet, scorekeeper=sk)
def print_scores(): singleton = ScoreKeeper.get_instance() scores = singleton.get_scores() for score in sorted(scores): print '{0} = {1}'.format(score, scores[score]) print '----------'
def __init__(self, log_file, cache_pull_mode, server, db): self.keeper = ScoreKeeper(db) self.secret_id = "SECRET PASSWORD LOL HOORAY" self.log_file = log_file self.cache_pull_mode = cache_pull_mode self.invalidate_cache = True ServerFunctions.__init__(self, server) if (self.cache_pull_mode): self.update_cache() self.invalidate_cache = False
class BeatSaberHistorian(): def __init__(self, config, args): self._config = config self._args = args self._current_player = None self._current_songdata = None self._connected_to_beatsaber = False self._current_score = None self._score_change = asyncio.Event() self._db = HistorianDatabase(self._config) self._local_server = LocalCommunicationServer(self) @property def config(self): return self._config @property def current_player(self): return self._current_player @current_player.setter def current_player(self, new_player): if new_player != self._current_player: self._current_player = new_player print("Player changed: %s" % (new_player)) self._local_server.change_event() @property def connected_to_beatsaber(self): return self._connected_to_beatsaber @property def current_score(self): return self._current_score @property def db(self): return self._db def _finish_song(self): now = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S") destination_filename = self._config["history_directory"] + "/" + ( self._current_player if (self._current_player is not None) else "unknown_player") + "/" + now + ".json.gz" with contextlib.suppress(FileExistsError): os.makedirs(os.path.dirname(destination_filename)) with gzip.open(destination_filename, "wt") as f: json.dump(self._current_songdata, f) f.write("\n") os.sync() self._db.add_scorekeeper_results( self._current_songdata["meta"]["player"], self._current_songdata["meta"]["songStartLocal"], self._current_score) self._db.mark_file_seen(destination_filename) self._current_songdata = None def _handle_beatsaber_event(self, event): if event["event"] == "songStart": self._current_score = ScoreKeeper(player_name=self._current_player, advanced=True) self._current_songdata = { "meta": { "songStartLocal": time.time(), "player": self._current_player, }, "events": [], } print("Player %s started %s - %s (%s)" % (self._current_player, event["status"]["beatmap"]["songAuthorName"], event["status"]["beatmap"]["songName"], event["status"]["beatmap"]["difficulty"])) if self._current_songdata is not None: self._current_songdata["events"].append(event) if self._current_score is not None: if self._current_score.process(event): self._local_server.change_event() if (self._current_songdata is not None) and ( (event["event"] == "finished") or (event["event"] == "failed")): self._finish_song() self._current_score = None self._local_server.change_event() async def _connect_beatsaber(self): uri = self._config["beatsaber_websocket_uri"] while True: try: async with websockets.connect(uri) as websocket: print("Connection to BeatSaber established at %s" % (uri)) self._connected_to_beatsaber = True while True: msg = await websocket.recv() msg = json.loads(msg) self._handle_beatsaber_event(msg) except (OSError, ConnectionRefusedError, websockets.exceptions.ConnectionClosed) as e: if self._connected_to_beatsaber: if self._current_songdata is not None: print( "Disconnected from BeatSaber: %s - %s; warning: data of current song is lost." % (e.__class__.__name__, str(e))) else: print("Disconnected from BeatSaber: %s - %s" % (e.__class__.__name__, str(e))) self._current_songdata = None self._connected_to_beatsaber = False await asyncio.sleep(1) async def _connect_heartrate_monitor(self): socket = self._config["heartrate_monitor"] while True: await asyncio.sleep(1) def start(self): loop = asyncio.get_event_loop() loop.create_task(self._local_server.create_server()) loop.create_task(self._connect_beatsaber()) if self._config.has("heartrate_monitor"): loop.create_task(self._connect_heartrate_monitor()) try: loop.run_forever() except KeyboardInterrupt: with contextlib.suppress(FileNotFoundError): os.unlink(self._config["unix_socket"])
class ObelixServerFunctions(ServerFunctions): """Implements all the functions of the frontend Obelix servers. ObelixServer supports both server-push and client-pull mode. Server-push mode has been deprecated for Lab #2. Arguments: log_file -- Opened file for logging output (deprecated). server -- The active server object implementing these methods. db -- (ip, port) tuple which is the address of the database server. """ def __init__(self, log_file, cache_pull_mode, server, db): self.keeper = ScoreKeeper(db) self.secret_id = "SECRET PASSWORD LOL HOORAY" self.log_file = log_file self.cache_pull_mode = cache_pull_mode self.invalidate_cache = True ServerFunctions.__init__(self, server) if (self.cache_pull_mode): self.update_cache() self.invalidate_cache = False def update_cache(self): self.keeper.update_cache() def get_medal_tally(self, team_name, client_id): """Returns current medal tally for a given team via RPC to ScoreKeeper. Always called by Pygmy.com on behalf of a requesting client. First increments internal event count in vector clock. ScoreKeeper returns tally and vector clock of DB. Syncs with DB vector clock before returning tally. Arguments: team_name -- String for one of the Olympic teams. client_id -- Unique string ID of the initial requesting client (used for raffle). """ medal_tally = self.keeper.get_medal_tally(team_name, client_id) return medal_tally def increment_medal_tally(self, team_name, medal_type, password): """Increments the medal tally for a given team via RPC to ScoreKeeper. Always called by Pygmy.com on behalf of Cacofonix. Pushes update to all clients in server-push mode (deprecated). Arguments: team_name -- String for one of the Olympic teams. medal_type -- String for the type of medal to increment. password -- Unique password only known by Cacofonix (hopefully). """ if password != self.secret_id: return "Unauthorized entry attempt." ack = self.keeper.increment_medal_tally(team_name, medal_type, self.get_timestamp(), self.invalidate_cache) #self.push_update_for_team(self.keeper.get_registered_clients_for_team(team_name), team_name) return ack def get_score(self, event_type, client_id): """Returns the current score for a given event via RPC to ScoreKeeper. Always called by Pygmy.com on behalf of a requesting client. First increments internal event count in vector clock. ScoreKeeper returns tally and vector clock of DB. Syncs with DB vector clock before returning tally. Arguments: event_type -- String for one of the Olympic events. client_id -- Unique string ID of the requesting client (used for raffle). """ score = self.keeper.get_score(event_type, client_id) return score def set_score(self, event_type, score, password): """Sets the score for a given event via RPC to ScoreKeeper. Always called by Pygmy.com on behalf of Cacofonix. Pushes update to all clients in server-push mode (deprecated). Arguments: event_type -- String for one of the Olympic events. score -- String for the updated score. password -- Unique password only known by Cacofonix (hopefully). """ if password != self.secret_id: return "Unauthorized entry attempt." ack = self.keeper.set_score(event_type, score, self.get_timestamp(), self.invalidate_cache) #self.push_update_for_event(self.keeper.get_registered_clients_for_event(event_type), event_type) return ack # -------------------------------------------------------------------- # All functions below are for server-push mode (deprecated for Lab #2). # -------------------------------------------------------------------- def register_client(self, client_id, events, teams): return self.keeper.register_client(client_id, events, teams) def push_update_for_event(self, clients, event_type): if len(clients)==0: return 0 self.log_file.write("----PUSHING NEW EVENT UPDATE: %s----\n"%time.strftime("%d %b %Y %H:%M:%S", time.gmtime())) time_of_update = time.time() # Measure latency for client_id in clients: client_ip, client_port = client_id s = xmlrpclib.ServerProxy("http://%s:%d"%(client_ip, client_port)) try: s.print_score_for_event(self.keeper.get_score(event_type), time_of_update) self.log_file.write("Successfully reached http://%s:%d\n"%(client_ip, client_port)) except socket.error as err: self.log_file.write("Unable to reach http://%s:%d, unsubscribing.\n"%(client_ip, client_port)) self.keeper.unregister_client(client_id) return 1 def push_update_for_team(self, clients, team_name): if len(clients)==0: return 0 self.log_file.write("----PUSHING NEW EVENT UPDATE: %s----\n"%time.strftime("%d %b %Y %H:%M:%S", time.gmtime())) time_of_update = time.time() # Measure latency for client_id in clients: client_ip, client_port = client_id s = xmlrpclib.ServerProxy("http://%s:%d"%(client_ip, client_port)) try: s.print_medal_tally_for_team(self.keeper.get_medal_tally(team_name), time_of_update) self.log_file.write("Successfully reached http://%s:%d\n"%(client_ip, client_port)) except socket.error as err: self.log_file.write("Unable to reach http://%s:%d, unsubscribing.\n"%(client_ip, client_port)) self.keeper.unregister_client(client_id) return 1
def setup(self, startWindow=None, playerName=None): self.params = GameParams() # To be filled by user input # Set up scorekeeping self.score = 0 self.scoreKeeper = ScoreKeeper() self.scoreKeeper.setFile('asteroidScore.txt') # Set up window width = 800 height = 600 font = sf.Font.from_file("rust.ttf") self.params.setFont(font) if startWindow is None: # startWindow is None unless this is a restart startWindow = sf.RenderWindow(sf.VideoMode(width, height), "Asteroids") startWindow.framerate_limit = 60 startWindow.clear(sf.Color.BLACK) #Display Welcome welcomeText = utils.drawText(startWindow, string="Asteroids", size=60, font=font, position='center') startWindow.display() # Wait for any input while (True): setup = False for event in startWindow.events: if type(event) is sf.CloseEvent: exit() elif (type(event) is sf.MouseButtonEvent or type(event) is sf.KeyEvent): setup = True if setup: break # Select Player Name if playerName is None: playerName = utils.textInput(startWindow, "Enter Name:", font, maxLength=10) self.params.setPlayerName(playerName.lower()) #Choose Difficulty difficulty = utils.selectOptions(startWindow, ["Easy", "Medium", "Hard"], [0, 1, 2], font) makeTimes = [20, 15, 12] timeModifiers = [0.98, 0.95, 0.92] self.params.setDifficulty(difficulty) self.timeToMakeAsteroid = makeTimes[difficulty] self.makeTimeModifier = timeModifiers[difficulty] self.lastAsteroidTime = time.time() - self.timeToMakeAsteroid self.timeToMakePowerup = 20 self.lastPowerupTime = time.time() - self.timeToMakePowerup self.powerupProbability = 1 / 600 # Set up Board self.board = Board(title="Asteroids", width=700, height=700) # Set up Ship self.ship = Ship(position=(self.board.getBoundary()[0] / 2, self.board.getBoundary()[1] / 2)) self.ship.setWrapping(True) self.ship.setBoundary(self.board.getBoundary()) startWindow.close()
class AsteroidsGame: def setup(self, startWindow=None, playerName=None): self.params = GameParams() # To be filled by user input # Set up scorekeeping self.score = 0 self.scoreKeeper = ScoreKeeper() self.scoreKeeper.setFile('asteroidScore.txt') # Set up window width = 800 height = 600 font = sf.Font.from_file("rust.ttf") self.params.setFont(font) if startWindow is None: # startWindow is None unless this is a restart startWindow = sf.RenderWindow(sf.VideoMode(width, height), "Asteroids") startWindow.framerate_limit = 60 startWindow.clear(sf.Color.BLACK) #Display Welcome welcomeText = utils.drawText(startWindow, string="Asteroids", size=60, font=font, position='center') startWindow.display() # Wait for any input while (True): setup = False for event in startWindow.events: if type(event) is sf.CloseEvent: exit() elif (type(event) is sf.MouseButtonEvent or type(event) is sf.KeyEvent): setup = True if setup: break # Select Player Name if playerName is None: playerName = utils.textInput(startWindow, "Enter Name:", font, maxLength=10) self.params.setPlayerName(playerName.lower()) #Choose Difficulty difficulty = utils.selectOptions(startWindow, ["Easy", "Medium", "Hard"], [0, 1, 2], font) makeTimes = [20, 15, 12] timeModifiers = [0.98, 0.95, 0.92] self.params.setDifficulty(difficulty) self.timeToMakeAsteroid = makeTimes[difficulty] self.makeTimeModifier = timeModifiers[difficulty] self.lastAsteroidTime = time.time() - self.timeToMakeAsteroid self.timeToMakePowerup = 20 self.lastPowerupTime = time.time() - self.timeToMakePowerup self.powerupProbability = 1 / 600 # Set up Board self.board = Board(title="Asteroids", width=700, height=700) # Set up Ship self.ship = Ship(position=(self.board.getBoundary()[0] / 2, self.board.getBoundary()[1] / 2)) self.ship.setWrapping(True) self.ship.setBoundary(self.board.getBoundary()) startWindow.close() def endGame(self): gameOverText = utils.drawText(self.board.window, string="Game Over", font=self.params.font, size=60, position='center', color=sf.Color.RED) oldScore = self.scoreKeeper.checkScore(self.params.playerName, self.params.getDifficulty()) scoreTextYPosition = gameOverText.position[ 1] + gameOverText.local_bounds.height + 10 if self.score > oldScore: # display a "New Highscore" screen self.scoreKeeper.setScore(self.params.playerName, self.score, self.params.getDifficulty()) utils.drawText(self.board.window, string="New High Score! {}".format(self.score), font=self.params.font, size=30, position='center', yposition=scoreTextYPosition, color=sf.Color.GREEN) else: # Display the old highscore utils.drawText(self.board.window, string="High Score: {}".format(oldScore), font=self.params.font, size=30, position='center', yposition=scoreTextYPosition, color=sf.Color.WHITE) utils.drawText(self.board.window, string="Press ENTER to Relplay", font=self.params.font, size=15, position='center', yposition=self.board.window.height - 20, color=sf.Color.WHITE) self.board.window.display() while (True): for event in self.board.window.events: if (type(event) is sf.CloseEvent or (type(event) is sf.KeyEvent and event.code is sf.Keyboard.ESCAPE)): exit() if (type(event) is sf.KeyEvent and event.code is sf.Keyboard.RETURN): # Reset self.setup(self.board.window, self.params.getPlayerName()) self.playGame() def _generateAsteroid(self, asteroidManager, velocityLimit=2): if (time.time() - self.lastAsteroidTime >= self.timeToMakeAsteroid): self.lastAsteroidTime = time.time() self.timeToMakeAsteroid *= self.makeTimeModifier #make asteroids appear faster as time progresses # Generate beyond the border so it doesn't appear in middle of screen # random velocity will make it appear evenly on either side position = (random.uniform(-20, 0), random.uniform(-20, 0)) velocity = (random.uniform(-velocityLimit, velocityLimit), random.uniform(-velocityLimit, velocityLimit)) asteroid = Asteroid(4, position, velocity, wrapping=True, boundary=self.board.getBoundary()) asteroidManager.addObject(asteroid) def _generatePowerup(self, powerupManager, velocityLimit=2): if ((time.time() - self.lastPowerupTime >= self.timeToMakePowerup) and random.random() < self.powerupProbability): typeNum = random.randint(0, 2) typeNames = ["cooldown", "agility", "acceleration"] typeColors = [sf.Color.BLUE, sf.Color.GREEN, sf.Color.YELLOW] # Lots of calculations to make it start evenly on any side of the board # and ensure that it moves across the board no matter where it starts positionX = None positionY = None velocityX = None velocityY = None boundary = self.board.getBoundary() if random.random() < 0.5: positionX = random.uniform(-20, 0) else: positionX = random.uniform(boundary[0], boundary[0] + 20) if random.random() < 0.5: positionY = random.uniform(-20, 0) else: positionY = random.uniform(boundary[0], boundary[0] + 20) if (positionX < 0): velocityX = random.uniform(0, velocityLimit) else: velocityX = random.uniform(-velocityLimit, 0) if (positionY < 0): velocityY = random.uniform(0, velocityLimit) else: velocityY = random.uniform(-velocityLimit, 0) velocity = (velocityX, velocityY) position = (positionX, positionY) powerup = Powerup(position=position, velocity=velocity, color=typeColors[typeNum], powerupType=typeNames[typeNum]) powerupManager.addObject(powerup) self.lastPowerupTime = time.time() def playGame(self): self.board.window.clear(sf.Color.BLACK) self.ship.draw(self.board.window) self.board.displayBoard() play = False while not play: for event in self.board.window.events: if type(event) is sf.CloseEvent: exit() elif (type(event) is sf.KeyEvent): play = True bulletManager = ObjectManager(cleanSize=10) asteroidManager = ObjectManager(cleanSize=10) powerupManager = ObjectManager(cleanSize=5) while (True): self.board.window.clear(sf.Color.BLACK) self._generateAsteroid(asteroidManager) self._generatePowerup(powerupManager) # Input handler for event in self.board.window.events: if type(event) is sf.CloseEvent: exit() if type( event ) is sf.KeyEvent and event.code is sf.Keyboard.SPACE and event.pressed: bullet = self.ship.shootBullet( boundary=self.board.getBoundary()) if bullet: bulletManager.addObject(bullet) if sf.Keyboard.is_key_pressed(sf.Keyboard.RIGHT): self.ship.turnRight() if sf.Keyboard.is_key_pressed(sf.Keyboard.UP): self.ship.accelerate() if sf.Keyboard.is_key_pressed(sf.Keyboard.LEFT): self.ship.turnLeft() # Move and draw bullets for i in range(bulletManager.getLength()): bullet = bulletManager.getItem(i) bullet.move() bullet.draw(self.board.window) # Move and draw Asteroids for i in range(asteroidManager.getLength()): asteroid = asteroidManager.getItem(i) asteroid.move() asteroid.draw(self.board.window) # Move and draw Powerups for i in range(powerupManager.getLength()): powerup = powerupManager.getItem(i) powerup.move() powerup.draw(self.board.window) # Move and draw Ship self.ship.moveForward() self.ship.draw(self.board.window) # Check for collisions newAsteroids = [] for i in reversed(range(asteroidManager.getLength())): asteroid = asteroidManager.getItem(i) # Asteroid-Ship collision if (self.ship.circleTriangleCollision(asteroid.getShape())): self.endGame() for j in reversed(range(bulletManager.getLength())): bullet = bulletManager.getItem(j) # if collision: break asteroid if asteroid.didCollide(bullet): self.score += 1 if asteroid.breakAsteroid(): for newAsteroid in asteroid.breakAsteroid(): newAsteroids.append(newAsteroid) bulletManager.removeIndex(j) asteroidManager.removeIndex(i) break asteroidManager.addObjects(newAsteroids) # Check for powerup collisions for i in reversed(range(powerupManager.getLength())): powerup = powerupManager.getItem(i) if self.ship.circleTriangleCollision(powerup.getShape()): power = powerup.getType() if power == "acceleration": oldAcc = self.ship.getAcceleration() self.ship.setAcceleration(1.1 * oldAcc) elif power == "cooldown": oldCool = self.ship.getCooldown() self.ship.setCooldown(0.9 * oldCool) elif power == "agility": oldSpeed = self.ship.getRotateSpeed() self.ship.setRotateSpeed(1.1 * oldSpeed) powerupManager.removeIndex(i) self._drawScore(self.board.window) self.board.window.display() def _drawScore(self, window): if hasattr(self, 'scoreText'): self.scoreText.string = str(self.score) else: self.scoreText = utils.drawText(window, size=25, font=self.params.font, string=str(self.score)) window.draw(self.scoreText)
def __init__(self, log_file, server, db): self.keeper = ScoreKeeper(db) self.secret_id = "SECRET PASSWORD LOL HOORAY" self.log_file = log_file ServerFunctions.__init__(self, server)
def setup(self, startWindow=None, playerName=None): self.params = GameParams() # To be filled by user input # Set up scorekeeping self.score = 0 self.scoreKeeper = ScoreKeeper() self.scoreKeeper.setFile('breakoutScore.txt') # Set up window width = 800 height = 600 font = sf.Font.from_file("rust.ttf") self.params.setFont(font) if startWindow is None: # startWindow is None unless this is a restart startWindow = sf.RenderWindow(sf.VideoMode(width, height), "Breakout") startWindow.framerate_limit = 60 startWindow.clear(sf.Color.BLACK) #Display Welcome welcomeText = utils.drawText(startWindow, string="Breakout", size=60, font=font, position='center') startWindow.display() # Wait for any input while (True): setup = False for event in startWindow.events: if type(event) is sf.CloseEvent: exit() elif (type(event) is sf.MouseButtonEvent or type(event) is sf.KeyEvent): setup = True if setup: break # Select Player Name if playerName is None: playerName = utils.textInput(startWindow, "Enter Name:", font, maxLength=10) self.params.setPlayerName(playerName.lower()) #Choose Difficulty #difficulty = utils.selectOptions(startWindow, ["Easy", "Medium", "Hard"], [0, 1, 2], font) #self.params.setDifficulty(difficulty) # Set up Board self.board = Board(title="Breakout", width=1000, height=500) # Set up Paddle self.paddle = Paddle(boundary=self.board.getBoundary(), width=75, height=15) self.paddle.setMoveSpeed(10) # Gameplay parameters self.maxLayers = 5 self.level = 1 startWindow.close()
class BreakoutGame: def setup(self, startWindow=None, playerName=None): self.params = GameParams() # To be filled by user input # Set up scorekeeping self.score = 0 self.scoreKeeper = ScoreKeeper() self.scoreKeeper.setFile('breakoutScore.txt') # Set up window width = 800 height = 600 font = sf.Font.from_file("rust.ttf") self.params.setFont(font) if startWindow is None: # startWindow is None unless this is a restart startWindow = sf.RenderWindow(sf.VideoMode(width, height), "Breakout") startWindow.framerate_limit = 60 startWindow.clear(sf.Color.BLACK) #Display Welcome welcomeText = utils.drawText(startWindow, string="Breakout", size=60, font=font, position='center') startWindow.display() # Wait for any input while (True): setup = False for event in startWindow.events: if type(event) is sf.CloseEvent: exit() elif (type(event) is sf.MouseButtonEvent or type(event) is sf.KeyEvent): setup = True if setup: break # Select Player Name if playerName is None: playerName = utils.textInput(startWindow, "Enter Name:", font, maxLength=10) self.params.setPlayerName(playerName.lower()) #Choose Difficulty #difficulty = utils.selectOptions(startWindow, ["Easy", "Medium", "Hard"], [0, 1, 2], font) #self.params.setDifficulty(difficulty) # Set up Board self.board = Board(title="Breakout", width=1000, height=500) # Set up Paddle self.paddle = Paddle(boundary=self.board.getBoundary(), width=75, height=15) self.paddle.setMoveSpeed(10) # Gameplay parameters self.maxLayers = 5 self.level = 1 startWindow.close() def endGame(self): gameOverText = utils.drawText(self.board.window, string="Game Over", font=self.params.font, size=60, position='center', color=sf.Color.RED) oldScore = self.scoreKeeper.checkScore(self.params.playerName, self.params.getDifficulty()) scoreTextYPosition = gameOverText.position[ 1] + gameOverText.local_bounds.height + 10 if self.score > oldScore: # display a "New Highscore" screen self.scoreKeeper.setScore(self.params.playerName, self.score, self.params.getDifficulty()) utils.drawText(self.board.window, string="New High Score! {}".format(self.score), font=self.params.font, size=30, position='center', yposition=scoreTextYPosition, color=sf.Color.GREEN) else: # Display the old highscore utils.drawText(self.board.window, string="High Score: {}".format(oldScore), font=self.params.font, size=30, position='center', yposition=scoreTextYPosition, color=sf.Color.WHITE) utils.drawText(self.board.window, string="Press ENTER to Relplay", font=self.params.font, size=15, position='center', yposition=self.board.window.height - 20, color=sf.Color.WHITE) self.board.window.display() while (True): for event in self.board.window.events: if (type(event) is sf.CloseEvent or (type(event) is sf.KeyEvent and event.code is sf.Keyboard.ESCAPE)): exit() if (type(event) is sf.KeyEvent and event.code is sf.Keyboard.RETURN): # Reset self.board.window.clear(sf.Color.BLACK) self.setup(self.board.window, self.params.getPlayerName()) self.playGame() def playLevel(self, level): self.board.window.clear(sf.Color.BLACK) self.paddle.draw(self.board.window) self.board.displayBoard() play = False while not play: for event in self.board.window.events: if type(event) is sf.CloseEvent: exit() elif (type(event) is sf.KeyEvent): play = True ballManager = ObjectManager(cleanSize=10) screenWidth = self.board.getBoundary()[0] screenHeight = self.board.getBoundary()[1] # Calculate BrickWall difficulty parameters wallDepth = min(self.maxLayers, self.level) wallLength = 10 + 2 * (self.level // 5 ) # increase by 2 width every 5 levels boundary = ((0, 25), (screenWidth, 25 + min(20 * wallDepth, screenHeight / 3))) brickWall = BrickWall(boundary=boundary) brickWall.setWallDepth(wallDepth) brickWall.setWallWidth(wallLength) if self.level < self.maxLayers: # Set all bricks health = 1 brickWall.setAllLayerHealth(1) else: minHealth = 1 + (self.level // 3) maxHealth = self.maxLayers + (self.level // 3) brickWall.setLayerHealthGradient(minHealth, maxHealth) brickWall.createBricks() ballSpeed = 4.5 + 0.2 * self.level ball = Ball(position=(100, screenHeight / 2), speed=ballSpeed, direction=45) ballManager.addObject(ball) while (True): self.board.window.clear(sf.Color.BLACK) # Input handler for event in self.board.window.events: if type(event) is sf.CloseEvent: exit() if type(event) is sf.KeyEvent and event.pressed and ( event.code is sf.Keyboard.RETURN): self.level += 1 self.playLevel(self.level) if sf.Keyboard.is_key_pressed(sf.Keyboard.RIGHT): self.paddle.moveRight() if sf.Keyboard.is_key_pressed(sf.Keyboard.LEFT): self.paddle.moveLeft() # Move and draw balls for i in range(ballManager.getLength()): ball = ballManager.getItem(i) ball.move() ball.draw(self.board.window) # Draw bricks brickWall.drawBricks(self.board.window) # Draw Paddle self.paddle.draw(self.board.window) # Check for Ball-Brick Collisions for i in range(ballManager.getLength()): ball = ballManager.getItem(i) brick = brickWall.checkCollision(ball) if brick: ball.rectangleBounce(brick.getShape()) if (brick.getHealth() == 0): self.score += 1 # Check for Ball Collisions for i in range(ballManager.getLength()): ball = ballManager.getItem(i) position = ball.getPosition() size = ball.getSize() if self.paddle.didCollide(ball): ball.rectangleBounce(self.paddle.getShape()) # Check for Ball-Wall Collision if (position[0] <= 0 or position[0] + size[0] >= self.board.getBoundary()[0]): ball.bounceHorizontal() if (position[1] <= 0): ball.bounceVertical() # Remove Dead Balls deadBalls = [] if (position[1] >= self.board.getBoundary()[1]): deadBalls.append(i) ballManager.removeItems(deadBalls) # Check if any balls left if ballManager.getLength() == 0: self.endGame() # Check if any bricks left if brickWall.getNumBricks() == 0: self.level += 1 self.playLevel(self.level) self._drawScore(self.board.window) self.board.window.display() def playGame(self): self.playLevel(self.level) def _drawScore(self, window): if hasattr(self, 'scoreText'): self.scoreText.string = str(self.score) else: self.scoreText = utils.drawText(window, size=25, font=self.params.font, string=str(self.score)) window.draw(self.scoreText)
def __init__(self): self.score = 0 self.scoreKeeper = ScoreKeeper() self.params = GameParams() # To be filled by user input
def add_to_player(player_name): singleton = ScoreKeeper.get_instance() print('Score given to {0}!'.format(player_name)) singleton.increment_score(player_name)
class SnakeGame(Game): def setup(self, startWindow=None, playerName=None): self.score = 0 self.scoreKeeper = ScoreKeeper() self.scoreKeeper.setFile('snakeScore.txt') self.params = GameParams() # To be filled by user input width = 800 height = 600 font = sf.Font.from_file("rust.ttf") if startWindow is None: # startWindow is None unless this is a restart startWindow = sf.RenderWindow(sf.VideoMode(width, height), "Snake") startWindow.framerate_limit = 60 startWindow.clear(sf.Color.BLACK) #Display Welcome welcomeText = utils.drawText(startWindow, string="Snake", size=60, font=font, position='center') startWindow.display() while(True): setup = False for event in startWindow.events: if type(event) is sf.CloseEvent: exit() elif (type(event) is sf.MouseButtonEvent or type(event) is sf.KeyEvent): setup = True if setup: break #TODO Choose PlayerName if playerName is None: playerName = utils.textInput(startWindow, "Enter Name:", font, maxLength=10) self.params.setPlayerName(playerName) #Choose Difficulty difficulty = utils.selectOptions(startWindow, ["Easy", "Medium", "Hard"], [0, 1, 2], font) frameRates = [20, 25, 30] self.params.setDifficulty(difficulty) self.params.setFrameRate(frameRates[difficulty]) #Choose Board Size boardSize = utils.selectOptions(startWindow, ["Small", "Medium", "Large"], [(40,30), (50,40), (60,50)], font) self.params.setBoardSize(boardSize) self.params.setSquareSize(15) self.params.setFont(font) self.snake = Snake(5, self.params.squareSize, sf.Vector2(10,10)) self.board = Board(width=self.params.boardWidth, height=self.params.boardHeight, squareSize=self.params.squareSize, frameRate=self.params.frameRate) self.board.initSnake(self.snake) startWindow.close() self.playGame() def endGame(self): gameOverText = utils.drawText(self.board.window, string="Game Over", font=self.params.font, size=60, position='center', color=sf.Color.RED) oldScore = self.scoreKeeper.checkScore(self.params.playerName, self.params.getDifficulty()) scoreTextYPosition = gameOverText.position[1]+gameOverText.local_bounds.height+10 scoreText = None if self.score > oldScore: # display a "New Highscore" screen self.scoreKeeper.setScore(self.params.playerName, self.score, self.params.getDifficulty()) utils.drawText(self.board.window, string="New High Score! {}".format(self.score), font=self.params.font, size=30, position='center', yposition=scoreTextYPosition, color=sf.Color.GREEN) else: # Display the old highscore utils.drawText(self.board.window, string="High Score: {}".format(oldScore), font=self.params.font, size=30, position='center', yposition=scoreTextYPosition, color=sf.Color.WHITE) utils.drawText(self.board.window, string="Press ENTER to Relplay", font=self.params.font, size=15, position='center', yposition=self.board.window.height - 20, color=sf.Color.WHITE) self.board.window.display() while(True): for event in self.board.window.events: if (type(event) is sf.CloseEvent or (type(event) is sf.KeyEvent and event.code is sf.Keyboard.ESCAPE)): exit() if (type(event) is sf.KeyEvent and event.code is sf.Keyboard.RETURN): # Reset self.snake = None self.setup(self.board.window, self.params.getPlayerName()) def playGame(self): self.board.drawBoard() self.board.displayBoard() # wait for keypress to begin game play = False while not play: for event in self.board.window.events: if type(event) is sf.CloseEvent: exit() elif (type(event) is sf.KeyEvent): play = True while(True): # Tell player to make their move self.snake.makeMove() # board should check if anything has been interacted with # call all of the checks (wall, self, food) and respond appropriately foundFood = self.snake.checkSquareCollision(self.board.food) if (foundFood): self.score += 1 self.snake.addSquare() self.board.generateFood(self.snake) hitObject = (self.board.checkCollisions(self.snake.getHeadPosition()) or self.snake.checkSelfCollision()) if (hitObject): self.endGame() self.board.drawBoard() self.snake.draw(self.board.window) self.drawScore(self.board.window) self.board.displayBoard() if not self.board.checkEvents(): exit() def drawScore(self, window): if hasattr(self,'scoreText'): self.scoreText.string = str(self.score) else: self.scoreText = utils.drawText(window, size=25, font=self.params.font, string=str(self.score)) window.draw(self.scoreText)