def test_bot_train(self):
player_id = 42
train_id = 9001
required = 6
p = Player(player_id, TestBot())
t = Train(train_id, required, p)
bt = BotTrain(t, p)
self.assertTrue(bt.can_add)
self.assertTrue(bt.am_owner)
self.assertFalse(bt.identity.mexican)
self.assertEqual(p, bt.identity.owner)
self.assertEqual(required, bt.requires)
bt.cars.append(Domino(2, 3))
self.assertEqual(0, len(t.cars))
d1 = Domino(6, 6)
t.add_domino(d1, p)
bt = BotTrain(t, p)
self.assertTrue(bt.demands_satisfaction)
self.assertEqual(6, bt.requires)
self.assertEqual(d1, bt.cars.pop())
d2 = Domino(12, 6)
t.add_domino(d2, p)
bt = BotTrain(t, p)
self.assertFalse(bt.demands_satisfaction)
self.assertEqual(12, bt.requires)
self.assertEqual(d2, bt.cars.pop())
def test_provide_satisfaction(self):
t = Train(5, 5, self.player_five)
d = Domino(5, 5)
t.add_domino(d, self.player_five)
self.assertTrue(t.demands_satisfaction)
self.assertFalse(t.private)
t.add_domino(Domino(3, 5), self.player_five)
self.assertFalse(t.demands_satisfaction)
self.assertTrue(t.private)
def test_bot_train_public(self):
player_id = 42
owner_id = 24
train_id = 9001
required = 6
p = Player(player_id, TestBot())
o = Player(owner_id, TestBot())
t = Train(train_id, required, o)
t.make_public()
bt = BotTrain(t, p)
self.assertTrue(bt.can_add)
self.assertFalse(bt.am_owner)
self.assertFalse(bt.identity.mexican)
self.assertEqual(o, bt.identity.owner)
def __init__(self, train: Train, player: Player):
self.identity = train.identity
self.is_public = not train.private
self.am_owner = player == self.identity.owner
self.can_add = train.can_player_add(player)
self.cars = copy(train.cars)
self.requires = train.requires
self.demands_satisfaction = train.demands_satisfaction
if player is not None:
self.owner_tile_count = len(player.dominoes)
else:
self.owner_tile_count = 0
def place_domino(self, train: Train, domino: Domino, player: Player):
"""
Place a domino on a Train.
:param train: The Train to add the Domino to.
:param domino: The Domino to add.
:param player: The Player who is placing the domino.
"""
if train.add_domino(domino, player):
player.dominoes.remove(domino)
self.played_count[domino.left] += 1
if not domino.is_double:
self.played_count[domino.right] += 1
self.played.append(domino)
def test_update_required(self):
t = Train(2, 2, self.player_two)
d = Domino(2, 3)
t.add_domino(d, self.player_two)
self.assertEqual(3, t.requires)
def test_private_to_public(self):
t = Train(2, 2, self.player_two)
t.make_private()
t.make_public()
d = Domino(2, 3)
self.assertTrue(t.add_domino(d, self.player_two))
def test_private_train(self):
t = Train(2, 2, self.player_two)
t.make_private()
d = Domino(2, 3)
self.assertTrue(t.add_domino(d, self.player_two))
self.assertFalse(t.add_domino(d, Player(1, TestBot())))
def test_cannot_add_domino(self):
t = Train(5, 5, self.player_five)
d = Domino(2, 3)
self.assertFalse(t.add_domino(d, self.player_two))
def test_can_add_domino(self):
t = Train(2, 2, self.player_two)
d = Domino(2, 3)
self.assertTrue(t.add_domino(d, self.player_two))
def test_does_not_demand_satisfaction(self):
t = Train(2, 2, self.player_two)
d = Domino(2, 3)
t.add_domino(d, self.player_two)
self.assertFalse(t.demands_satisfaction)
self.assertTrue(t.private)
def main_loop(self):
if not internet_on():
print 'No internet connection.'
return
try:
#input = InputName(self.screen)
#name = input.get_name()
name = "02 03 2017"
self.test_hash = name.lower().replace(' ', '_')
# self.test_hash = str(random.getrandbits(1))
self.__generate_logger()
log_info_game = {
'game_mode_parameter': self.game_mode,
'game_helper_parameter': self.helper,
'entrainment_helper_name': (CHARACTERS[self.helper % 2])[0],
'player_number': self.test_hash
}
logging.info("General=> Starting test - %s", log_info_game)
train = Train(self.screen)
train.start()
practiceGame = PracticeGame(screen=self.screen)
practiceGame.config(self.test_hash)
_, rate_avg, energy_avg, f0mean_avg = practiceGame.play() # RG
score_screen = InterGameScreen(
screen=self.screen,
step=0,
scores=[practiceGame.human_player.score])
score_screen.show()
score_helper_1 = 0
score_helper_2 = 0
for j in range(1, CANT_GAMES + 1):
if modeAdmin == PLAYING_MODE_ONE:
game = GameTypeOne(
screen=self.screen,
rate_base=rate_avg,
# range_base=range_avg, # RG
energy_base=energy_avg, # RG
f0mean_base=f0mean_avg, # RG
entrainment_helper=self.helper,
score_h1=score_helper_1,
score_h2=score_helper_2)
elif modeAdmin == PLAYING_MODE_TWO:
game = GameTypeTwo(
screen=self.screen,
rate_base=rate_avg,
# range_base=range_avg, # RG
energy_base=energy_avg, # RG
f0mean_base=f0mean_avg, # RG
entrainment_helper=self.helper,
score_h1=score_helper_1,
score_h2=score_helper_2)
game.config(self.test_hash)
score, rate_avg, energy_avg, f0mean_avg = game.play() # RG
self.results.append(score)
# Recupero los scores de los
score_helper_1 = game.known_helpers[0].score
score_helper_2 = game.known_helpers[1].score
score_screen = InterGameScreen(screen=self.screen,
step=j,
scores=self.results)
score_screen.show()
except (KeyboardInterrupt, SystemExit):
raise
from src.Analyze import Analyze
from src.Train import Train
from src.FeatureExtraction import FeatureExtraction
if __name__ == "__main__":
trainer = Train(datafp="data/np-rnn/")
trainset = [1, 2, 3, 4, 5, 6, 7, 12, 13, 14, 15, 17, 20]
validationset = [9, 18, 19, 16, 8, 11]
testset = [9, 10]
trainer.trainmodel(trainset, validationset, testset)
#extractor.load([1,2], "data/np-rnn/")
# -----------------------------
# extractor = FeatureExtraction()
# savedir = "data/np-rnn2"
# extractor.mkdir(savedir)
# extractor.save(savedir)
# -----------------------------
sounds, sr = Analyze.load("datasets/UrbanSound8K/test/audio/")
labels = [
"foreground", "background", "synthesis", "synthesis", "synthesis",
"synthesis", "synthesis"
]
Analyze.plotwave(labels, sounds)
Analyze.plotspectrogram(labels, sounds)
Analyze.plotlogspectrogram(labels, sounds)
Analyze.plotmelspectrogram(labels, sounds, sr)
