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)
