def _get_randomizer(self, settings, context, calling_context):
key = "random_{}.{}".format(context, calling_context)
if settings['scope'] == "player":
if not self.machine.game.player[key]:
self.machine.game.player[key] = Randomizer(settings['events'])
r'''player_var: random_(x).(y)
desc: Holds references to Randomizer settings that need to be
tracked on a player basis. There is nothing you need to know
or do with this, rather this is just FYI on what the player
variables that start with "random\_" are.
'''
if settings['force_all']:
self.machine.game.player[key].force_all = True
if not settings['force_different']:
self.machine.game.player[key].force_different = False
return self.machine.game.player[key]
else:
if key not in self._machine_wide_dict:
self._machine_wide_dict[key] = Randomizer(settings['events'])
if settings['force_all']:
self._machine_wide_dict[key].force_all = True
if not settings['force_different']:
self._machine_wide_dict[key].force_different = False
return self._machine_wide_dict[key]
def _get_randomizer(self, settings, context, calling_context):
key = "random_{}.{}".format(context, calling_context)
if settings['scope'] == "player":
if not self.machine.game.player[key]:
self.machine.game.player[key] = Randomizer(settings['events'])
if settings['force_all']:
self.machine.game.player[key].force_all = True
if settings['force_different']:
self.machine.game.player[key].force_different = True
return self.machine.game.player[key]
else:
if key not in self._machine_wide_dict:
self._machine_wide_dict[key] = Randomizer(settings['events'])
if settings['force_all']:
self._machine_wide_dict[key].force_all = True
if settings['force_different']:
self._machine_wide_dict[key].force_different = True
return self._machine_wide_dict[key]
def __init__(self,
name: str,
playlist: dict,
track_crossfade_time: float,
context: Optional[str] = None,
settings: Optional[dict] = None):
"""Constructor"""
self._name = name
if playlist is None:
raise ValueError(
"Cannot create playlist instance: playlist parameter is None")
self._context = context
if settings is None:
settings = {}
# Set crossfade time that will be used for playing this instance (will either
# use the track time or the playlist time depending upon the crossfade_mode
# setting
settings.setdefault('crossfade_mode', playlist['crossfade_mode'])
if settings['crossfade_mode'] == 'use_track_setting':
settings['crossfade_time'] = track_crossfade_time
elif settings['crossfade_mode'] == 'use_playlist_setting':
if playlist['crossfade_mode'] == 'use_track_setting':
settings['crossfade_time'] = track_crossfade_time
else:
settings.setdefault('crossfade_time',
playlist['crossfade_time'])
else:
settings.setdefault('crossfade_time', playlist['crossfade_time'])
settings.setdefault('shuffle', playlist['shuffle'])
settings.setdefault('repeat', playlist['repeat'])
settings['sounds'] = playlist['sounds']
settings.setdefault('events_when_played',
playlist['events_when_played'])
settings.setdefault('events_when_stopped',
playlist['events_when_stopped'])
settings.setdefault('events_when_looping',
playlist['events_when_looping'])
settings.setdefault('events_when_sound_changed',
playlist['events_when_sound_changed'])
settings.setdefault('events_when_sound_stopped',
playlist['events_when_sound_stopped'])
self._settings = settings
self._sounds = Randomizer(self._settings['sounds'])
self._sounds.disable_random = not self._settings['shuffle']
self._sounds.force_all = True
self._sounds.force_different = True
self._sounds.loop = self._settings['repeat']
self._current_sound_instance = None
self._fading_sound_instance = None
def test_fallback_value(self):
items = []
r = Randomizer(items)
r.fallback_value = "foo"
results = list()
for x in range(100):
results.append(next(r))
self.assertEqual(100, results.count('foo'))
def test_weights(self):
items = [
('1', 2),
('2', 1),
('3', 1),
]
r = Randomizer(items)
r.force_different = False
results = list()
for x in range(10000):
results.append(next(r))
self.assertAlmostEqual(5000, results.count('1'), delta=500)
self.assertAlmostEqual(2500, results.count('2'), delta=500)
self.assertAlmostEqual(2500, results.count('3'), delta=500)
items = [
('1', 1),
('2', 1),
('3', 3),
]
r = Randomizer(items)
r.force_different = False
results = list()
for x in range(10000):
results.append(next(r))
self.assertAlmostEqual(2000, results.count('1'), delta=500)
self.assertAlmostEqual(2000, results.count('2'), delta=500)
self.assertAlmostEqual(6000, results.count('3'), delta=500)
items = [
('1', 1),
('2', 6),
('3', 3),
]
r = Randomizer(items)
r.force_different = False
results = list()
for x in range(10000):
results.append(next(r))
self.assertAlmostEqual(1000, results.count('1'), delta=500)
self.assertAlmostEqual(6000, results.count('2'), delta=500)
self.assertAlmostEqual(3000, results.count('3'), delta=500)
def test_loop_no_random(self):
items = [
('1', 1),
('2', 1),
('3', 1),
]
r = Randomizer(items)
r.disable_random = True
for i1 in range(50):
self.assertEqual(next(r), '1')
self.assertEqual(next(r), '2')
self.assertEqual(next(r), '3')
def test_no_loop(self):
items = [
('1', 1),
('2', 1),
('3', 1),
]
r = Randomizer(items)
r.loop = False
x = 0
for _ in r:
x += 1
self.assertEqual(3, x)
def test_force_different(self):
items = [
('1', 1),
('2', 1),
('3', 1),
]
r = Randomizer(items)
r.force_different = True
last_item = None
for x in range(1000):
this_item = next(r)
self.assertNotEqual(this_item, last_item)
last_item = this_item
def test_one_element_with_force_different(self):
items = ['1']
r = Randomizer(items)
self.assertTrue(r.force_different)
# it has one element and should thereby always return it
self.assertEqual('1', next(r))
self.assertEqual('1', next(r))
self.assertEqual('1', next(r))
def test_force_all(self):
items = [
('1', 1),
('2', 1),
('3', 1),
]
r = Randomizer(items)
r.force_all = True
last_item = None
for x in range(100):
results = set()
results.add(next(r))
self.assertNotEqual(last_item, r.get_current())
results.add(next(r))
results.add(next(r))
last_item = r.get_current()
self.assertEqual(len(results), 3)
def test_no_loop_no_random(self):
items = [
('1', 1),
('2', 1),
('3', 1),
]
for _ in range(50):
r = Randomizer(items)
r.loop = False
r.disable_random = True
x = 0
for i, result in enumerate(r):
x += 1
self.assertEqual(items[i][0], result)
self.assertEqual(3, x)
def test_machine_randomizer(self):
items = [
'1',
'2',
'3',
]
r = Randomizer(items)
results = list()
for x in range(10000):
results.append(next(r))
self.assertAlmostEqual(3333, results.count('1'), delta=500)
self.assertAlmostEqual(3333, results.count('2'), delta=500)
self.assertAlmostEqual(3333, results.count('3'), delta=500)
class PlaylistInstance:
"""
PlaylistInstance class represents an instance of a playlist asset.
"""
# pylint: disable-msg=too-many-arguments
def __init__(self, name: str, playlist: dict, track_crossfade_time: float,
context: Optional[str] = None, settings: Optional[dict] = None):
"""Constructor"""
self._name = name
if playlist is None:
raise ValueError("Cannot create playlist instance: playlist parameter is None")
self._context = context
if settings is None:
settings = {}
# Set crossfade time that will be used for playing this instance (will either
# use the track time or the playlist time depending upon the crossfade_mode
# setting
settings.setdefault('crossfade_mode', playlist['crossfade_mode'])
if settings['crossfade_mode'] == 'use_track_setting':
settings['crossfade_time'] = track_crossfade_time
elif settings['crossfade_mode'] == 'use_playlist_setting':
if playlist['crossfade_mode'] == 'use_track_setting':
settings['crossfade_time'] = track_crossfade_time
else:
settings.setdefault('crossfade_time', playlist['crossfade_time'])
else:
settings.setdefault('crossfade_time', playlist['crossfade_time'])
settings.setdefault('shuffle', playlist['shuffle'])
settings.setdefault('repeat', playlist['repeat'])
settings['sounds'] = playlist['sounds']
settings.setdefault('events_when_played', playlist['events_when_played'])
settings.setdefault('events_when_stopped', playlist['events_when_stopped'])
settings.setdefault('events_when_looping', playlist['events_when_looping'])
settings.setdefault('events_when_sound_changed', playlist['events_when_sound_changed'])
settings.setdefault('events_when_sound_stopped', playlist['events_when_sound_stopped'])
self._settings = settings
self._sounds = Randomizer(self._settings['sounds'])
self._sounds.disable_random = not self._settings['shuffle']
self._sounds.force_all = True
self._sounds.force_different = True
self._sounds.loop = self._settings['repeat']
self._current_sound_instance = None
self._fading_sound_instance = None
def __repr__(self):
"""String that's returned if someone prints this object"""
return '<PlaylistInstance: {}>'.format(self.name)
@property
def name(self):
return self._name
@property
def crossfade_time(self):
return self._settings['crossfade_time']
@property
def shuffle(self):
return self._settings['shuffle']
@property
def repeat(self):
return self._settings['repeat']
@property
def events_when_played(self):
return self._settings['events_when_played']
@property
def events_when_stopped(self):
return self._settings['events_when_stopped']
@property
def events_when_looping(self):
return self._settings['events_when_looping']
@property
def events_when_sound_changed(self):
return self._settings['events_when_sound_changed']
@property
def events_when_sound_stopped(self):
return self._settings['events_when_sound_stopped']
@property
def sounds(self):
return self._settings['sounds']
@property
def end_of_playlist(self):
if self._sounds.disable_random:
return self._sounds.data['current_item_index'] == len(self._sounds.items)
else:
return len(self._sounds.data['items_sent']) == len(self._sounds.items)
@property
def current_sound_instance(self):
"""Return the current sound instance"""
return self._current_sound_instance
@current_sound_instance.setter
def current_sound_instance(self, value):
"""Set the current sound instance"""
self._current_sound_instance = value
@property
def fading_sound_instance(self):
"""Return the fading sound instance"""
return self._fading_sound_instance
@fading_sound_instance.setter
def fading_sound_instance(self, value):
"""Set the fading sound instance"""
self._fading_sound_instance = value
@property
def context(self):
"""The context under which this playlist was created/played."""
return self._context
def get_next_sound_name(self):
"""Return the name of the next sound in the playlist (advance iterator)"""
try:
return self._sounds.get_next()
except StopIteration:
return None
def get_current_sound_name(self):
"""Return the name of the current sound in the playlist"""
try:
return self._sounds.get_current()
except StopIteration:
return None
