class GameRound:
START_LIVES = 3
def __init__(self, noteWars, windowWidth, windowHeight):
self._noteWars = noteWars
self._windowWidth = windowWidth
self._windowHeight = windowHeight
self._enemiesGroup = pygame.sprite.Group()
self._enemyDelaySec = 3.0
self._enemyElapsedDelaySec = 0.0
self._playerGroup = pygame.sprite.GroupSingle()
self._hudGroup = pygame.sprite.Group()
self._score = 0
self._lives = self.START_LIVES
def load(self, songPath):
# Load projectiles
self._laser = Laser(self._windowWidth * 1.5)
# Load player
self._playerSpawnPos = (self._windowWidth / 2, self._windowHeight / 2)
self._player = Player(ContentManager.load_image('media/actors/player.png'), self._laser, self._playerSpawnPos)
self._playerGroup.add(self._player)
# Load HUD
fontPath = 'media/fonts/freesansbold.ttf'
self._font = ContentManager.load_font(fontPath, 36)
self._scoreSprite = TextSprite(self._font, pygame.Color('white'), (30, 30))
self._livesSprite = TextSprite(self._font, pygame.Color('white'), (30, 70))
self._livesSprite.updateText('Lives: ' + str(self._lives))
self._hudGroup.add(self._scoreSprite, self._livesSprite)
# Load music configuration
#songPath = 'media/music/battlefield1942'
#songPath = 'media/music/test'
# Load game director
self._gameDirector = GameDirector(self)
self._gameDirector.load(self._player, songPath)
# Load music
self._musicPlayer = MusicPlayer()
self._musicPlayer.load(songPath + '.mid')
self._musicPlayer.play()
def spawnEnemy(self, enemy):
spawnSide = int(random.uniform(0, 4))
spawnDistance = random.random()
spawnX = 0
spawnY = 0
if spawnSide == 0: # Left side
spawnX = 0
spawnY = self._windowHeight * spawnDistance
elif spawnSide == 1: # Top side
spawnX = self._windowWidth * spawnDistance
spawnY = 0
elif spawnSide == 2: # Right side
spawnX = self._windowWidth
spawnY = self._windowHeight * spawnDistance
else: # Bottom side
spawnX = self._windowWidth * spawnDistance
spawnY = self._windowHeight
enemy.setPosition((spawnX, spawnY))
self._enemiesGroup.add(enemy)
def update(self, elapsedTimeSec):
self._enemyElapsedDelaySec += elapsedTimeSec
# Check for collisions
self._checkCollisions()
# Update game entities
self._playerGroup.update(elapsedTimeSec)
self._enemiesGroup.update(elapsedTimeSec)
self._hudGroup.update(elapsedTimeSec)
# Invoke game director
self._gameDirector.update(elapsedTimeSec)
# Check whether the user wants to exit the game
pressedKeys = pygame.key.get_pressed()
if pressedKeys[K_BACKSPACE]:
self._exitRound()
def stop(self):
self._musicPlayer.stop()
self._gameDirector.stop()
def _handlePlayerDeath(self):
self._lives -= 1
if self._lives < 0:
self.stop()
self._noteWars.goToMainMenuWithLose(self._score)
else:
self._livesSprite.updateText('Lives: ' + str(self._lives))
self._enemiesGroup.empty()
self._player.setPosition(self._playerSpawnPos)
def roundComplete(self):
self.stop()
self._noteWars.goToMainMenuWithWin(self._score)
def _exitRound(self):
self.stop()
self._noteWars.goToMainMenu()
def _checkCollisions(self):
# Check collisions between laser and enemies
collidedEnemies = []
if self._laser.isFiring():
for enemy in self._enemiesGroup.sprites():
if CollisionMethods.collideLineToRect(self._laser.getFiredFromPos(),
self._laser.getFiredToPos(),
enemy.rect):
collidedEnemies.append(enemy)
self._score += len(collidedEnemies) * 100
self._scoreSprite.updateText('Score: ' + str(self._score))
for enemy in collidedEnemies:
enemy.kill()
# Check collisions between player and enemies
collidedEnemies = pygame.sprite.spritecollide(self._player, self._enemiesGroup, True, CollisionMethods.collideRectThenMask)
if collidedEnemies:
self._handlePlayerDeath()
def draw(self, screen):
self._laser.draw(screen)
self._playerGroup.draw(screen)
self._enemiesGroup.draw(screen)
[text.render() for text in self._hudGroup.sprites()]
self._hudGroup.draw(screen)
class GeneratorFacade:
def __init__(self):
self.neural_network = None
self.melody = None
self.music_player = MusicPlayer()
self.duration = None
self.data_set = None
self.unique_events_list = None
def is_model_loaded(self):
if self.neural_network is None:
return False
return True
def is_melody_generated(self):
if self.melody is None:
return False
return True
def load_model(self, file_path):
if not file_path:
return False
if file_path.lower().endswith(
RecurrentNeuralNetwork.model_file_format):
self.neural_network = RecurrentNeuralNetwork.load_model(file_path)
else:
raise ValueError()
return True
def save_model(self, file_path):
if file_path is None or self.neural_network is None:
return
self.neural_network.save_model(file_path)
@staticmethod
def get_model_file_format():
return RecurrentNeuralNetwork.model_file_format
def generate_melody(self, duration):
if self.neural_network is None:
return
self.duration = duration
ticks_per_second = (MidiConverter.ticks_per_beat *
MidiConverter.beats_per_minute) / 60
number_of_ticks = duration * ticks_per_second
number_of_notes = number_of_ticks / MidiConverter.delta_time_in_ticks
self.melody = self.neural_network.generate(int(number_of_notes))
def save_melody(self, file_path):
if self.melody is None:
return
MidiConverter.write_midi_file(file_path, self.melody,
self.neural_network.unique_events_list)
def play_melody(self):
file_object = MidiConverter.get_midi_file_object(
self.melody, self.neural_network.unique_events_list)
self.music_player.play(file_object)
print('play melody')
def stop_melody(self):
self.music_player.stop()
print('stop melody')
def load_data_set(self, file_paths):
self.data_set = []
for file_path in file_paths:
if not file_path.lower().endswith(('.mid', '.midi')):
self.data_set = None
raise ValueError()
self.data_set.append(MidiConverter.convert_midi_file(file_path))
self.unique_events_list = UniqueEventsList(self.data_set)
self.unique_events_list.convert_data_set(self.data_set)
def reset_data_set(self):
self.data_set = None
def is_data_set_loaded(self):
if self.data_set is not None:
return True
return False
def train(self, sequence_length, first_lstm_layer_size,
second_lstm_layer_size, dropout_rate, number_of_epochs,
test_sample_ratio, callbacks):
self.neural_network = RecurrentNeuralNetwork(
self.data_set, self.unique_events_list, sequence_length,
first_lstm_layer_size, second_lstm_layer_size, dropout_rate)
self.neural_network.train(number_of_epochs, test_sample_ratio,
callbacks)
