def __init__(self,
flask_host=config["output_server_host"],
flask_port=config["output_server_port"],
flask_url=config["output_server_url"],
voice_hash=config["default_voice"],
mary_host=config["marytts_host"],
mary_port=config["marytts_port"]):
"""
Here we create objects of main components of Output,
which are controled by this class.
Also we create "_is_running" flag to be able to stop running
and Rlock object to lock self and threads of controlled object when it is necessary
"""
super(OutputController, self).__init__()
self._lock = threading.RLock()
self._receiver = CommandReceiver(flask_host, flask_port, flask_url,
self._lock)
self._tts = TTSClient(voice_hash, mary_host, mary_port, self)
self._audioplayer = AudioPlayer(controller=self)
# lists for controlling text to speech and its playing
self.tts_phrases_queue = []
self.text_to_say = []
self._is_video_playing = False
self._is_running = True
self._cur_filetype = None
self._zoom_factor = 1
# it saves volume to set it after turning off mute
# and to know how to increase/decrease it
self._speech_volume = 0
self._music_volume = 0
self._muted = False
def __init__(self) -> None:
# Initialize pygame
pygame.init()
self.audio_player = AudioPlayer()
# Setup to draw maps
self.tile_size_pixels = 20
desired_win_size_pixels = Point(2560, 1340)
if desired_win_size_pixels is None:
self.screen: pygame.surface.Surface = pygame.display.set_mode(
(0, 0), pygame.FULLSCREEN | pygame.NOFRAME | pygame.SRCALPHA
| pygame.DOUBLEBUF | pygame.HWSURFACE)
self.win_size_pixels: Point = Point(self.screen.get_size())
self.win_size_tiles: Point = (self.win_size_pixels /
self.tile_size_pixels).floor()
else:
self.win_size_tiles = (desired_win_size_pixels /
self.tile_size_pixels).floor()
self.win_size_pixels = self.win_size_tiles * self.tile_size_pixels
self.screen = pygame.display.set_mode(
self.win_size_pixels.getAsIntTuple(),
pygame.SRCALPHA | pygame.DOUBLEBUF | pygame.HWSURFACE)
self.image_pad_tiles = self.win_size_tiles // 2 * 4
# Initialize GameInfo
import os
base_path = os.path.split(os.path.abspath(__file__))[0]
game_xml_path = os.path.join(base_path, 'game.xml')
self.game_info = GameInfo(base_path, game_xml_path,
self.tile_size_pixels, self.win_size_pixels)
self.is_running = True
def handle_death(self,
message_dialog: Optional[GameDialog] = None) -> None:
if not self.hero_party.has_surviving_members():
# Player death
self.hero_party.main_character.hp = 0
AudioPlayer().stop_music()
AudioPlayer().play_sound('player_died')
GameDialog.create_encounter_status_dialog(self.hero_party).blit(
self.screen, False)
gde = GameDialogEvaluator(self.game_info, self)
if message_dialog is None:
message_dialog = GameDialog.create_message_dialog()
else:
message_dialog.add_message('')
gde.add_and_wait_for_message('Thou art dead.', message_dialog)
gde.wait_for_acknowledgement(message_dialog)
for hero in self.hero_party.members:
hero.curr_pos_dat_tile = hero.dest_pos_dat_tile = self.game_info.death_hero_pos_dat_tile
hero.curr_pos_offset_img_px = Point(0, 0)
hero.direction = self.game_info.death_hero_pos_dir
hero.hp = hero.level.hp
hero.mp = hero.level.mp
gde.update_default_dialog_font_color()
self.pending_dialog = self.game_info.death_dialog
self.hero_party.gp = self.hero_party.gp // 2
self.set_map(self.game_info.death_map, respawn_decorations=True)
def __init__(self):
#Tkinter
self.root = Tk()
self.audioPlayer = AudioPlayer()
self.initWindow()
self.queue = queue.Queue()
self.authenticator = Authenticator()
self.startAuthentication()
self.root.mainloop()
class Playlist:
SIZE = 5
RECENTLY_PLAYED_TIMEOUT_SEC = 60*30
song_list = list()
recently_played = dict()
audioPlayer = None
def __init__(self):
self.audioPlayer = AudioPlayer()
self.update_song_list()
def update_song_list(self):
if len(self.song_list) == self.SIZE:
return
self.clean_recently_played()
client = MongoClient()
coll = client[configurations.DB.NAME][configurations.DB.COLLECTIONS.SONGS]
songs = list(coll.find({}).sort("upvotes", -1))
if len(songs) == len(self.recently_played):
self.recently_played = dict()
self.song_list = list()
while len(self.song_list) < self.SIZE and len(songs) > 0:
song = songs.pop(0)
if song['_id'] not in self.recently_played:
self.song_list.append(song)
client.close()
def clean_recently_played(self):
new_list = dict()
now = int(time.time())
for song in self.recently_played:
if (now - self.recently_played[song]) < self.RECENTLY_PLAYED_TIMEOUT_SEC:
new_list[song] = self.recently_played[song]
self.recently_played = new_list
def play_next_song(self):
if len(self.song_list) == 0:
self.update_song_list()
if len(self.song_list) != 0:
song = self.song_list.pop(0)
self.recently_played[song['_id']] = int(time.time())
self.audioPlayer.play(song)
return True
return False
def get_currently_playing(self):
return self.audioPlayer.song
def is_initial(self):
return self.audioPlayer.is_initial()
def __init__(self) -> None:
self.is_running = True
# Initialize pygame
pygame.init()
self.audio_player = AudioPlayer()
self.clock = pygame.time.Clock()
# Setup to draw maps
self.tile_size_pixels = 32
desired_win_size_pixels = Point(2560, 1340)
if desired_win_size_pixels is None:
self.screen: pygame.surface.Surface = pygame.display.set_mode(
(0, 0), pygame.FULLSCREEN | pygame.NOFRAME | pygame.SRCALPHA)
self.win_size_pixels: Point = Point(self.screen.get_size())
self.win_size_tiles: Point = self.win_size_pixels // self.tile_size_pixels
else:
self.win_size_tiles = desired_win_size_pixels // self.tile_size_pixels
self.win_size_pixels = self.win_size_tiles * self.tile_size_pixels
self.screen = pygame.display.set_mode(
self.win_size_pixels.getAsIntTuple(), pygame.SRCALPHA)
self.image_pad_tiles = self.win_size_tiles // 2 * 4
# Initialize GameInfo
import os
base_path = os.path.split(os.path.abspath(__file__))[0]
game_xml_path = os.path.join(base_path, 'game.xml')
from GameInfo import GameInfo
self.game_info = GameInfo(base_path, game_xml_path,
self.tile_size_pixels, self.win_size_pixels)
# Initialize the hero party
self.hero_party = HeroParty(
HeroState(self.game_info.character_types['hero'], Point(),
Direction.NORTH, 'Camden', 20000))
# Setup a mock game state
from unittest import mock
from unittest.mock import MagicMock
self.mock_game_state = mock.create_autospec(spec=GameStateInterface)
self.mock_game_state.screen = self.screen
self.mock_game_state.is_running = self.is_running
self.mock_game_state.get_game_info = MagicMock(
return_value=self.game_info)
self.mock_game_state.get_image_pad_tiles = MagicMock(
return_value=self.image_pad_tiles)
self.mock_game_state.get_hero_party = MagicMock(
return_value=self.hero_party)
self.mock_game_state.check_progress_markers = MagicMock(
return_value=True)
def __init__(self):
#Tkinter
self.root = Tk()
self.initWindow()
self.queue = queue.Queue()
self.enroller = Enroller()
self.audioPlayer = AudioPlayer()
self.audioPlayer.playEnrollWelcome()
#Blocked from here
self.root.mainloop()
class MapViewer:
def __init__(self) -> None:
# Initialize pygame
pygame.init()
self.audio_player = AudioPlayer()
# Setup to draw maps
self.tile_size_pixels = 20
desired_win_size_pixels = Point(2560, 1340)
if desired_win_size_pixels is None:
self.screen: pygame.surface.Surface = pygame.display.set_mode(
(0, 0), pygame.FULLSCREEN | pygame.NOFRAME | pygame.SRCALPHA
| pygame.DOUBLEBUF | pygame.HWSURFACE)
self.win_size_pixels: Point = Point(self.screen.get_size())
self.win_size_tiles: Point = (self.win_size_pixels /
self.tile_size_pixels).floor()
else:
self.win_size_tiles = (desired_win_size_pixels /
self.tile_size_pixels).floor()
self.win_size_pixels = self.win_size_tiles * self.tile_size_pixels
self.screen = pygame.display.set_mode(
self.win_size_pixels.getAsIntTuple(),
pygame.SRCALPHA | pygame.DOUBLEBUF | pygame.HWSURFACE)
self.image_pad_tiles = self.win_size_tiles // 2 * 4
# Initialize GameInfo
import os
base_path = os.path.split(os.path.abspath(__file__))[0]
game_xml_path = os.path.join(base_path, 'game.xml')
self.game_info = GameInfo(base_path, game_xml_path,
self.tile_size_pixels, self.win_size_pixels)
self.is_running = True
def __del__(self) -> None:
# Terminate pygame
self.audio_player.terminate()
pygame.quit()
def view_map(self, map_name: str) -> None:
if not self.is_running:
return
if self.game_info.maps[map_name].tiled_filename is not None:
print('Skipping tiled map', map_name, flush=True)
return
self.audio_player.play_music(self.game_info.maps[map_name].music)
ScrollTest(self.screen, self.game_info, map_name).run()
def title_screen(self, text: str) -> None:
# Play title music and display title screen
AudioPlayer().play_music(self.title_music)
title_image_size_px = Point(self.title_image.get_size())
title_image_size_px *= max(
1,
int(
min(self.win_size_pixels.w * 0.8 / title_image_size_px.w,
self.win_size_pixels.h * 0.8 / title_image_size_px.h)))
title_image = pygame.transform.scale(
self.title_image, title_image_size_px.getAsIntTuple())
title_image_dest_px = Point(
(self.win_size_pixels.w - title_image_size_px.w) / 2,
self.win_size_pixels.h / 2 - title_image_size_px.h)
screen = pygame.display.get_surface()
screen.fill('black')
screen.blit(title_image, title_image_dest_px)
title_image = GameDialog.font.render(text, GameDialog.anti_alias,
pygame.Color('white'),
pygame.Color('black'))
title_image_dest_px = Point(
(self.win_size_pixels.w - title_image.get_width()) / 2,
3 * self.win_size_pixels.h / 4)
screen.blit(title_image, title_image_dest_px)
pygame.display.flip()
def on_click_downloading_table(self):
print("\n")
for currentQTableWidgetItem in self.tableFileDownloadingWidget.selectedItems(
):
print(currentQTableWidgetItem.row(),
currentQTableWidgetItem.column(),
currentQTableWidgetItem.text())
audio = AudioPlayer(currentQTableWidgetItem.text())
start_new_thread(audio.start_audio, ())
print("Sound!")
def open_locked_item(self) -> Optional[MapDecoration]:
locked_map_decoration = self.get_locked_map_decoration()
if locked_map_decoration is not None:
if locked_map_decoration.type is not None and locked_map_decoration.type.remove_sound is not None:
AudioPlayer().play_sound(
locked_map_decoration.type.remove_sound)
self.remove_decoration(locked_map_decoration)
return locked_map_decoration
def main():
cam = UsbWebcam()
ml = Yolo()
coord = Coordinate()
audio = AudioPlayer()
navigation = Thread(target=CoordinateNavigation,
args=(coord, audio, cam, ml))
navigation.start()
camera = Thread(target=CameraNavigation, args=(cam, ml, audio))
camera.start()
def test_deafness(test_trials=5):
sound_was_heard = True
# Reduced the volume if the sound was heard
while sound_was_heard:
audio_player = AudioPlayer(deafness_test_sound.as_posix(),
dummy=dummy_audio_player)
# Set output line to speaker in the middle
audio_player.set_output_line(5)
for j in range(test_trials):
audio_player.play()
print(Fore.GREEN + 'Has participant heard the sound? (y / n)' +
Style.RESET_ALL)
# Get input regarding perception
userAnswer = str(input())
# Set status
if userAnswer == 'n' or userAnswer == '0' or userAnswer == 'N':
sound_was_heard = False
clear_screen()
print(Fore.RED + 'Do NOT forget to write down sound level!' +
Style.RESET_ALL)
input()
clear_screen()
def choose_audio(self):
path = QtGui.QFileDialog.getOpenFileName(self,
u'Selecione um áudio',
HOME_DIRECTORY,
model.CONTENT_TYPES[model.Media.AUDIO])
if path == None:
return
self.audio_path = unicode(path)
self.audio_player = AudioPlayer()
self.ui.txt_sound.clear()
self.ui.txt_sound.append(os.path.split(self.audio_path)[1])
self.audio_player.load_audio(self.audio_path)
self.audio_player.setVisible(False)
def make_map_transition(self,
transition: Optional[OutgoingTransition]) -> bool:
if transition is None:
return False
src_map = self.game_info.maps[self.get_map_name()]
dest_map = self.game_info.maps[transition.dest_map]
# Find the destination transition corresponding to this transition
if transition.dest_name is None:
try:
dest_transition = dest_map.transitions_by_map[
self.get_map_name()]
except KeyError:
print('Failed to find destination transition by dest_map',
flush=True)
return False
else:
try:
dest_transition = dest_map.transitions_by_map_and_name[
self.get_map_name()][transition.dest_name]
except KeyError:
try:
dest_transition = dest_map.transitions_by_name[
transition.dest_name]
except KeyError:
print('Failed to find destination transition by dest_name',
flush=True)
return False
# If transitioning from outside to inside, save off last outside position
if src_map.is_outside and not dest_map.is_outside:
self.hero_party.set_last_outside_pos(
self.get_map_name(), self.hero_party.get_curr_pos_dat_tile(),
self.hero_party.get_direction())
# Make the transition and draw the map
AudioPlayer().play_sound('walk_away')
self.hero_party.set_pos(dest_transition.point, dest_transition.dir)
self.set_map(transition.dest_map,
respawn_decorations=transition.respawn_decorations)
self.draw_map(True)
# Slight pause on a map transition
pygame.time.wait(250)
return True
def handle_quit(self, force: bool = False) -> None:
AudioPlayer().play_sound('select')
if force:
self.is_running = False
# Save off initial background image
background_surface = self.screen.copy()
menu_dialog = GameDialog.create_yes_no_menu(
Point(1, 1), 'Do you really want to quit?')
menu_dialog.blit(self.screen, flip_buffer=True)
menu_result = GameDialogEvaluator(
self.game_info, self).get_menu_result(menu_dialog,
allow_quit=False)
if menu_result is not None and menu_result == 'YES':
self.is_running = False
# Restore initial background image
menu_dialog.erase(self.screen, background_surface, flip_buffer=True)
def main():
audio = AudioPlayer()
audio.Play('CollisionWarning.mp3')
audio.Play('CollisionWarning.mp3')
time.sleep(2.3)
audio.Stop()
print('Killed')
audio.Play('CollisionWarning.mp3')
audio.Play('CollisionWarning.mp3')
print('wait 5')
time.sleep(5)
# audio.KillOtherSounds()
audio.Play('CollisionWarning.mp3')
audio.Play('CollisionWarning.mp3')
time.sleep(5)
# audio.KillOtherSounds()
audio.Play('CollisionWarning.mp3')
audio.Play('CollisionWarning.mp3')
time.sleep(5)
def main():
fileToPlay = "audio\\white_noise_300.0ms_1000_bandwidth.wav"
#fileToPlay = "audio\\wn_long.wav"
audio_player = AudioPlayer(fileToPlay)
trials = 1
try:
for i in range(13):
# i = 4
logging.info("Testing Line: " + str(i + 1))
audio_player.set_output_line(i + 1)
#audi_player.set_output_line(9)
for j in range(trials):
audio_player.play()
except KeyboardInterrupt:
parser.exit('\nInterrupted by user')
except Exception as e:
parser.exit(type(e).__name__ + ': ' + str(e))
except TypeError as e:
parser.exit(type(e).__name__ + ': ' + str(e))
def title_screen_loop(self,
pc_name_or_file_name: Optional[str] = None) -> None:
self.title_screen('Press any key')
# Wait for user input - any key press
while self.game_state.is_running:
waiting_for_user_input = True
for event in GameEvents.get_events():
if event.type == pygame.QUIT:
self.game_state.handle_quit(force=True)
elif event.type == pygame.KEYDOWN:
AudioPlayer().play_sound('select')
waiting_for_user_input = False
break
if waiting_for_user_input:
pygame.time.wait(25)
else:
break
# Prompt user for new game or to load a saved game
if pc_name_or_file_name is None:
# Get a list of the saved games
saved_game_files = glob.glob(
os.path.join(self.game_state.saves_path, '*.xml'))
saved_games = []
for saved_game_file in saved_game_files:
saved_games.append(os.path.basename(saved_game_file)[:-4])
while self.game_state.is_running:
menu_options = []
if 0 < len(saved_games):
menu_options.append('Continue a Quest')
menu_options.append('Begin a Quest')
if 0 < len(saved_games):
menu_options.append('Delete a Quest')
if self.game_state.should_add_math_problems_in_combat():
menu_options.append('Combat Mode: Math')
else:
menu_options.append('Combat Mode: Classic')
message_dialog = GameDialog.create_message_dialog()
message_dialog.add_menu_prompt(menu_options, 1)
message_dialog.blit(self.game_state.screen, True)
menu_result = self.gde.get_menu_result(message_dialog)
# print('menu_result =', menu_result, flush=True)
if menu_result == 'Continue a Quest':
message_dialog.clear()
message_dialog.add_menu_prompt(saved_games, 1)
message_dialog.blit(self.game_state.screen, True)
menu_result = self.gde.get_menu_result(message_dialog)
if menu_result is not None:
pc_name_or_file_name = menu_result
break
if menu_result == 'Delete a Quest':
message_dialog.clear()
message_dialog.add_menu_prompt(saved_games, 1)
message_dialog.blit(self.game_state.screen, True)
menu_result = self.gde.get_menu_result(message_dialog)
if menu_result is not None:
message_dialog.add_yes_no_prompt('Are you sure?')
message_dialog.blit(self.game_state.screen, True)
if self.gde.get_menu_result(message_dialog) == 'YES':
saved_games.remove(menu_result)
# Delete the save game by archiving it off
saved_game_file = os.path.join(
self.game_state.saves_path,
menu_result + '.xml')
self.game_state.archive_saved_game_file(
saved_game_file, 'deleted')
elif menu_result == 'Begin a Quest':
message_dialog.clear()
pc_name_or_file_name = self.gde.wait_for_user_input(
message_dialog, 'What is your name?')[0]
if pc_name_or_file_name in saved_games:
message_dialog.add_message(
'Thou hast already started a quest. Dost thou want to start over?'
)
message_dialog.add_yes_no_prompt()
message_dialog.blit(self.game_state.screen, True)
menu_result = self.gde.get_menu_result(message_dialog)
if menu_result == 'YES':
# Delete the existing save game by archiving it off
saved_game_file = os.path.join(
self.game_state.saves_path,
pc_name_or_file_name + '.xml')
self.game_state.archive_saved_game_file(
saved_game_file, 'deleted')
elif menu_result != 'NO':
continue
break
elif menu_result is not None and menu_result.startswith(
'Combat Mode:'):
self.game_state.toggle_should_add_math_problems_in_combat()
# Load the saved game
self.game_state.load(pc_name_or_file_name)
self.gde.refresh_game_state()
from AudioPlayer import AudioPlayer
lol = AudioPlayer()
lol.play_music('organ_background.wav')
lol.play_speech('process')
lol.run()
def scroll_tile(self) -> None:
transition: Optional[OutgoingTransition] = None
# Determine the destination tile and pixel count for the scroll
hero_dest_dat_tile = self.game_state.hero_party.members[
0].dest_pos_dat_tile
# Validate if the destination tile is navigable
movement_allowed = self.game_state.can_move_to_tile(hero_dest_dat_tile)
# Play a walking sound or bump sound based on whether the movement was allowed
audio_player = AudioPlayer()
movement_hp_penalty = 0
if movement_allowed:
dest_tile_type = self.game_state.get_tile_info(hero_dest_dat_tile)
for hero_idx in range(1, len(self.game_state.hero_party.members)):
hero = self.game_state.hero_party.members[hero_idx]
hero.dest_pos_dat_tile = self.game_state.hero_party.members[
hero_idx - 1].curr_pos_dat_tile
if hero.curr_pos_dat_tile != hero.dest_pos_dat_tile:
hero.direction = Direction.get_direction(
hero.dest_pos_dat_tile - hero.curr_pos_dat_tile)
# Determine if the movement should result in a transition to another map
map_size = self.game_state.game_map.size()
leaving_transition = self.game_state.game_info.maps[
self.game_state.get_map_name()].leaving_transition
if leaving_transition is not None:
if leaving_transition.bounding_box:
if not leaving_transition.bounding_box.collidepoint(
hero_dest_dat_tile.getAsIntTuple()):
transition = leaving_transition
elif (hero_dest_dat_tile[0] == 0 or hero_dest_dat_tile[1] == 0
or hero_dest_dat_tile[0] == map_size[0] - 1
or hero_dest_dat_tile[1] == map_size[1] - 1):
transition = leaving_transition
if transition is None:
# TODO: Uncomment following two statements to disable coordinate logging
#encounter_background = self.game_state.get_encounter_background(hero_dest_dat_tile)
#print('Check for transitions at', hero_dest_dat_tile, encounter_background, flush=True)
# See if this tile has any associated transitions
transition = self.game_state.get_point_transition(
hero_dest_dat_tile, filter_to_automatic_transitions=True)
else:
# Map leaving transition
# print('Leaving map', self.gameState.mapState.mapName, flush=True)
pass
# Check for tile penalty effects
if dest_tile_type.hp_penalty > 0 and not self.game_state.hero_party.is_ignoring_tile_penalties(
):
audio_player.play_sound('hit_lvl_1')
movement_hp_penalty = dest_tile_type.hp_penalty
# Check for any status effect changes or healing to occur as the party moves
has_low_health = self.game_state.hero_party.has_low_health()
dialog_from_inc_step_count = self.game_state.hero_party.inc_step_counter(
)
if has_low_health != self.game_state.hero_party.has_low_health():
# Change default dialog font color
self.gde.update_default_dialog_font_color()
# Redraw the map
self.game_state.draw_map(True)
if dialog_from_inc_step_count is not None:
self.gde.dialog_loop(dialog_from_inc_step_count)
else:
self.game_state.hero_party.members[0].dest_pos_dat_tile = \
self.game_state.hero_party.members[0].curr_pos_dat_tile
audio_player.play_sound('blocked')
first_frame = True
while self.game_state.hero_party.members[0].curr_pos_dat_tile != \
self.game_state.hero_party.members[0].dest_pos_dat_tile:
# Redraws the characters when movement_allowed is True
# print('advancing one tick in scroll_tile', flush=True)
if movement_allowed and movement_hp_penalty > 0 and first_frame:
flicker_surface = pygame.surface.Surface(
self.game_state.screen.get_size())
flicker_surface.fill('red')
flicker_surface.set_alpha(128)
self.game_state.advance_tick(update_map=True,
draw_map=True,
advance_time=False,
flip_buffer=False)
self.game_state.screen.blit(flicker_surface, (0, 0))
self.game_state.advance_tick(update_map=False,
draw_map=False,
advance_time=True,
flip_buffer=True)
pygame.time.wait(20)
first_frame = False
else:
self.game_state.advance_tick()
if movement_allowed:
# Apply health penalty and check for player death
for hero in self.game_state.hero_party.members:
if not hero.is_ignoring_tile_penalties():
hero.hp -= movement_hp_penalty
self.gde.update_default_dialog_font_color()
self.game_state.handle_death()
# At destination - now determine if an encounter should start
if not self.game_state.make_map_transition(transition):
# Check for special monster encounters
if (self.game_state.get_special_monster() is not None or
(len(self.game_state.get_tile_monsters()) > 0
and random.uniform(0, 1) < dest_tile_type.spawn_rate)):
# NOTE: Comment out the following line to disable encounters
self.game_state.initiate_encounter()
else:
for x in range(CharacterSprite.get_tile_movement_steps()):
self.game_state.advance_tick()
def exploring_loop(self) -> None:
map_name = ''
while self.game_state.is_running:
# Generate the map state a mode or map change
if map_name != self.game_state.get_map_name():
map_name = self.game_state.get_map_name()
# Play the music for the map
AudioPlayer().play_music(self.game_state.game_info.maps[
self.game_state.get_map_name()].music)
# Draw the map to the screen
self.game_state.draw_map()
if self.game_state.pending_dialog is not None:
self.gde.dialog_loop(self.game_state.pending_dialog)
self.game_state.pending_dialog = None
# Process events
# print(datetime.datetime.now(), 'exploring_loop: Getting events...', flush=True)
events = GameEvents.get_events(True)
changed_direction = False
for event in events:
# print('exploring_loop: Processing event', event, flush=True)
move_direction: Optional[Direction] = None
menu = False
talking = False
searching = False
opening = False
if event.type == pygame.QUIT:
self.game_state.handle_quit(force=True)
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.game_state.handle_quit()
elif event.key == pygame.K_RETURN:
menu = True
elif event.key == pygame.K_SPACE:
# Fast, smart interactions - skip launching the menu
if self.game_state.get_npc_to_talk_to() is not None:
talking = True
elif self.game_state.is_facing_openable_item():
opening = True
else:
searching = True
elif event.key == pygame.K_F1:
AudioPlayer().play_sound('select')
self.game_state.save(quick_save=True)
else:
move_direction = Direction.get_optional_direction(
event.key)
else:
# print('exploring_loop: Ignoring event', event, flush=True)
continue
# print(datetime.datetime.now(), 'exploring_loop: Processed event', event, flush=True)
# Clear queued events upon launching the menu
GameEvents.clear_events()
events = []
if move_direction:
if changed_direction or self.game_state.hero_party.members[0].curr_pos_dat_tile != \
self.game_state.hero_party.members[0].dest_pos_dat_tile:
# print('Ignoring move as another move is already in progress', flush=True)
continue
if move_direction != self.game_state.hero_party.members[
0].direction:
self.game_state.hero_party.members[
0].direction = move_direction
changed_direction = True
else:
self.game_state.hero_party.members[0].dest_pos_dat_tile = \
self.game_state.hero_party.members[0].curr_pos_dat_tile + move_direction.get_vector()
if menu:
AudioPlayer().play_sound('select')
GameDialog.create_exploring_status_dialog(
self.game_state.hero_party).blit(
self.game_state.screen, False)
menu_dialog = GameDialog.create_exploring_menu()
menu_dialog.blit(self.game_state.screen, True)
menu_result = self.gde.get_menu_result(menu_dialog)
# print('menu_result =', menu_result, flush=True)
if menu_result == 'TALK':
talking = True
elif menu_result == 'SEARCH':
searching = True
elif menu_result == 'OPEN':
opening = True
elif menu_result == 'STAIRS':
if not self.game_state.make_map_transition(
self.game_state.get_point_transition()):
self.gde.dialog_loop('There are no stairs here.')
elif menu_result == 'STATUS':
GameDialog.create_full_status_dialog(
self.game_state.hero_party).blit(
self.game_state.screen, True)
self.gde.wait_for_acknowledgement()
elif menu_result == 'SPELL':
# TODO: Need to choose the actor (spellcaster)
actor = self.game_state.hero_party.main_character
self.gde.set_actor(actor)
available_spell_names = actor.get_available_spell_names(
)
if len(available_spell_names) == 0:
self.gde.dialog_loop(
'Thou hast not yet learned any spells.')
else:
menu_dialog = GameDialog.create_menu_dialog(
Point(
-1, menu_dialog.pos_tile.y +
menu_dialog.size_tiles.h + 1), None,
'SPELLS', available_spell_names, 1)
menu_dialog.blit(self.game_state.screen, True)
menu_result = self.gde.get_menu_result(menu_dialog)
# print( 'menu_result =', menu_result, flush=True )
if menu_result is not None:
spell = self.game_state.game_info.spells[
menu_result]
if actor.mp >= spell.mp:
# TODO: Depending on the spell may need to select the target(s)
targets = [actor]
actor.mp -= spell.mp
self.gde.set_targets(
cast(List[CombatCharacterState],
targets))
self.gde.dialog_loop(spell.use_dialog)
GameDialog.create_exploring_status_dialog(
self.game_state.hero_party).blit(
self.game_state.screen, False)
else:
self.gde.dialog_loop(
'Thou dost not have enough magic to cast the spell.'
)
# Restore the default actor and targets after calling the spell
self.gde.restore_default_actor_and_targets()
elif menu_result == 'ITEM':
# TODO: Need to choose the hero to use an item
actor = self.game_state.hero_party.main_character
self.gde.set_actor(actor)
item_cols = 2
item_row_data = actor.get_item_row_data()
if len(item_row_data) == 0:
self.gde.dialog_loop(
'Thou dost not have any items.')
else:
menu_dialog = GameDialog.create_menu_dialog(
Point(
-1, menu_dialog.pos_tile.y +
menu_dialog.size_tiles.h + 1), None,
'ITEMS', item_row_data, item_cols,
GameDialogSpacing.OUTSIDE_JUSTIFIED)
menu_dialog.blit(self.game_state.screen, True)
item_result = self.gde.get_menu_result(menu_dialog)
# print('item_result =', item_result, flush=True)
if item_result is not None:
item_options = self.game_state.hero_party.main_character.get_item_options(
item_result)
if len(item_row_data) == 0:
self.gde.dialog_loop(
"The item vanished in [ACTOR]'s hands."
)
else:
menu_dialog = GameDialog.create_menu_dialog(
Point(
-1, menu_dialog.pos_tile.y +
menu_dialog.size_tiles.h + 1),
None, None, item_options,
len(item_options))
menu_dialog.blit(self.game_state.screen,
True)
action_result = self.gde.get_menu_result(
menu_dialog)
# print('action_result =', action_result, flush=True)
if action_result == 'DROP':
# TODO: Add an are you sure prompt here
self.game_state.hero_party.lose_item(
item_result)
elif action_result == 'EQUIP':
self.game_state.hero_party.main_character.equip_item(
item_result)
elif action_result == 'UNEQUIP':
self.game_state.hero_party.main_character.unequip_item(
item_result)
elif action_result == 'USE':
item = self.game_state.hero_party.get_item(
item_result)
if item is not None and isinstance(
item, Tool
) and item.use_dialog is not None:
# TODO: Depending on the item may need to select the target(s)
targets = [actor]
self.gde.set_targets(
cast(
List[CombatCharacterState],
targets))
self.gde.dialog_loop(
item.use_dialog)
else:
self.gde.dialog_loop(
'[ACTOR] studied the object and was confounded by it.'
)
# Restore the default actor and targets after using the item
self.gde.restore_default_actor_and_targets()
elif menu_result is not None:
print('ERROR: Unsupported menu_result =',
menu_result,
flush=True)
# Erase menu
self.game_state.draw_map()
pygame.display.flip()
if talking:
npc = self.game_state.get_npc_to_talk_to()
if npc:
if npc.npc_info.dialog is not None:
dialog = npc.npc_info.dialog
self.game_state.draw_map()
else:
dialog = ['They pay you no mind.']
else:
dialog = ['There is no one there.']
self.gde.dialog_loop(dialog, npc)
if searching or opening:
decorations = self.game_state.get_decorations()
if searching:
dialog = [
'[NAME] searched the ground and found nothing.'
]
else:
dialog = ['[NAME] found nothing to open.']
dest_tile = self.game_state.hero_party.members[0].curr_pos_dat_tile\
+ self.game_state.hero_party.members[0].direction.get_vector()
decorations += self.game_state.get_decorations(
dest_tile)
for decoration in decorations:
requires_removal = False
if decoration.type is not None:
requires_removal = (
decoration.type.remove_with_search
or decoration.type.remove_with_open
or decoration.type.remove_with_key)
if requires_removal:
if ((searching
and decoration.type.remove_with_search) or
(opening
and decoration.type.remove_with_open)):
if decoration.type.remove_sound is not None:
AudioPlayer().play_sound(
decoration.type.remove_sound)
self.game_state.remove_decoration(
decoration)
self.game_state.draw_map()
if decoration.dialog is not None:
dialog = decoration.dialog
else:
dialog = []
break
elif decoration.type.remove_with_key:
key_item = self.game_state.game_info.items[
'Key']
if self.game_state.hero_party.has_item(key_item.name) \
and isinstance(key_item, Tool) \
and key_item.use_dialog is not None:
dialog = [
'It is locked. Do you want to open it with a key?',
{
'Yes': key_item.use_dialog,
'No': None
}
]
else:
dialog = ['It is locked.']
break
if not requires_removal and decoration.dialog is not None:
dialog = decoration.dialog
self.gde.dialog_loop(dialog)
if self.game_state.hero_party.members[0].curr_pos_dat_tile != \
self.game_state.hero_party.members[0].dest_pos_dat_tile:
self.scroll_tile()
else:
# print('advancing one tick in exploring_loop', flush=True)
self.game_state.advance_tick()
def load_annotation(self):
if self.project is not None and \
self.annotation is not None:
self.ui.time_begin.setTime(self.annotation.annotation_time)
self.ui.textEdit.append(self.annotation.description)
if self.annotation.interaction is not None:
show_content = self.annotation.interaction
self.ui.ckb_compulsory.setChecked(show_content.compulsory)
self.ui.ckb_interactive.setChecked(show_content.interactive)
self.ui.ckb_allows_end_content.setChecked(show_content.allow_end_content)
self.ui.ckb_show_on_tv.setChecked(show_content.tv)
self.ui.ckb_show_on_mobile.setChecked(show_content.mobile)
self.ui.ckb_pause_main_video.setChecked(show_content.pause_main_video)
self.ui.ckb_viber.setChecked(show_content.viber_alert)
if show_content.sound_alert is not None:
self.ui.ckb_audio.setChecked(True)
self.audio_path = unicode(show_content.sound_alert)
self.audio_player = AudioPlayer()
self.ui.txt_sound.clear()
self.ui.txt_sound.append(os.path.split(self.audio_path)[1])
self.audio_player.load_audio(self.audio_path)
self.audio_player.setVisible(False)
if show_content.icon.image == model.Icon.INFO:
self.ui.radio_info.setChecked(True)
elif show_content.icon.image == model.Icon.SEXUAL:
self.ui.radio_sexual.setChecked(True)
elif show_content.icon.image == model.Icon.VIOLENCE:
self.ui.radio_violence.setChecked(True)
elif show_content.icon.image == model.Icon.YES:
self.ui.radio_yes.setChecked(True)
elif show_content.icon.image == model.Icon.NO:
self.ui.radio_no.setChecked(True)
else:
self.ui.radio_personalized.setChecked(True)
self.icon_path = show_content.icon.image
self.ui.radio_personalized.setIcon(QtGui.QIcon(self.icon_path))
self.ui.cmb_button.setEnabled(True)
if show_content.button is not None:
self.ui.cmb_button.setCurrentIndex(self.buttons.index(\
show_content.button))
if show_content.icon.position == model.Icon.BOT_LEFT:
self.ui.radio_bl.setChecked(True)
elif show_content.icon.position == model.Icon.BOT_RIGHT:
self.ui.radio_br.setChecked(True)
elif show_content.icon.position == model.Icon.TOP_LEFT:
self.ui.radio_tl.setChecked(True)
elif show_content.icon.position == model.Icon.TOP_RIGHT:
self.ui.radio_tr.setChecked(True)
elif show_content.icon.position == model.Icon.PERSONALIZED:
self.ui.radio_free_position.setChecked(True)
self.set_icon_boundaries(show_content.icon.bondaries)
before_str = str(show_content.icon.relative_time)
for index in xrange(self.ui.cmb_icon_before.count()):
str_index = str(self.ui.cmb_icon_before.itemText(index))
if before_str == str_index:
self.ui.cmb_icon_before.setCurrentIndex(index)
break
duration_str = str(show_content.icon.duration_time)
for index in xrange(self.ui.cmb_icon_duration.count()):
str_index = str(self.ui.cmb_icon_duration.itemText(index))
if duration_str == str_index:
self.ui.cmb_icon_duration.setCurrentIndex(index)
break
for content in show_content.contents:
self.add_media_widget.add_media_item(content)
if show_content.interaction_type == model.ShowContent.SHOW_CONTENT:
self.ui.radio_show.setChecked(True)
elif show_content.interaction_type == model.ShowContent.SKIP:
self.ui.radio_skip.setChecked(True)
self.ui.time_skip_point.setTime(util.sec_to_qtime(show_content.skip_point))
elif show_content.interaction_type == model.ShowContent.BACK_5:
self.ui.radio_back.setChecked(True)
elif show_content.interaction_type == model.ShowContent.BACK_TO:
self.ui.radio_back_to.setChecked(True)
self.ui.time_back_point.setTime(util.sec_to_qtime(show_content.back_point))
self.ui.time_back_limite.setTime(util.sec_to_qtime(show_content.back_limite))
self.ui.btn_preview.setEnabled(True)
self.add_media_widget.update_media_list()
# initialize input system
inputProcess = InputWorker()
inputProcess.start()
# initialize scanner
scannerProcess = ScannerWorker()
scannerProcess.start()
# merge the outputs into a single queue
qm = QueueMerge()
qm.add_input_queue(inputProcess.output_queue)
qm.add_input_queue(scannerProcess.output_queue)
# initialize audio player
player = AudioPlayer()
while True:
# Endless work loop. We read an event and act on it
event = qm.outputQueue.get()
# print(event.__str__())
if isinstance(event, ScannerEvent):
# Scanner event handler block
if isinstance(event, RootPathAppeared):
mdb.add_root_path(event.rootPath)
elif isinstance(event, RootPathRemoved):
mdb.remove_root_path(event.rootPath)
elif isinstance(event, AudioFileFound):
mdb.add_entry(event.path, event.gain_level)
print(event.path.__str__() + ": " + event.gain_level.__str__())
from EventParser import EventParser from Commentator import Commentator from AudioRenderer import AudioRenderer from AudioPlayer import AudioPlayer from threading import Thread from Queue import Queue import time eventQueue = Queue() commentatorQueue = Queue() rendererQueue = Queue() eventParser = EventParser(eventQueue) commentator = Commentator(eventQueue, commentatorQueue) audioRenderer = AudioRenderer(commentatorQueue, rendererQueue) audioPlayer = AudioPlayer(rendererQueue) eventParser.daemon = True eventParser.start() commentator.daemon = True commentator.start() audioRenderer.daemon = True audioRenderer.start() audioPlayer.daemon = True audioPlayer.start() while True: time.sleep(100)
def auralizer_thread(player, frame, cont):
prev_frame = frame[0]
while cont[0]:
t0 = time.time()
video_data = frame[0]
audio_data = auralizer.auralize(video_data, prev_frame)
print(audio_data)
player.play_multiple_chords(audio_data)
prev_frame = video_data
time.sleep(max(0, DELTA - (time.time() - t0)))
DELTA = 60 / AudioPlayer.BPM
if __name__ == "__main__":
player = AudioPlayer()
prev_frame = None
cont = [True]
video_stream = XiaoYiActionCamera().open_stream()
# video_stream = VideoStream(cv2.VideoCapture(0))
frame = video_stream.read_frame()
filters.registerMotionFilter(MotionFilter(frame.shape))
frame = [frame]
t1 = threading.Thread(target=stream_thread,
args=(video_stream, frame, cont))
t1.start()
# initialize pygame
pygame.init()
pygame.mouse.set_visible(False)
# init rendering screen
displaymode = (IMAGE_WIDTH, IMAGE_HEIGHT)
screen = pygame.display.set_mode(displaymode)
pygame.display.toggle_fullscreen()
# load cover image
cover = pygame.image.load(IMAGE_NAME).convert()
# set cover position
position = pygame.Rect((0, -IMAGE_HEIGHT, IMAGE_WIDTH, IMAGE_HEIGHT))
screen.blit(cover, position)
audioPlayer = AudioPlayer(AUDIO_NAME)
videoPlayer = VideoPlayer(VIDEO_NAME, IMAGE_WIDTH, IMAGE_HEIGHT, USE_VLC,
audioPlayer, pygame)
inputLen = getInputDevices()
prevInputLen = inputLen
# MAIN LOOP
while True:
pygame.mouse.set_cursor((8, 8), (0, 0), (0, 0, 0, 0, 0, 0, 0, 0),
(0, 0, 0, 0, 0, 0, 0, 0))
try:
if areThereNewInputsDevices():
hardKill()
killAll()
def initiate_encounter(
self,
monster_info: Optional[MonsterInfo] = None,
approach_dialog: Optional[DialogType] = None,
victory_dialog: Optional[DialogType] = None,
run_away_dialog: Optional[DialogType] = None,
encounter_music: Optional[str] = None,
message_dialog: Optional[GameDialog] = None) -> None:
# TODO: Make the conditions for no monsters configurable
if self.hero_party.has_item('Ball of Light'):
return
# Determine the monster party for the encounter
if monster_info is None:
# Check for special monsters
special_monster_info = self.get_special_monster()
if special_monster_info is not None:
monster_party = MonsterParty(
[MonsterState(special_monster_info)])
approach_dialog = special_monster_info.approach_dialog
victory_dialog = special_monster_info.victory_dialog
run_away_dialog = special_monster_info.run_away_dialog
else:
monster_info = self.game_info.monsters[random.choice(
self.get_tile_monsters())]
monster_party = MonsterParty([MonsterState(monster_info)])
else:
monster_party = MonsterParty([MonsterState(monster_info)])
if self.hero_party.is_monster_party_repelled(monster_party,
self.is_outside()):
return
# A combat encounter requires an encounter background
encounter_background = self.game_info.maps[
self.get_map_name()].encounter_background
if encounter_background is None:
encounter_background = self.get_encounter_background()
if encounter_background is None:
print(
'Failed to initiate combat encounter due to lack of encounter image in map '
+ self.get_map_name(),
flush=True)
return
# Perform the combat encounter
CombatEncounter.static_init('combat')
self.combat_encounter = CombatEncounter(
game_info=self.game_info,
game_state=self,
monster_party=monster_party,
encounter_background=encounter_background,
message_dialog=message_dialog,
approach_dialog=approach_dialog,
victory_dialog=victory_dialog,
run_away_dialog=run_away_dialog,
encounter_music=encounter_music)
self.combat_encounter.encounter_loop()
self.combat_encounter = None
# Play the music for the current map
AudioPlayer().play_music(
self.game_info.maps[self.get_map_name()].music)
# Clear event queue
GameEvents.clear_events()
def main():
# set path where the results are stored
results_path = Path('./results_inear_exp/')
results_path.mkdir(parents=False, exist_ok=True)
# We have 2 conditions (monaural, binaural). In each condition, two different sounds are randomly played
conditions = ['mono', 'bin']
# set number of trials per condition. each sound is then played N_TRIALS/2
# make sure this numer is divideable by 2 (sounds) and 13 (number of speakers)
assert (N_TRIALS % 2 == 0 and N_TRIALS % N_SPEAKERS == 0)
# ask for user id
print(Fore.GREEN + 'Please enter participant id: ' + Style.RESET_ALL)
user_id = input()
# create the path to the data file
date = datetime.now()
resultsFile = 'userid_' + user_id + '_date_' + date.strftime(
'%d.%m.%Y') + '_time_' + date.strftime('%H.%M') + '.csv'
resultsStoredIn = results_path / resultsFile
# start by creating a new data file to store the data.
# data is stored continously, so in case of a crash the data is not lost.
with open(resultsStoredIn.as_posix(), mode='w', newline='') as resFile:
# create the file
res_file_writer = csv.writer(resFile,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_MINIMAL)
# add headers
res_file_writer.writerow([
'trial', # Trial
'line_number', # line number (speaker number)
'user_estimate', # perceived elevation in degree
'sound_type', # type of the sound
'condition', # condition
'reaction_time', # time for participant to respond
'user_id' # id of the user
])
# Ask for dominant ear
# left channel is 0, right channel is 1
print(Fore.GREEN +
'Which is the dominat ear (0 for right, 1 for left): ' +
Style.RESET_ALL)
dominant_ear = int(input())
assert (dominant_ear == 0 or dominant_ear == 1)
### Monaural condition is the first ###
clear_screen()
print(Fore.GREEN + 'All set. Experiments is about to start...' +
Style.RESET_ALL)
# Initialize AudioPlayer
audio_player = AudioPlayer(dummy=dummy_audio_player)
# Initialize Arduino Reader
arduino_reader = ArduinoReader(port=ARDUINO_PORT,
dummy=dummy_arduino_reader)
# Initialize the audio player
audio_player = AudioPlayer(dummy=dummy_audio_player)
# Zeroing of the angle encoder
print(
Fore.RED +
'Confirm that the handle is in zero position (pointing upwards)' +
Style.RESET_ALL)
input()
arduino_reader.zeroing()
clear_screen()
print(Back.RED + '###### Experiment is starting NOW ######' +
Style.RESET_ALL)
print(Back.RED + '########################################' +
Style.RESET_ALL)
print(Back.RED + '########################################' +
Style.RESET_ALL)
print(Back.RED + '----------------------------------------' +
Style.RESET_ALL)
print(
Back.RED +
'Recording of sounds will start whne participant presses button once'
+ Style.RESET_ALL)
# Wait for the participant to press button
arduino_reader.get_data()
# Start the recording process
# recording_data_path = record_sounds(N_SPEAKERS, audio_player=audio_player, results_path=results_path, user_id=user_id)
recording_data_path = recording_data_path = results_path / (
'participant_' + user_id)
clear_screen()
print(Back.GREEN + 'Recording successful!' + Style.RESET_ALL)
input()
clear_screen()
print(Back.RED + 'Provide participant with headphones.' +
Style.RESET_ALL)
print(Back.RED +
'Make sure that left and right headphones are place correctly.' +
Style.RESET_ALL)
input()
clear_screen()
###### Test correct working of headphones ######
print(Back.RED + 'Testing headphones!' + Style.RESET_ALL)
###### Play recorded sound ######
file_name = 'userid_' + str(user_id) + '_speakerNum_' + str(
5) + '_soundType_white.wav'
file_to_play = recording_data_path / file_name
# Extract data and sampling rate from file
data, fs = sf.read(file_to_play.as_posix(), dtype='int16')
sd.play(data, fs)
print(
Back.RED +
'Ask participant if sound from headphones can be heard well (y) or (n)?'
+ Style.RESET_ALL)
hear_well = input()
if hear_well == 'y':
print(Back.GREEN + 'Very Well...' + Style.RESET_ALL)
else:
print(Back.RED + 'Aborting the experiment....' + Style.RESET_ALL)
print(Back.RED + 'Redo the recording procedure!' + Style.RESET_ALL)
exit()
clear_screen()
print(Back.RED + '###### Experiment is starting NOW ######' +
Style.RESET_ALL)
print(Back.RED + '########################################' +
Style.RESET_ALL)
print(Back.RED + '########################################' +
Style.RESET_ALL)
print(Back.RED + '----------------------------------------' +
Style.RESET_ALL)
print(Fore.GREEN +
'Participant starts experiment by pressing the button \n' +
Style.RESET_ALL)
# wait for button press of participant
arduino_reader.get_data()
# create tupels of all speakers with all sound types 10 speakers * 2 sounds * conditions = 20 tuples
stimulus_sequence = [(i, j, k) for i in np.arange(N_SPEAKERS)
for j in np.arange(2) for k in conditions]
# We need to walk over this sequence to ensure that we tested all speakers, conditions and sounds
random_sequence = create_rand_balanced_order(n_items=N_SPEAKERS * 2 *
2,
n_trials=N_TRIALS * 2)
print(stimulus_sequence)
print(random_sequence)
print(len(random_sequence))
# walk over random sequence
for i_trial, i_tuple in enumerate(random_sequence):
# decode the stimulus sequence
num_speaker = stimulus_sequence[i_tuple][0]
sound_type = stimulus_sequence[i_tuple][1]
cond = stimulus_sequence[i_tuple][2]
if sound_type == 1:
sound_type_name = 'rippled'
else:
sound_type_name = 'white'
print(Fore.GREEN + 'The following condition is tested: ' + cond +
'\n' + Style.RESET_ALL)
###### Play recorded sound here ######
file_name = 'userid_' + str(user_id) + '_speakerNum_' + str(
num_speaker) + '_soundType_' + sound_type_name + '.wav'
file_to_play = recording_data_path / file_name
# Extract data and sampling rate from file
data, fs = sf.read(file_to_play.as_posix(), dtype='int16')
# remove one side in mono condition
if cond == 'mono':
# left channel is 0, right channel is 1
data[:, dominant_ear] = 0
sd.play(data, fs)
# start measuring the time
ts = datetime.now()
# get participant response
print('Waiting for participant response...')
user_estimate = arduino_reader.get_data()
# calculate reaction time
reaction_time = (datetime.now() - ts).total_seconds()
# create data entry and add it to file
result_item = [
i_trial, # Trial
num_speaker, # line number (speaker number)
user_estimate, # perceived elevation in degree
sound_type_name, # type of the sound
cond, # condition
reaction_time,
user_id # id of the user
]
# write it to file
res_file_writer.writerow(result_item)
# wait some time until playing the next sound
time.sleep(0.5)
print(Back.GREEN + 'Experiment has finished' + Style.RESET_ALL)
def __init__(self):
super().__init__()
self.setupUi(self)
self.text_to_speach_list = [
self.Text_to_Speech, self.Text_to_Speech_2, self.Text_to_Speech_3,
self.Text_to_Speech_4
]
self.canvas = Canvas()
self.canvas_comp = QtWidgets.QVBoxLayout(self.Mel_spec)
self.canvas_comp.addWidget(self.canvas)
self.toolbar = NavigationToolbar(self.canvas, self)
self.canvas_comp.addWidget(self.toolbar)
self.canvas1 = Canvas_spectr(self, width=21, height=4)
self.Spectrum.setStyleSheet(
" background-color: none; selection-background-color: none;")
self.canvas1.setStyleSheet(
"background-color: none; selection-background-color: none;")
self.SpectrAudio = QtWidgets.QStackedLayout(self.Spectrum)
self.SpectrAudio.insertWidget(0, self.canvas1)
self._Syntethis = Synthesis()
self.player = AudioPlayer()
self.speakerlist = SpeakerList()
self.speakerlist.setStyleSheet("border: 0; height: 50px;")
self.speakerlist_layout = QtWidgets.QVBoxLayout(self.SpeakerList)
self.speakerlist_layout.addWidget(self.speakerlist)
self.speakerlist.set_model.connect(self._Syntethis.T2LoadModel)
self.speakerlist.load_data()
self.LoadWaveGlowModel.clicked.connect(self.WGSelectModel)
self.Syntethis.clicked.connect(self.SyntethisFunc)
self.PlayWav.clicked.connect(self.playSpeeck)
self.output_directory_button.clicked.connect(self._output_directory)
self.log_directory_button.clicked.connect(self._log_directory)
self.checkpoint_path_Box.stateChanged.connect(
self._path_checkpoint_enabled)
self.path_checkpoint_button.clicked.connect(self._path_checkpoint)
self.training_files_button.clicked.connect(self._training_files)
self.validation_files_button.clicked.connect(self._validation_files)
self.AudioParametersBox.currentIndexChanged.connect(
self._Syntethis.SetCurrentAudioParameters)
self.AudioParametersBox.currentIndexChanged.connect(
self.SetAudioParameters)
self.StartTrain.clicked.connect(self._start_train)
self.SaveAudio.clicked.connect(self.saveFile)
self.Stop.clicked.connect(self._stop_train)
self.VolumeSlider.valueChanged.connect(self.player.set_voulume)
self.PauseWav.clicked.connect(self.player.pause)
self.StopWav.clicked.connect(self.player.stop)
self.double_slider = DoubleSlider()
self.double_slider.setOrientation(QtCore.Qt.Horizontal)
self.SpectrAudio.insertWidget(0, self.double_slider)
self.SpectrAudio.setStackingMode(self.SpectrAudio.StackAll)
self.SpectrAudio.setCurrentWidget(self.double_slider)
self.double_slider.setStyleSheet(
"QSlider{ border: 0; background-color: none; selection-background-color: none;}"
"QSlider::groove:horizontal {border: 1px solid #000000; }"
"QSlider::handle:horizontal{ border: 10px solide #5c5c5c;"
"background: qlineargradient(x1:0, y1:0, x2:1, y2:1, stop:0 #b4b4b4, stop:1 #8f8f8f); }"
" }"
"QSlider::add-page:horizontal{ background: rgba(255, 255, 255, 10%);}"
"QSlider::sub-page:horizontal{ background: rgba(255,140,0, 40%);}")
self.player.positionChanged.connect(self.setPosMax)
self.StartTrain.setToolTip(
"checkpoint_path + warm_start - если модель уже обученная и начать обучение новой модели \n"
" только checkpoint_path - не модель обученная модель а точка остановки, продолжит \n "
"без checkpoint_path и warm_start - модель с нуля \n ")
self.SetAudioParameters()
self.load_data()
""" This Script Tests the functionality of the AudioPlayer module.
Warning: there is a very real danger of screaming feedback, so
lower speaker volume before using!
"""
from AudioPlayer import AudioPlayer
player = AudioPlayer.AudioPlayer()
player.load(
"/Users/nolanmeske/Documents/Music Projects/4280/Orbital/renders/Orbital.wav"
)
player.play()
del player
def __init__(self):
self.audioPlayer = AudioPlayer()
self.update_song_list()
from EventParser import EventParser
from Commentator import Commentator
from AudioRenderer import AudioRenderer
from AudioPlayer import AudioPlayer
from threading import Thread
from Queue import Queue
import time
eventQueue = Queue()
commentatorQueue = Queue()
rendererQueue = Queue()
eventParser = EventParser(eventQueue)
commentator = Commentator(eventQueue, commentatorQueue)
audioRenderer = AudioRenderer(commentatorQueue, rendererQueue)
audioPlayer = AudioPlayer(rendererQueue)
eventParser.daemon = True
eventParser.start()
commentator.daemon = True
commentator.start()
audioRenderer.daemon = True
audioRenderer.start()
audioPlayer.daemon = True
audioPlayer.start()
while True:
time.sleep(100)
class ShowContent(QtGui.QDialog):
def __init__(self, project=None, annotation=None, interaction=None, parent=None):
super(ShowContent, self).__init__(parent)
self.is_editing_time = False
self.project = project
self.annotation = annotation
self.interaction = interaction
self.ui = Ui_ShowContent()
self.ui.setupUi(self)
self.ui.btn_preview.setVisible(False)
self.init_ui()
self.audio_path = None
self.buttons = ["RED", "GREEN", "BLUE", "YELLOW"]
self.load_annotation()
self.result = None
def timer_focus_in(self):
self.player.pause()
self.is_editing_time = True
def load_annotation(self):
if self.project is not None and \
self.annotation is not None:
self.ui.time_begin.setTime(self.annotation.annotation_time)
self.ui.textEdit.append(self.annotation.description)
if self.annotation.interaction is not None:
show_content = self.annotation.interaction
self.ui.ckb_compulsory.setChecked(show_content.compulsory)
self.ui.ckb_interactive.setChecked(show_content.interactive)
self.ui.ckb_allows_end_content.setChecked(show_content.allow_end_content)
self.ui.ckb_show_on_tv.setChecked(show_content.tv)
self.ui.ckb_show_on_mobile.setChecked(show_content.mobile)
self.ui.ckb_pause_main_video.setChecked(show_content.pause_main_video)
self.ui.ckb_viber.setChecked(show_content.viber_alert)
if show_content.sound_alert is not None:
self.ui.ckb_audio.setChecked(True)
self.audio_path = unicode(show_content.sound_alert)
self.audio_player = AudioPlayer()
self.ui.txt_sound.clear()
self.ui.txt_sound.append(os.path.split(self.audio_path)[1])
self.audio_player.load_audio(self.audio_path)
self.audio_player.setVisible(False)
if show_content.icon.image == model.Icon.INFO:
self.ui.radio_info.setChecked(True)
elif show_content.icon.image == model.Icon.SEXUAL:
self.ui.radio_sexual.setChecked(True)
elif show_content.icon.image == model.Icon.VIOLENCE:
self.ui.radio_violence.setChecked(True)
elif show_content.icon.image == model.Icon.YES:
self.ui.radio_yes.setChecked(True)
elif show_content.icon.image == model.Icon.NO:
self.ui.radio_no.setChecked(True)
else:
self.ui.radio_personalized.setChecked(True)
self.icon_path = show_content.icon.image
self.ui.radio_personalized.setIcon(QtGui.QIcon(self.icon_path))
self.ui.cmb_button.setEnabled(True)
if show_content.button is not None:
self.ui.cmb_button.setCurrentIndex(self.buttons.index(\
show_content.button))
if show_content.icon.position == model.Icon.BOT_LEFT:
self.ui.radio_bl.setChecked(True)
elif show_content.icon.position == model.Icon.BOT_RIGHT:
self.ui.radio_br.setChecked(True)
elif show_content.icon.position == model.Icon.TOP_LEFT:
self.ui.radio_tl.setChecked(True)
elif show_content.icon.position == model.Icon.TOP_RIGHT:
self.ui.radio_tr.setChecked(True)
elif show_content.icon.position == model.Icon.PERSONALIZED:
self.ui.radio_free_position.setChecked(True)
self.set_icon_boundaries(show_content.icon.bondaries)
before_str = str(show_content.icon.relative_time)
for index in xrange(self.ui.cmb_icon_before.count()):
str_index = str(self.ui.cmb_icon_before.itemText(index))
if before_str == str_index:
self.ui.cmb_icon_before.setCurrentIndex(index)
break
duration_str = str(show_content.icon.duration_time)
for index in xrange(self.ui.cmb_icon_duration.count()):
str_index = str(self.ui.cmb_icon_duration.itemText(index))
if duration_str == str_index:
self.ui.cmb_icon_duration.setCurrentIndex(index)
break
for content in show_content.contents:
self.add_media_widget.add_media_item(content)
if show_content.interaction_type == model.ShowContent.SHOW_CONTENT:
self.ui.radio_show.setChecked(True)
elif show_content.interaction_type == model.ShowContent.SKIP:
self.ui.radio_skip.setChecked(True)
self.ui.time_skip_point.setTime(util.sec_to_qtime(show_content.skip_point))
elif show_content.interaction_type == model.ShowContent.BACK_5:
self.ui.radio_back.setChecked(True)
elif show_content.interaction_type == model.ShowContent.BACK_TO:
self.ui.radio_back_to.setChecked(True)
self.ui.time_back_point.setTime(util.sec_to_qtime(show_content.back_point))
self.ui.time_back_limite.setTime(util.sec_to_qtime(show_content.back_limite))
self.ui.btn_preview.setEnabled(True)
self.add_media_widget.update_media_list()
@QtCore.pyqtSlot(int)
def update_time_edit(self, time):
if not self.is_editing_time:
time_edit = self.ui.time_media
time_edit.setTime(QtCore.QTime().addMSecs(time))
@QtCore.pyqtSlot(QtCore.QTime)
def editing_time(self, time):
'''if self.is_editing_time:
total_time = self.player.player.mediaObject().totalTime()
max_time = QtCore.QTime(0,0,0).addMSecs(total_time)
self.ui.time_edit.setTimeRange(QtCore.QTime(0,0,0), max_time)
msec = time.hour()
msec = time.minute() + msec*60
msec = time.second() + msec*60
msec = msec*1000 + time.msec()
self.ui.video_player.seek(msec)'''
pass
def get_result(self):
return self.result
def set_icon_boundaries(self, bound):
self.lbl_icon.move(bound.left, bound.top)
self.lbl_icon.resize(bound.width, bound.height)
def get_icon_bondaries(self):
bound = Bondaries()
qpoint = self.lbl_icon.pos()
qsize = self.lbl_icon.size()
bound.width = qsize.width()
bound.height = qsize.height()
bound.left = qpoint.x()
bound.top = qpoint.y()
qsize = self.lbl_screen.size()
bound.screen_width, bound.screen_height = qsize.width(), qsize.height()
print bound
return bound
def init_ui(self):
self.setFixedSize(self.size())
self.ui.radio_info.setChecked(True)
self.ui.radio_tl.setChecked(True)
self.ui.btn_choose_icon.setEnabled(False)
self.ui.tabs.setCurrentIndex(0)
layout = QtGui.QHBoxLayout()
self.ui.tab_content.setLayout(layout)
self.add_media_widget = AddMediaWidget(self.project, self.annotation)
layout.addWidget(self.add_media_widget)
self.ui.radio_personalized.toggled.connect(self.personalized_choosed)
self.ui.btn_choose_icon.clicked.connect(self.choose_icon)
self.lbl_screen = QtGui.QLabel(self.ui.widget_icon)
self.lbl_screen.resize(self.ui.widget_icon.size())
self.lbl_screen.setStyleSheet('background-color: rgb(0, 0, 0); \
border-color: rgb(255, 255, 255);\
font: 75 28pt "Ubuntu";\
color: rgb(255, 255, 127);')
self.lbl_screen.setAlignment(QtCore.Qt.AlignCenter)
self.lbl_screen.setText("Tela")
self.lbl_icon = MovebleLabel(u"", self.ui.widget_icon)
self.lbl_icon.resize(30,30)
self.lbl_icon.move(10,10)
self.lbl_icon.setStyleSheet('background-color: rgb(255, 255, 0);\
border-color: rgb(255, 255, 255);\
font: 75 8pt "Ubuntu";\
color: rgb(0, 0, 0);')
self.lbl_icon.setEnabled(False)
self.ui.radio_bl.toggled.connect(self.selected_bl)
self.ui.radio_br.toggled.connect(self.selected_br)
self.ui.radio_tr.toggled.connect(self.selected_tr)
self.ui.radio_tl.toggled.connect(self.selected_tl)
self.ui.radio_free_position.toggled.connect(self.selected_free_position)
self.ui.btn_ok.clicked.connect(self.ok_pressed)
self.ui.btn_cancel.clicked.connect(self.cancel_pressed)
self.ui.btn_preview.clicked.connect(self.preview)
self.ui.btn_preview.setEnabled(False)
#player_holder = self.ui.player_widget
#layout = QtGui.QVBoxLayout()
self.player = VideoPlayer(parent=self.ui.player_widget)
#layout.addWidget(self.player)
#self.ui.tab_interaction.setLayout(layout)
self.player.load_video(self.project.main_media)
self.player.player.mediaObject().tick.connect(self.update_time_edit)
#self.player.move(50,0)
self.ui.radio_show.toggled.connect(self.selected_show)
self.ui.radio_back.toggled.connect(self.selected_back)
self.ui.radio_back_to.toggled.connect(self.selected_back_to)
self.ui.radio_skip.toggled.connect(self.selected_skip)
self.ui.btn_back_limite.clicked.connect(self.use_time_for_back_limite)
self.ui.btn_back_point.clicked.connect(self.use_time_for_back_point)
self.ui.btn_skip.clicked.connect(self.use_time_for_skip)
self.ui.time_media.timeChanged.connect(self.editing_time)
self.ui.time_media.installEventFilter(self)
self.ui.time_media.setEnabled(False)
self.ui.radio_show.setChecked(True)
self.ui.ckb_audio.toggled.connect(self.toogled_audio_alert)
self.ui.btn_choose_audio.clicked.connect(self.choose_audio)
self.ui.btn_play_audio.clicked.connect(self.play_audio)
@QtCore.pyqtSlot(bool)
def toogled_audio_alert(self, value):
if value:
self.ui.btn_choose_audio.setEnabled(True)
self.ui.btn_play_audio.setEnabled(True)
self.ui.txt_sound.setEnabled(True)
else:
self.ui.btn_choose_audio.setEnabled(False)
self.ui.btn_play_audio.setEnabled(False)
self.ui.txt_sound.setEnabled(False)
@QtCore.pyqtSlot()
def choose_audio(self):
path = QtGui.QFileDialog.getOpenFileName(self,
u'Selecione um áudio',
HOME_DIRECTORY,
model.CONTENT_TYPES[model.Media.AUDIO])
if path == None:
return
self.audio_path = unicode(path)
self.audio_player = AudioPlayer()
self.ui.txt_sound.clear()
self.ui.txt_sound.append(os.path.split(self.audio_path)[1])
self.audio_player.load_audio(self.audio_path)
self.audio_player.setVisible(False)
@QtCore.pyqtSlot()
def play_audio(self):
self.audio_player.play()
def eventFilter(self, myObject, event):
if myObject == self.ui.time_media:
if event.type() == QtCore.QEvent.FocusIn:
self.timer_focus_in()
elif event.type() == QtCore.QEvent.FocusOut:
pass
return False
@QtCore.pyqtSlot()
def use_time_for_back_limite(self):
self.ui.time_back_limite.setTime(self.ui.time_media.time())
def use_time_for_back_point(self):
self.ui.time_back_point.setTime(self.ui.time_media.time())
def use_time_for_skip(self):
self.ui.time_skip_point.setTime(self.ui.time_media.time())
@QtCore.pyqtSlot(bool)
def selected_show(self, value):
self.player.stop()
self.player.setVisible(False)
self.ui.time_back_limite.setVisible(False)
self.ui.time_back_point.setVisible(False)
self.ui.time_skip_point.setVisible(False)
self.ui.time_media.setVisible(False)
self.ui.lbl_back_limite.setVisible(False)
self.ui.lbl_back_point.setVisible(False)
self.ui.lbl_current_time.setVisible(False)
self.ui.lbl_skip.setVisible(False)
self.ui.btn_skip.setVisible(False)
self.ui.btn_back_limite.setVisible(False)
self.ui.btn_back_point.setVisible(False)
@QtCore.pyqtSlot(bool)
def selected_back(self, value):
self.player.stop()
self.player.setVisible(False)
self.ui.time_back_limite.setVisible(False)
self.ui.time_back_point.setVisible(False)
self.ui.time_skip_point.setVisible(False)
self.ui.time_media.setVisible(False)
self.ui.lbl_back_limite.setVisible(False)
self.ui.lbl_back_point.setVisible(False)
self.ui.lbl_current_time.setVisible(False)
self.ui.lbl_skip.setVisible(False)
self.ui.btn_skip.setVisible(False)
self.ui.btn_back_limite.setVisible(False)
self.ui.btn_back_point.setVisible(False)
@QtCore.pyqtSlot(bool)
def selected_back_to(self, value):
self.player.stop()
self.player.setVisible(True)
self.ui.time_back_limite.setVisible(True)
self.ui.time_back_point.setVisible(True)
self.ui.time_skip_point.setVisible(False)
self.ui.time_media.setVisible(True)
self.ui.lbl_back_limite.setVisible(True)
self.ui.lbl_back_point.setVisible(True)
self.ui.lbl_current_time.setVisible(True)
self.ui.lbl_skip.setVisible(False)
self.ui.btn_skip.setVisible(False)
self.ui.btn_back_limite.setVisible(True)
self.ui.btn_back_point.setVisible(True)
@QtCore.pyqtSlot(bool)
def selected_skip(self, value):
self.player.stop()
self.player.setVisible(True)
self.ui.time_back_limite.setVisible(False)
self.ui.time_back_point.setVisible(False)
self.ui.time_skip_point.setVisible(True)
self.ui.time_media.setVisible(True)
self.ui.lbl_back_limite.setVisible(False)
self.ui.lbl_back_point.setVisible(False)
self.ui.lbl_current_time.setVisible(True)
self.ui.lbl_skip.setVisible(True)
self.ui.btn_skip.setVisible(True)
self.ui.btn_back_limite.setVisible(False)
self.ui.btn_back_point.setVisible(False)
@QtCore.pyqtSlot()
def ok_pressed(self):
show_content = model.ShowContent()
show_content.compulsory = self.ui.ckb_compulsory.isChecked()
show_content.interactive = self.ui.ckb_interactive.isChecked()
show_content.allow_end_content = self.ui.ckb_allows_end_content.isChecked()
show_content.tv = self.ui.ckb_show_on_tv.isChecked()
show_content.mobile = self.ui.ckb_show_on_mobile.isChecked()
show_content.pause_main_video = self.ui.ckb_pause_main_video.isChecked()
show_content.viber_alert = self.ui.ckb_viber.isChecked()
icon = model.Icon()
if self.ui.radio_personalized.isChecked():
self.icon_path = util.copy_to_directory(self.project, unicode(self.icon_path))
icon.image = self.icon_path
show_content.button = str(self.ui.cmb_button.currentText())
elif self.ui.radio_info.isChecked():
icon.image = model.Icon.INFO
show_content.button = "GREEN"
elif self.ui.radio_sexual.isChecked():
icon.image = model.Icon.SEXUAL
show_content.button = "RED"
elif self.ui.radio_violence.isChecked():
icon.image = model.Icon.VIOLENCE
show_content.button = "RED"
elif self.ui.radio_yes.isChecked():
icon.image = model.Icon.YES
show_content.button = "GREEN"
elif self.ui.radio_no.isChecked():
icon.image = model.Icon.NO
show_content.button = "RED"
icon.relative_time = int(self.ui.cmb_icon_before.itemText(
self.ui.cmb_icon_before.currentIndex()))
icon.duration_time = int(self.ui.cmb_icon_duration.itemText(
self.ui.cmb_icon_duration.currentIndex()))
icon.bondaries = self.get_icon_bondaries()
if self.ui.radio_bl.isChecked():
icon.position = model.Icon.BOT_LEFT
elif self.ui.radio_br.isChecked():
icon.position = model.Icon.BOT_RIGHT
elif self.ui.radio_tl.isChecked():
icon.position = model.Icon.TOP_LEFT
elif self.ui.radio_tr.isChecked():
icon.position = model.Icon.TOP_RIGHT
elif self.ui.radio_free_position.isChecked():
icon.position = model.Icon.PERSONALIZED
show_content.icon = icon
if self.ui.ckb_audio.isChecked():
if self.audio_path is not None:
realpath = util.copy_to_directory(self.project,
self.audio_path)
show_content.sound_alert = realpath
for media in self.add_media_widget.medias:
show_content.add_content(media)
self.annotation.description = unicode(self.ui.textEdit.toPlainText())
self.annotation.interaction = show_content
self.annotation.annotation_time = self.ui.time_begin.time()
self.annotation.description = self.ui.textEdit.toPlainText()
if self.ui.radio_show.isChecked():
show_content.interaction_type = model.ShowContent.SHOW_CONTENT
elif self.ui.radio_skip.isChecked():
show_content.interaction_type = model.ShowContent.SKIP
show_content.skip_point = util.qtime_to_sec(self.ui.time_skip_point.time())
elif self.ui.radio_back.isChecked():
show_content.interaction_type = model.ShowContent.BACK_5
elif self.ui.radio_back_to.isChecked():
print 'back_to'
show_content.interaction_type = model.ShowContent.BACK_TO
show_content.back_point = util.qtime_to_sec(self.ui.time_back_point.time())
show_content.back_limite = util.qtime_to_sec(self.ui.time_back_limite.time())
self.result = show_content
self.close()
@QtCore.pyqtSlot()
def preview(self):
import generation
try:
begintime = util.qtime_to_sec(self.annotation.annotation_time)
begintime = begintime - int(self.ui.cmb_icon_before.currentText()) - 3
nclgenerator = generation.NclGenerator(self.project,
generation.GenerationOptions())
print self.project.directory
nclgenerator.dump_file(os.path.join(self.project.directory,
'medias', 'main.ncl'),
begintime)
current_path = os.path.dirname(os.path.realpath(__file__))
src = os.path.join(os.path.split(current_path)[0], 'files', 'medias', "connBase.ncl")
dst = os.path.join(self.project.directory, "medias", "connBase.ncl")
import shutil
shutil.copy(src, dst)
except:
logging.exception('Error Generating the NCL')
QtGui.QMessageBox.warning(self, u'Gerando NCL', u"Aconteceu um erro ao gerar o documento multimídia", QtGui.QMessageBox.Ok)
return
import subprocess as sp
html = os.path.join(self.project.directory, "index.html")
current_path = os.path.dirname(os.path.realpath(__file__))
script_path = os.path.join(os.path.split(current_path)[0], 'browser.py')
sp.Popen(['python', script_path, html])
@QtCore.pyqtSlot()
def cancel_pressed(self):
self.close()
@QtCore.pyqtSlot(bool)
def selected_bl(self, value):
self.lbl_icon.resize(30,30)
self.lbl_icon.move(10,150)
self.lbl_icon.setEnabled(False)
@QtCore.pyqtSlot(bool)
def selected_br(self, value):
self.lbl_icon.resize(30,30)
self.lbl_icon.move(300,150)
self.lbl_icon.setEnabled(False)
@QtCore.pyqtSlot(bool)
def selected_tr(self, value):
self.lbl_icon.resize(30,30)
self.lbl_icon.move(300,10)
self.lbl_icon.setEnabled(False)
@QtCore.pyqtSlot(bool)
def selected_tl(self, value):
self.lbl_icon.resize(30,30)
self.lbl_icon.move(10,10)
self.lbl_icon.setEnabled(False)
@QtCore.pyqtSlot(bool)
def selected_free_position(self, value):
self.lbl_icon.setEnabled(True)
@QtCore.pyqtSlot()
def choose_icon(self):
path = QtGui.QFileDialog.getOpenFileName(self,
u'Selecione uma imagem',
HOME_DIRECTORY,
model.CONTENT_TYPES[model.Media.IMAGE])
if path == None:
return
self.icon_path = path
self.ui.radio_personalized.setIcon(QtGui.QIcon(path))
self.ui.radio_personalized.setText("...")
@QtCore.pyqtSlot(bool)
def personalized_choosed(self, checked):
if checked:
self.ui.btn_choose_icon.setEnabled(True)
else:
self.ui.btn_choose_icon.setEnabled(False)
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument(
'-g',
'--gamepad',
help='Gamepad (if present) will be used for providing user inputs',
action='store_true',
default=None)
parser.add_argument('-k',
'--keyboard',
dest='gamepad',
help='Keyboard will be used for providing user inputs',
action='store_false')
parser.add_argument('-u',
'--force-use-unlicensed-assets',
help='Force using the unlicensed assets',
action='store_true',
default=False)
parser.add_argument('-p',
'--skip_pip_install',
dest='perform_pip_install',
help='Skip performing a pip install',
action='store_false',
default=True)
parser.add_argument('save',
nargs='?',
help='Load a specific saved game file')
args = parser.parse_args()
# print('args =', args, flush=True)
# Determine if application is a script file or frozen exe
if getattr(sys, 'frozen', False):
# Executing as a pyinstaller binary executable
application_path = os.path.dirname(sys.executable)
elif __file__:
# Normal execution
application_path = os.path.dirname(__file__)
# Load required Python libraries
if args.perform_pip_install:
subprocess.check_call([
sys.executable, '-m', 'pip', 'install', '-U', '-r',
os.path.join(application_path, 'requirements.txt')
],
stdout=subprocess.DEVNULL)
application_name = 'pyDragonWarrior'
saves_path = get_saves_path(application_path, application_name)
os.environ[
'PYGAME_HIDE_SUPPORT_PROMPT'] = '1' # Silence pygame outputs to standard out
import pygame
from AudioPlayer import AudioPlayer
from GameDialog import GameDialog
from GameLoop import GameLoop
# Set the current working directory to the location of this file so that the game can be run from any path
os.chdir(os.path.dirname(__file__))
base_path = os.path.split(os.path.abspath(__file__))[0]
icon_image_filename = os.path.join(base_path, 'icon.png')
pygame.init()
pygame.mouse.set_visible(False)
pygame.display.set_caption(application_name)
if os.path.exists(icon_image_filename):
try:
icon_image = pygame.image.load(icon_image_filename)
pygame.display.set_icon(icon_image)
except:
print('ERROR: Failed to load', icon_image_filename, flush=True)
GameDialog.force_use_menus_for_text_entry = args.gamepad
# Initialize the game
if not args.force_use_unlicensed_assets and os.path.exists(
os.path.join(base_path, 'data', 'licensed_assets')):
game_xml_path = os.path.join(base_path, 'game_licensed_assets.xml')
else:
game_xml_path = os.path.join(base_path, 'game.xml')
win_size_pixels = None # Point(2560, 1340)
tile_size_pixels = 16 * 3
game_loop = GameLoop(saves_path, base_path, game_xml_path, win_size_pixels,
tile_size_pixels)
# Run the game
game_loop.run(args.save)
# Exit the game
AudioPlayer().terminate()
pygame.joystick.quit()
pygame.quit()
class MainInterface(QtWidgets.QMainWindow, interface.Ui_MainWindow):
def __init__(self):
super().__init__()
self.setupUi(self)
self.text_to_speach_list = [
self.Text_to_Speech, self.Text_to_Speech_2, self.Text_to_Speech_3,
self.Text_to_Speech_4
]
self.canvas = Canvas()
self.canvas_comp = QtWidgets.QVBoxLayout(self.Mel_spec)
self.canvas_comp.addWidget(self.canvas)
self.toolbar = NavigationToolbar(self.canvas, self)
self.canvas_comp.addWidget(self.toolbar)
self.canvas1 = Canvas_spectr(self, width=21, height=4)
self.Spectrum.setStyleSheet(
" background-color: none; selection-background-color: none;")
self.canvas1.setStyleSheet(
"background-color: none; selection-background-color: none;")
self.SpectrAudio = QtWidgets.QStackedLayout(self.Spectrum)
self.SpectrAudio.insertWidget(0, self.canvas1)
self._Syntethis = Synthesis()
self.player = AudioPlayer()
self.speakerlist = SpeakerList()
self.speakerlist.setStyleSheet("border: 0; height: 50px;")
self.speakerlist_layout = QtWidgets.QVBoxLayout(self.SpeakerList)
self.speakerlist_layout.addWidget(self.speakerlist)
self.speakerlist.set_model.connect(self._Syntethis.T2LoadModel)
self.speakerlist.load_data()
self.LoadWaveGlowModel.clicked.connect(self.WGSelectModel)
self.Syntethis.clicked.connect(self.SyntethisFunc)
self.PlayWav.clicked.connect(self.playSpeeck)
self.output_directory_button.clicked.connect(self._output_directory)
self.log_directory_button.clicked.connect(self._log_directory)
self.checkpoint_path_Box.stateChanged.connect(
self._path_checkpoint_enabled)
self.path_checkpoint_button.clicked.connect(self._path_checkpoint)
self.training_files_button.clicked.connect(self._training_files)
self.validation_files_button.clicked.connect(self._validation_files)
self.AudioParametersBox.currentIndexChanged.connect(
self._Syntethis.SetCurrentAudioParameters)
self.AudioParametersBox.currentIndexChanged.connect(
self.SetAudioParameters)
self.StartTrain.clicked.connect(self._start_train)
self.SaveAudio.clicked.connect(self.saveFile)
self.Stop.clicked.connect(self._stop_train)
self.VolumeSlider.valueChanged.connect(self.player.set_voulume)
self.PauseWav.clicked.connect(self.player.pause)
self.StopWav.clicked.connect(self.player.stop)
self.double_slider = DoubleSlider()
self.double_slider.setOrientation(QtCore.Qt.Horizontal)
self.SpectrAudio.insertWidget(0, self.double_slider)
self.SpectrAudio.setStackingMode(self.SpectrAudio.StackAll)
self.SpectrAudio.setCurrentWidget(self.double_slider)
self.double_slider.setStyleSheet(
"QSlider{ border: 0; background-color: none; selection-background-color: none;}"
"QSlider::groove:horizontal {border: 1px solid #000000; }"
"QSlider::handle:horizontal{ border: 10px solide #5c5c5c;"
"background: qlineargradient(x1:0, y1:0, x2:1, y2:1, stop:0 #b4b4b4, stop:1 #8f8f8f); }"
" }"
"QSlider::add-page:horizontal{ background: rgba(255, 255, 255, 10%);}"
"QSlider::sub-page:horizontal{ background: rgba(255,140,0, 40%);}")
self.player.positionChanged.connect(self.setPosMax)
self.StartTrain.setToolTip(
"checkpoint_path + warm_start - если модель уже обученная и начать обучение новой модели \n"
" только checkpoint_path - не модель обученная модель а точка остановки, продолжит \n "
"без checkpoint_path и warm_start - модель с нуля \n ")
self.SetAudioParameters()
self.load_data()
def SetAudioParameters(self):
self.max_wav_value.setValue(self._Syntethis.AudioParameters[
self._Syntethis.currentAudioParameters][0])
self.sampling_rate.setValue(self._Syntethis.AudioParameters[
self._Syntethis.currentAudioParameters][1])
self.filter_length.setValue(self._Syntethis.AudioParameters[
self._Syntethis.currentAudioParameters][2])
self.hop_length.setValue(self._Syntethis.AudioParameters[
self._Syntethis.currentAudioParameters][3])
self.win_length.setValue(self._Syntethis.AudioParameters[
self._Syntethis.currentAudioParameters][4])
self.n_mel_channels.setValue(self._Syntethis.AudioParameters[
self._Syntethis.currentAudioParameters][5])
self.mel_fmin.setValue(self._Syntethis.AudioParameters[
self._Syntethis.currentAudioParameters][6])
self.mel_fmax.setValue(self._Syntethis.AudioParameters[
self._Syntethis.currentAudioParameters][7])
self.batch_size.setValue(8)
def _train_param_load(self):
if os.path.isfile("train_param.txt"):
start_param = Serializ.load("train_param.txt")
self.epoch.setValue(start_param[0][0])
self.iters_per_checkpoint.setValue(start_param[0][1])
self.cudnn_enabled.setChecked(start_param[0][2])
self.cudnn_benchmark.setChecked(start_param[0][3])
self.load_mel_from_disk.setChecked(start_param[0][4])
self.training_files.setText(start_param[0][5])
self.validation_files.setText(start_param[0][6])
self.encoder_kernel_size.setValue(start_param[1][0])
self.encoder_n_convolutions.setValue(start_param[1][1])
self.encoder_embedding_dim.setValue(start_param[1][2])
self.decoder_rnn_dim.setValue(start_param[1][3])
self.prenet_dim.setValue(start_param[1][4])
self.max_decoder_steps.setValue(start_param[1][5])
self.gate_threshold.setValue(start_param[1][6])
self.p_attention_dropout.setValue(start_param[1][7])
self.p_decoder_dropout.setValue(start_param[1][8])
self.attention_rnn_dim.setValue(start_param[2][0])
self.attention_dim.setValue(start_param[2][1])
self.attention_location_n_filters.setValue(start_param[2][2])
self.attention_location_kernel_size.setValue(start_param[2][3])
self.postnet_embedding_dim.setValue(start_param[3][0])
self.postnet_kernel_size.setValue(start_param[3][1])
self.postnet_n_convolutions.setValue(start_param[3][2])
self.use_saved_learning_rate.setChecked(start_param[4][0])
self.mask_padding.setChecked(start_param[4][1])
self.learning_rate.setValue(start_param[4][2])
self.weight_decay.setValue(start_param[4][3])
self.batch_size.setValue(start_param[4][4])
def _start_train(self):
ExperimentDataParameters = [
self.epoch.value(),
self.iters_per_checkpoint.value(),
self.cudnn_enabled.isChecked(),
self.cudnn_benchmark.isChecked(),
self.load_mel_from_disk.isChecked(),
self.training_files.text(),
self.validation_files.text(),
self.text_cleaners_box.currentText()
]
EncoderDecoderParameters = [
self.encoder_kernel_size.value(),
self.encoder_n_convolutions.value(),
self.encoder_embedding_dim.value(),
self.decoder_rnn_dim.value(),
self.prenet_dim.value(),
self.max_decoder_steps.value(),
self.gate_threshold.value(),
self.p_attention_dropout.value(),
self.p_decoder_dropout.value()
]
AttentionLocationLayerParameters = [
self.attention_rnn_dim.value(),
self.attention_dim.value(),
self.attention_location_n_filters.value(),
self.attention_location_kernel_size.value()
]
MelProcessingNetworkNarameters = [
self.postnet_embedding_dim.value(),
self.postnet_kernel_size.value(),
self.postnet_n_convolutions.value()
]
OptimizationHyperparameters = [
self.use_saved_learning_rate.isChecked(),
self.mask_padding.isChecked(),
self.learning_rate.value(),
self.weight_decay.value(),
self.batch_size.value()
]
Serializ.dump("train_param.txt", [
ExperimentDataParameters, EncoderDecoderParameters,
AttentionLocationLayerParameters, MelProcessingNetworkNarameters,
OptimizationHyperparameters
])
hpr = create_hparams(
ExperimentDataParameters, self._Syntethis.AudioParameters[
self.AudioParametersBox.currentIndex()],
EncoderDecoderParameters, AttentionLocationLayerParameters,
MelProcessingNetworkNarameters, OptimizationHyperparameters)
self._train_param_load()
self.train = Train()
self.train.log_signal.connect(self.setLog)
self.x = Thread(target=self.train.train,
args=(
self.output_directory.text(),
self.log_directory.text(),
[
None,
[None, self.path_checkpoint.text()
][os.path.isfile(self.path_checkpoint.text())]
][self.checkpoint_path_Box.isChecked()],
self.warm_start.isChecked(),
False,
False,
False,
hpr,
))
self.logBox.setPlainText("")
self.x.start()
def _stop_train(self):
self.train.check_train = True
self.x.join()
self.x._stop()
self.setLog("train stopped")
def _output_directory(self):
self.out_dir = QtWidgets.QFileDialog.getExistingDirectory(
self, "Выберите папку вывода модели")
self.output_directory.setText(self.out_dir)
def _log_directory(self):
self.log_dir = QtWidgets.QFileDialog.getExistingDirectory(
self, "Выберите папку вывода логов")
self.log_directory.setText(self.log_dir)
def _path_checkpoint_enabled(self, state):
if state == 2:
self.path_checkpoint.setEnabled(True)
self.path_checkpoint_button.setEnabled(True)
else:
self.path_checkpoint.setEnabled(False)
self.path_checkpoint_button.setEnabled(False)
def _path_checkpoint(self):
self.checkpoint_model = QtWidgets.QFileDialog.getOpenFileName(
self,
"Выберите файл модели/контрольной точки от которой продолжить обучение"
)[0]
self.path_checkpoint.setText(self.checkpoint_model)
def _training_files(self):
self.train_file = QtWidgets.QFileDialog.getOpenFileName(
self,
"Выберите файл модели/контрольной точки от которой продолжить обучение"
)[0]
self.training_files.setText(self.train_file)
def _validation_files(self):
self.valid_file = QtWidgets.QFileDialog.getOpenFileName(
self,
"Выберите файл модели/контрольной точки от которой продолжить обучение"
)[0]
self.validation_files.setText(self.valid_file)
def load_data(self):
self._train_param_load()
data_load = Serializ.load("config.txt")
if data_load != False:
self._WGModel = data_load[0]
self._Syntethis.WGLoadModel(self._WGModel)
self.WaveGlowModel.setText(self._WGModel)
def WGSelectModel(self):
self._WGModel = QtWidgets.QFileDialog.getOpenFileName(
self, "Выберите файл модели/контрольной вокодера")[0]
self._Syntethis.WGLoadModel(self._WGModel)
self.WaveGlowModel.setText(self._WGModel)
self.LoadWaveGlowModel.setEnabled(True)
def SyntethisFunc(self):
if self.text_to_speach_list[
self.tabWidget.currentIndex()].toPlainText() != "":
model_param = [self._WGModel]
Serializ.dump("config.txt", model_param)
self.player._stop()
self.canvas.update_g(
self._Syntethis.SyntethisFunc(
self.text_to_speach_list[
self.tabWidget.currentIndex()].toPlainText(),
int(self.SampleRate.currentText()),
self.AddSpeech.isChecked()))
self.player.set_file('TempFile/test.wav')
self.canvas1.print_spec('TempFile/test.wav')
self.canvas_comp.update()
self.Mel_spec.repaint()
self.repaint()
def playSpeeck(self):
print(self.player.duration())
self.double_slider.setMaximum(self.player.duration() / 1000)
self.player.play()
def saveFile(self):
file_name = QtWidgets.QFileDialog.getSaveFileName(
self, "Сохранить речь", '', 'WAV (*.wav)')[0]
if file_name != "":
if self.AddSpeech.isChecked() == False:
self._Syntethis.SaveFile(file_name,
int(self.SampleRate.currentText()))
else:
self._Syntethis.SaveFile(file_name,
int(self.SampleRate.currentText()),
add=1)
def setLog(self, text):
temp = self.logBox.toPlainText()
self.logBox.setText(temp + text)
self.logBox.moveCursor(QtGui.QTextCursor.End)
def setPosMax(self, MAX):
self.double_slider.setValue(MAX / 1000)
print(MAX / 1000)