def __init__(self, number):
self.keysdown = []
self.controllable = False
self.entities = []
self.level = number
self.musicres = [[
resource.media('epikboss_INTRO.ogg'),
resource.media('epikboss_loop.wav')
]]
self.musicplayer = media.Player()
self.batch = graphics.Batch()
self.expsfx = media.Player()
self.expsfx.queue(World.explo)
self.expsfx.eos_action = "pause"
self.s1sfx = media.Player()
self.s1sfx.queue(World.s1)
self.s1sfx.eos_action = "pause"
self.s2sfx = media.Player()
self.s2sfx.queue(World.s2)
self.s2sfx.eos_action = "pause"
self.s3sfx = media.Player()
self.s3sfx.queue(World.s3)
self.s3sfx.eos_action = "pause"
self.layers = (pyglet.graphics.OrderedGroup(0),
pyglet.graphics.OrderedGroup(1),
pyglet.graphics.OrderedGroup(2),
pyglet.graphics.OrderedGroup(3),
pyglet.graphics.OrderedGroup(4))
self.ui = UI(self)
def read(self, file):
if not hasattr(file, 'read'):
self.basedir = os.path.dirname(file)
file = open(file, 'rt')
elif hasattr(file, 'name'):
self.basedir = os.path.dirname(file.name)
reader = None
lineno = 0
for line in file:
lineno += 1
if not line.strip() or line.startswith('#'):
continue
if line.startswith(' '):
if not reader:
raise ReaderException('Unexpected indented block line %d' %
lineno)
reader.line(line, lineno)
else:
reader = None
parts = line.split()
if parts[0] == 'loop':
if len(parts) < 2:
raise ReaderException('No loop filename line %d' %
lineno)
player = media.Player()
player.eos_action = 'loop'
player.queue(self.source(parts[1], streaming=False))
self.space.add_player(player)
reader = PlayerReader(player)
def queueSoundtrack(song):
global soundtrack
if not soundtrack:
soundtrack = media.Player()
soundtrack.eos_action = 'loop'
soundtrack.queue(media.load(os.path.join(data.data_dir, song)))
return soundtrack
def play(self, volume: float = 1.0, pan: float = 0.0, loop: bool = False) -> media.Player:
"""
Play the sound.
:param float volume: Volume, from 0=quiet to 1=loud
:param float pan: Pan, from -1=left to 0=centered to 1=right
:param bool loop: Loop, false to play once, true to loop continously
"""
if (isinstance(self.source, media.StreamingSource)):
if (self.source.is_player_source):
raise RuntimeError("Tried to play a streaming source more than once."
" Streaming sources should only be played in one instance."
" If you need more use a Static source.")
player: media.Player = media.Player()
player.volume = volume
player.position = (pan, 0.0, math.sqrt(1 - math.pow(pan, 2))) #used to mimic panning with 3D audio
player.loop = loop
player.queue(self.source)
player.play()
media.Source._players.append(player)
def _on_player_eos():
media.Source._players.remove(player)
# There is a closure on player. To get the refcount to 0,
# we need to delete this function.
player.on_player_eos = None
player.on_player_eos = _on_player_eos
return player
def tts1(text, lang):
file = gTTS(text=text, lang=lang)
filename = 'temp1.mp3'
file.save(filename)
src = media.load(filename)
player = media.Player()
player.queue(src)
player.play()
timeout = time.time() + src.duration
while time.time() < timeout:
r = sr.Recognizer()
with sr.Microphone() as source:
filename = 'beep.wav'
music = pyglet.media.load(filename, streaming=False)
music.play()
time.sleep(music.duration)
try:
speech = r.listen(source, phrase_time_limit=4)
text = r.recognize_google(speech)
c = text.lower()
if 'stop' in c:
player.pause()
player.next()
return
else:
continue
except Exception as e:
pass
player.pause()
player.next()
return
def __init__(self):
QThread.__init__(self)
self.queue = queue.Queue()
if gPygletAvailable:
self.player = media.Player()
else:
self.player = None
self.active = True
def test_method(self):
source = procedural.WhiteNoise(0.5)
player = media.Player()
player.play()
player.queue(source)
while player.source:
player.dispatch_events()
def test_play_queue(self):
"""You should hear white noise (static) for 0.5 seconds.
The test will exit immediately after.
"""
source = procedural.WhiteNoise(0.5)
player = media.Player()
player.play()
player.queue(source)
def __init__(self, path, volume):
# Song Playing Song
self.path = path
# Song Volume Update
self.volume = volume
# pyglet Media Player
self.player = media.Player()
self.player.volume = volume
self.songPosition = 0
def __init__(self):
self.view = View() #подключаем Viuw
self.player = media.Player() #укорачиваем вызов функции
self.btnPlay = False #состояние кнопки Play/Pause
#-----------------------обрабатываем событие нажатия на кнопки--------------------#
self.view.btnOpen.bind("<ButtonRelease-1>", self.openFile)
self.view.btnPlay.bind("<Button-1>", self.play)
self.view.btnStop.bind("<Button-1>", self.stop)
self.view.playList.bind("<Double-Button-1>", self.listBoxSelect)
def __init__(self):
QThread.__init__(self)
self.queue = queue.Queue()
if gPygletAvailable:
self.player = media.Player()
else:
self.player = None
if self.usePyTTS:
self.speech_engine = pyttsx3.init()
self.active = True
def test_eos_next(self):
"""You should hear a tone at 440Hz (A above middle C) for 1.0 seconds.
The test will exit immediately after.
"""
source1 = procedural.Sine(0.5)
source2 = procedural.Sine(0.5)
player = media.Player()
player.queue(source1)
player.queue(source2)
player.play()
def test_method(self):
source1 = procedural.Sine(0.5)
source2 = procedural.Sine(0.5)
player = media.Player()
player.queue(source1)
player.queue(source2)
player.play()
while player.source:
player.dispatch_events()
def main():
fname = '/home/evan/Desktop/openJarvis/openJarvis/speech/tdfw.mp3'
src = media.load(fname)
player = media.Player()
player.queue(src)
player.volume = 1.0
player.play()
try:
pyglet.app.run()
except KeyboardInterrupt:
player.next()
def check_time():
ctime = datetime.now().time().strftime("%I:%M:%S")
if ctime[3:] == "00:00":
src = "/home/pi/Desktop/chimes/chime.wav"
chime = pg.load(src, streaming=False)
player = pg.Player()
player.volume = 0.5
for h in range(int(ctime[:2])):
player.queue(chime)
player.play()
threading.Timer(1, check_time).start() #runs check_time every 1 sec
def __init__(self, song_time, song_duration, volume):
self.path = ''
# volume is a float from 0 (mute) to 1 (normal volume)
self.volume = volume
self.songtime = song_time
self.songduration = song_duration
self.player = media.Player() # the pyglet media player
self.time_thread() # time updating thread
# var for fast forwarding/reverse speed
self.jump_distance = 10
def __init__(self, playList):
self.playList = playList
self.activePlayer = media.Player()
self.activePlayer.eos_action = self.activePlayer.EOS_PAUSE
self.paused = False
mediaHandler = playList.nextSong()
print "Now playing " + mediaHandler.id3Tags["title"][
0] + " by " + mediaHandler.id3Tags["artist"][0]
self.activePlayer.queue(mediaHandler.songFile)
self.play()
def __init__(self, path, song_time, song_duration, volume):
self.path = path # Song Playing Song
self.volume = volume # Song Volume Update
self.songtime = song_time # Song Time Variable
self.songduration = song_duration # Song Duration
self.player = media.Player() # pyglet Media Player
self.player.volume = 1.5 #
self.time_thread() # Time Updating Thread
self.path.trace('w', self.play_song)
self.volume.trace('w', self.volume_)
def test_pause_queue(self):
"""You should hear white noise (static) for 0.5 seconds.
The test will exit immediately after.
"""
source = procedural.WhiteNoise(0.5)
player = media.Player()
player.pause()
player.queue(source)
while player.source:
player.dispatch_events()
player.play()
def __init__(self, parent, file=None, source=None, title=None,
playing=False, bgcolor=(1, 1, 1, 1), color=(0, 0, 0, 1),
font_size=20, **kw):
'''Pass in a filename as "file" or a pyglet Source as "source".
'''
self.parent = parent
if file is not None:
source = media.load(file, streaming=True)
else:
assert source is not None, 'one of file or source is required'
self.player = media.Player()
# poke at the audio format
if not source.audio_format:
raise ValueError("File doesn't contain audio")
super(Music, self).__init__(parent, bgcolor=bgcolor, **kw)
# lay it out
# control frame top-level
c = self.control = Frame(self, width='100%', height=64)
ft = Frame(c, is_transparent=True, width='100%', height='100%')
ft.layout = layouts.Vertical(ft)
Label(ft, title or 'unknown', color=color, bgcolor=bgcolor,
padding=2, font_size=font_size)
# controls underlay
f = Frame(ft, is_transparent=True, width='100%', height='100%')
f.layout = layouts.Horizontal(f, valign='center', halign='center',
padding=10)
c.play = Image(f, data.load_gui_image('media-play.png'),
classes=('-play-button',), is_visible=not playing)
c.pause = Image(f, data.load_gui_image('media-pause.png'),
bgcolor=None, classes=('-pause-button',), is_visible=playing)
fi = Frame(f, is_transparent=True)
c.range = Image(fi, data.load_gui_image('media-range.png'))
c.position = Image(fi, data.load_gui_image('media-position.png'),
y=-2, classes=('-position',))
c.time = Label(f, '00:00', font_size=20)
c.anim = None
# make sure we get at least one frame to display
self.player.queue(source)
clock.schedule(self.update)
self.playing = False
if playing:
self.play()
def __init__(self, name, path):
self.name = name
self.__error = False
try:
snd = media.load(path, streaming=False)
self.__looper = media.SourceGroup(snd.audio_format, None)
self.__looper.loop = False
self.__looper.queue(snd)
self.__sound = media.Player()
self.__sound.queue(self.__looper)
except:
self.__error = True
def playAudioFile(self, filename, stream=False):
try:
volume = float(self.volume) / 100.0
if gPygletAvailable:
src = media.load(filename, streaming=stream)
player = media.Player()
player.queue(src)
player.volume = volume
player.play()
elif self.isDarwin:
subprocess.call(
["afplay -v {0} {1}".format(volume, filename)],
shell=True)
except Exception as e:
logging.error("SoundThread.playAudioFile exception: %s", e)
def __init__(self):
QtGui.QMainWindow.__init__(self)
Ui_MainWindow.__init__(self)
# Phonon.MediaObject.__init__(self)
self.setupUi(self)
self.round_robin.clicked.connect(self.RoundRobin)
self.sjf.clicked.connect(self.ShortestJobFirst)
self.fcfs.clicked.connect(self.FirstComeFirstServe)
self.prior.clicked.connect(self.Prior)
self.exit.clicked.connect(EXIT)
self.fname1 = path + '/Sounds/Sound1.mp3'
self.fname2 = path + '/Sounds/Sound2.mp3'
self.fname3 = path + '/Sounds/Sound3.mp3'
self.fname4 = path + '/Sounds/Sound4.mp3'
self.src1 = media.load(self.fname1)
self.src2 = media.load(self.fname2)
self.src3 = media.load(self.fname3)
self.src4 = media.load(self.fname4)
self.player1 = media.Player()
self.player2 = media.Player()
self.player3 = media.Player()
self.player4 = media.Player()
self.player1.queue(self.src1)
self.player2.queue(self.src2)
self.player3.queue(self.src3)
self.player4.queue(self.src4)
self.player1.volume = 1.0
self.player2.volume = 1.0
self.player3.volume = 1.0
self.player4.volume = 1.0
def test_method(self):
source = procedural.WhiteNoise(0.5)
player = media.Player()
player.queue(source)
player.play()
start_time = time.time()
stage = 0
while player.source:
if stage == 0 and time.time() - start_time > 0.25:
player.pause()
stage = 1
if stage == 1 and time.time() - start_time > 0.75:
player.play()
stage = 2
player.dispatch_events()
class GameField:
CELL_SIZE = 64
ROWS_NUM = 9
COLUMNS_NUM = 9
WIN_WIDTH = 640
WIN_HEIGHT = 640 - CELL_SIZE
trees = []
bricks = []
boxes = []
box_targets = []
music = media.Player()
def __init__(self):
source = res.backmusic
self.music.volume = 0.3
self.music.queue(source)
self.music.loop = True
# self.music.play()
# TODO: скорее всего можно улучшить
def can_move(self, obj, direction):
# проверяем не кирпич ли это
next_cell = np.add([obj.row, obj.column], direction)
next_cell.tolist()
r, c = next_cell
if get_obj_by_cell(self.bricks, r, c):
return False
else:
# проверяем, если это ящик, то что за ним
old_r = r
old_c = c
if get_obj_by_cell(self.boxes, r, c):
next_cell = np.add(next_cell, direction)
next_cell.tolist()
r, c = next_cell
if self.get_obj_by_cell(self.boxes, r,
c) or self.get_obj_by_cell(
self.bricks, r, c):
return False
else:
box = self.get_obj_by_cell(self.boxes, old_r, old_c)
box.move(direction)
return True
def set_background_music(path):
"""
Sets the background music to the file specified by "path"
Once background music has been set, you can play it by calling AudioPlayer.play_background_music()
"""
# Background music is handled a bit differently than other sounds
# Since it must stream and loop, we cannot use StaticSource.play() to create a ManagedPlayer
# Instead, load create a Source object from file, and a Player() from this Source
# This will be our background music Player
global _bg_music_source
global _bg_music_player
_bg_music_source = media.load(path, None, False)
_bg_music_player = media.Player()
_bg_music_player.eos_action = media.Player.EOS_LOOP
_bg_music_player.queue(_bg_music_source)
_bg_music_player.pause()
def __init__(self):
super().__init__()
self.menu = [
"1 Player",
"2 Players",
"2 Players LAN",
"Controls",
"Exit",
]
self.menu_item_selected = 0
# Background music
self.music = pm.load(utils.resource_path(os.path.join('data', 'music0.wav')))
self.player = pm.Player()
self.player.queue(self.music)
self.player.play()
def test_pause(self):
"""You should hear white noise (static) for 0.25 seconds, then a 0.5
second pause then another 0.25 seconds of noise. The test will exit
immediately after.
"""
source = procedural.WhiteNoise(0.5)
player = media.Player()
player.queue(source)
player.play()
start_time = time.time()
stage = 0
while player.source:
if stage == 0 and time.time() - start_time > 0.25:
player.pause()
stage = 1
if stage == 1 and time.time() - start_time > 0.75:
player.play()
stage = 2
player.dispatch_events()
def __init__(self):
return
self.click = resource.media("click.wav", streaming=False)
self.your_focus = resource.media("your_focus.wav", streaming=False)
self.opponent_focus = resource.media("opponent_focus.wav",
streaming=False)
self.end_turn = resource.media("end_turn.wav", streaming=False)
self.start_combat = resource.media("combat.wav", streaming=False)
self.gamestart = resource.media("gamestart.wav", streaming=False)
self.gameover = resource.media("gameover.wav", streaming=False)
self.mana = resource.media("mana.wav", streaming=False)
self.manaspent = resource.media("manaspent.wav", streaming=False)
self.tap = resource.media("tap.wav", streaming=False)
#self.clink = resource.media("ding.wav", streaming=False)
#self.enter_sound = resource.media("card_entering_play.wav", streaming=False)
#self.leave_sound = resource.media("card_leaving_play.wav", streaming=False)
#self.play_ability = resource.media("play_ability.wav", streaming=False)
#self.untap = resource.media("untap.wav", streaming=False)
#self.lifeloss = resource.media("lifeloss.wav", streaming=False)
self.player = media.Player()
self.player.queue(resource.media("background.ogg", streaming=True))
self.player.eos_action = self.player.EOS_LOOP
self.connections = [
(self.gamestart, GameEvent.GameStartEvent()),
(self.gameover, GameEvent.GameOverEvent()),
(self.your_focus, GUIEvent.MyPriority()),
(self.opponent_focus, GUIEvent.OpponentPriority()),
(self.end_turn, GameEvent.NewTurnEvent()),
(self.start_combat, GameEvent.DeclareAttackersEvent()),
(self.tap, GameEvent.CardTapped()),
#(self.tap, GameEvent.CardUntapped()),
#(self.lifeloss, GameEvent.LifeLostEvent()),
#(self.mana, GameEvent.ManaAdded()),
(self.manaspent, GameEvent.ManaSpent()),
#(self.clink, GUIEvent.FocusCard(), sender=dispatcher.Anonymous, priority=dispatcher.UI_PRIORITY)),
#(self_ability, GameEvent.AbilityAnnounced()),
#(self.enter_sound, GameEvent.CardEnteredZone()),
#(self.leave_sound, GameEvent.CardLeftZone()),
]
class Sound:
resource.path.append("../res/sound")
resource.reindex()
try:
snd = resource.media("main_theme.mp3", streaming=False)
except Exception as e:
music = DummyPlayer()
print(e)
else:
music = media.Player()
music.queue(snd)
music.loop = True
sounds_name = [
"big_jump", "brick_smash", "bump", "coin", "death", "flagpole",
"game_over", "out_of_time", "powerup", "powerup_appears", "small_jump",
"stage_clear", "stomp"
]
sounds = defaultdict(DummyPlayer)
for sound in sounds_name:
try:
sounds[sound] = resource.media(sound + ".mp3", streaming=False)
except Exception as e:
print(e)
@classmethod
def play(cls, name):
if name == "mario":
cls.music.play()
else:
cls.sounds[name].play()
@classmethod
def stop(cls, name):
if name == "mario":
cls.music.pause()
