def fill_coop_entrant_lists(props, rtgg_obs: RacetimeObs):
fill_entrant_list(rtgg_obs.race,
obs.obs_properties_get(props, "coop_partner"))
fill_entrant_list(rtgg_obs.race,
obs.obs_properties_get(props, "coop_opponent1"))
fill_entrant_list(rtgg_obs.race,
obs.obs_properties_get(props, "coop_opponent2"))
def check_file_use(props, prop, settings):
p = obs.obs_properties_get(props, "file_path")
st = obs.obs_properties_get(props, "scripted_text")
p2 = obs.obs_properties_get(props, "reload_file")
obs.obs_property_set_visible(p, std.use_file)
obs.obs_property_set_visible(p2, std.use_file)
obs.obs_property_set_visible(st, not std.use_file)
return True
def closing_scene_modified(props, properties, settings):
obs.obs_property_set_enabled(
obs.obs_properties_get(props, "stop_streaming_delay"),
closing_scene != "" and manage_streaming)
obs.obs_property_set_enabled(
obs.obs_properties_get(props, "stop_recording_delay"),
closing_scene != "" and manage_recording)
return True
def get_scenes(props, prop):
if device_ip is not None and auth_key is not None:
nl = Nanoleaf(device_ip, auth_key)
s1 = obs.obs_properties_get(props, "scene_on")
s2 = obs.obs_properties_get(props, "scene_off")
for light_scene in nl.list_effects():
obs.obs_property_list_add_string(s1, light_scene, light_scene)
obs.obs_property_list_add_string(s2, light_scene, light_scene)
return True
def on_property_modified(props, property, settings):
obs.obs_property_set_enabled(obs.obs_properties_get(props, "start_scene"),
manage_streaming or manage_recording)
obs.obs_property_set_enabled(obs.obs_properties_get(props, "weekday"),
(manage_streaming or manage_recording)
and start_scene != "")
obs.obs_property_set_enabled(obs.obs_properties_get(props, "event_start"),
(manage_streaming or manage_recording)
and start_scene != "")
obs.obs_property_set_enabled(
obs.obs_properties_get(props, "preshow_duration"),
(manage_streaming or manage_recording) and start_scene != "")
obs.obs_property_set_enabled(obs.obs_properties_get(props, "text_source"),
(manage_streaming or manage_recording)
and start_scene != "")
obs.obs_property_set_enabled(
obs.obs_properties_get(props, "countdown_final_text"),
(manage_streaming or manage_recording) and text_source != ""
and start_scene != "")
obs.obs_property_set_enabled(
obs.obs_properties_get(props, "closing_scene"), manage_streaming
or manage_recording)
obs.obs_property_set_enabled(
obs.obs_properties_get(props, "stop_streaming_delay"),
closing_scene != "" and manage_streaming)
obs.obs_property_set_enabled(
obs.obs_properties_get(props, "stop_recording_delay"),
closing_scene != "" and manage_recording)
return True
def script_qualifier_settings(props, rtgg_obs: RacetimeObs):
lang = gettext.translation("racetime-obs",
localedir=os.environ['LOCALEDIR'])
_ = lang.gettext
p = obs.obs_properties_add_bool(
props, "use_qualifier",
_("Display race results as tournament qualifier?"))
obs.obs_property_set_modified_callback(p, qualifier_toggled)
qualifier_group = obs.obs_properties_create()
obs.obs_properties_add_group(props, "qualifier_group", _("Qualifier Mode"),
obs.OBS_GROUP_NORMAL, qualifier_group)
obs.obs_property_set_visible(
obs.obs_properties_get(props, "qualifier_group"),
rtgg_obs.qualifier.enabled)
p = obs.obs_properties_add_int_slider(qualifier_group, "qualifier_cutoff",
_("Use Top X as par time, where X="),
3, 10, 1)
p = obs.obs_properties_add_list(qualifier_group, "qualifier_par_source",
_("Qualifier Par Time Source"),
obs.OBS_COMBO_TYPE_EDITABLE,
obs.OBS_COMBO_FORMAT_STRING)
fill_source_list(p)
p = obs.obs_properties_add_list(qualifier_group, "qualifier_score_source",
_("Qualifier Score Source"),
obs.OBS_COMBO_TYPE_EDITABLE,
obs.OBS_COMBO_FORMAT_STRING)
fill_source_list(p)
def _update(properties, prop, data=None):
if not data:
return
n1 = _obs.obs_property_name(prop)
n2 = f"_{n1}_item"
p = _obs.obs_properties_get(properties, n2)
return SceneItemList._do_update(data, p, n1, n2)
def name_modified(props, prop, *args, **kwargs):
racer_name = obs.obs_data_get_string(args[0], lp.ladder_name)
p = obs.obs_properties_get(props, lp.ladder_name)
if ladder_timer.update_settings(racer_name):
obs.obs_property_set_description(p, _("Ladder Name ✅"))
else:
obs.obs_property_set_description(p, _("Ladder Name ❌"))
return True
def populate_channels(props, p=None, _settings=None):
p = obs.obs_properties_get(props, 'voice_channel')
obs.obs_property_list_clear(p)
for guild in sorted(client.guilds, key=lambda x: x.name.lower()):
for channel in sorted(guild.channels, key=lambda x: x.position):
if isinstance(channel, discord.VoiceChannel):
obs.obs_property_list_add_string(
p, guild.name + ' -> ' + channel.name, str(channel.id))
return True
def find_nanoleafs(props, prop):
nanoleaf_dict = discovery.discover_devices(timeout=10)
print(nanoleaf_dict)
l = obs.obs_properties_get(props, "device_ip")
for device in nanoleaf_dict:
obs.obs_property_list_add_string(l, nanoleaf_dict[device],
nanoleaf_dict[device])
return True
def callback(props, prop, settings):
_number = obs.obs_data_get_int(settings, "_int")
_text_value = obs.obs_data_get_string(settings, "_text")
text_property = obs.obs_properties_get(props, "_text")
if _number > 50:
eg.data = _text_value + str(_number)
obs.obs_property_set_visible(text_property, True)
return True
else:
eg.data = ""
obs.obs_property_set_visible(text_property, False)
return True
def show_tooltip(props, prop, settings):
p = obs.obs_properties_get(props, "text_effect")
docs = getattr(std, std.effect + "_effect", "default")
if docs == "default":
selection = "[error]: there is no such effect".upper()
color = "red"
else:
selection = docs.__doc__
color = "green"
styled_docs = f'<h1 style="color:{color};">{selection}</h1>'
obs.obs_property_set_long_description(p, styled_docs)
return True
def event_start_list_modified(props, property, settings):
event_start_list = obs.obs_properties_get(props, "preshow_duration")
obs.obs_property_list_clear(event_start_list)
for i in range(0, 4):
seconds = i * 60 * 5
obs.obs_property_list_add_int(
event_start_list,
time(hour=math.floor((event_start - seconds) / 60 / 60),
minute=int(
(event_start - seconds) / 60 % 60)).strftime("%I:%M %p"),
seconds)
return True
def is_user_config(props, prop, data):
if data:
config = obs.obs_data_get_json(data)
configjson = json.loads(config)
del (config)
isUserConfig = 'use_user_config' in configjson.keys(
) and configjson['use_user_config']
for a_prop in ('score_names', 'score_count', 'font', 'fgcolor',
'bgcolor'):
thisprop = obs.obs_properties_get(props, a_prop)
obs.obs_property_set_visible(thisprop, not isUserConfig)
del (thisprop)
config_path_property = obs.obs_properties_get(props, 'user_config')
obs.obs_property_set_visible(config_path_property, isUserConfig)
del (config_path_property)
if isUserConfig:
global settings
settings = data
return True
def populate_sources(props, p=None, _settings=None):
p = obs.obs_properties_get(props, 'discord_source')
obs.obs_property_list_clear(p)
obs.obs_property_list_add_string(p, '(none)', '')
sources = obs.obs_enum_sources()
labels = {}
for src in sources:
n = obs.obs_source_get_name(src)
labels[n] = n + ' (' + obs.obs_source_get_display_name(
obs.obs_source_get_id(src)) + ')'
obs.source_list_release(sources)
for n in sorted(labels, key=lambda x: x.lower()):
obs.obs_property_list_add_string(p, labels[n], n)
return True
def authorize_device(props, prop):
global generated_auth_token
nl = Nanoleaf(device_ip)
if nl.generate_auth_token():
generated_auth_key = nl.auth_token
s = obs.obs_properties_get(props, "auth_key")
obs.obs_property_list_add_string(s, generated_auth_key,
generated_auth_key)
return True
print('[OBS-Nanoleaf]: Unable to acquire Authorization!')
print(
'[OBS-Nanoleaf]: Please make sure to Hold the on-off button down for 5-7 seconds until the LED starts flashing in a pattern'
)
def script_coop_settings(props, rtgg_obs: RacetimeObs):
lang = gettext.translation("racetime-obs",
localedir=os.environ['LOCALEDIR'])
_ = lang.gettext
p = obs.obs_properties_add_bool(props, "use_coop",
_("Display coop information?"))
obs.obs_property_set_modified_callback(p, coop_toggled)
coop_group = obs.obs_properties_create()
obs.obs_properties_add_group(props, "coop_group", _("Co-op Mode"),
obs.OBS_GROUP_NORMAL, coop_group)
obs.obs_property_set_visible(obs.obs_properties_get(props, "coop_group"),
rtgg_obs.coop.enabled)
p = obs.obs_properties_add_list(coop_group, "coop_partner",
_("Co-op Partner"),
obs.OBS_COMBO_TYPE_LIST,
obs.OBS_COMBO_FORMAT_STRING)
p = obs.obs_properties_add_list(coop_group, "coop_opponent1",
_("Co-op Rival 1"),
obs.OBS_COMBO_TYPE_LIST,
obs.OBS_COMBO_FORMAT_STRING)
p = obs.obs_properties_add_list(coop_group, "coop_opponent2",
_("Co-op Rival 2"),
obs.OBS_COMBO_TYPE_LIST,
obs.OBS_COMBO_FORMAT_STRING)
fill_coop_entrant_lists(props, rtgg_obs)
p = obs.obs_properties_add_list(coop_group, "coop_our_source",
_("Our Team's Timer"),
obs.OBS_COMBO_TYPE_EDITABLE,
obs.OBS_COMBO_FORMAT_STRING)
obs.obs_property_set_long_description(p, (
_("This text source will display your team's timer when you finish.")))
fill_source_list(p)
p = obs.obs_properties_add_list(coop_group, "coop_opponent_source",
"Rival Team's Timer",
obs.OBS_COMBO_TYPE_EDITABLE,
obs.OBS_COMBO_FORMAT_STRING)
obs.obs_property_set_long_description(
p,
(_("This text source will be use to display your rival's timer when "
"they finish")))
obs.obs_properties_add_color(coop_group, "coop_winner_color",
_("Winner Color:"))
obs.obs_properties_add_color(coop_group, "coop_loser_color",
_("Loser Color:"))
obs.obs_properties_add_color(coop_group, "coop_undetermined_color",
_("Winner Undetermined Color"))
fill_source_list(p)
def b_stop(props, prop, *arg, **kwargs):
p = obs.obs_properties_get(props, "b1")
obs.obs_property_set_description(p, "Start")
obs.obs_property_set_modified_callback(p, b_start)
visible_prop(props, "wf", True)
visible_prop(props, "rf", True)
visible_prop(props, "cb", True)
visible_prop(props, "df", True)
visible_prop(props, "af", True)
visible_prop(props, "al", True)
global run
run = False
return True
def b_start(props, prop, *arg, **kwargs):
p = obs.obs_properties_get(props, "b1")
obs.obs_property_set_description(p, "Stop")
obs.obs_property_set_modified_callback(p, b_stop)
visible_prop(props, "wf", False)
visible_prop(props, "rf", False)
visible_prop(props, "cb", False)
visible_prop(props, "df", False)
visible_prop(props, "af", False)
visible_prop(props, "al", False)
global run
run = True
t = threading.Thread(target=busy_thread)
t.start()
return True
def refresh_pressed(props, prop, *args, **kwargs):
fill_source_list(obs.obs_properties_get(props, "source"))
fill_source_list(obs.obs_properties_get(props, "coop_our_source"))
fill_source_list(obs.obs_properties_get(props, "coop_opponent_source"))
fill_source_list(obs.obs_properties_get(props, "qualifier_par_source"))
fill_source_list(obs.obs_properties_get(props, "qualifier_score_source"))
fill_race_list(rtgg_obs, obs.obs_properties_get(props, "race"),
obs.obs_properties_get(props, "category_filter"))
coop_scripting.fill_coop_entrant_lists(props, rtgg_obs)
if rtgg_obs.race is not None:
rtgg_obs.coop.update_coop_text(rtgg_obs.race, rtgg_obs.full_name)
update_coop_sources()
rtgg_obs.qualifier.update_qualifier_text(rtgg_obs.race,
rtgg_obs.full_name)
rtgg_obs.media_player.race_updated(rtgg_obs.race, rtgg_obs.full_name)
return True
def script_media_player_settings(props, rtgg_obs: RacetimeObs,
media_player_toggled):
lang = gettext.translation("racetime-obs",
localedir=os.environ['LOCALEDIR'])
_ = lang.gettext
p = obs.obs_properties_add_bool(props, "use_media_player",
_("Enable sounds?"))
obs.obs_property_set_modified_callback(p, media_player_toggled)
media_player_group = obs.obs_properties_create()
obs.obs_properties_add_group(props, "media_player_group",
_("Media Player Mode"), obs.OBS_GROUP_NORMAL,
media_player_group)
obs.obs_property_set_visible(
obs.obs_properties_get(props, "media_player_group"),
rtgg_obs.media_player.enabled)
monitoring_list = obs.obs_properties_add_list(media_player_group,
"monitoring_type",
_("Monitoring Type"),
obs.OBS_COMBO_TYPE_LIST,
obs.OBS_COMBO_FORMAT_INT)
obs.obs_property_list_add_int(monitoring_list, _("Listen Only"),
obs.OBS_MONITORING_TYPE_MONITOR_ONLY)
obs.obs_property_list_add_int(monitoring_list, _("Stream Only"),
obs.OBS_MONITORING_TYPE_NONE)
obs.obs_property_list_add_int(monitoring_list, _("Listen and Stream"),
obs.OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT)
p = obs.obs_properties_add_bool(media_player_group, "use_chat_pings",
_("Chat Pings"))
obs.obs_property_set_long_description(
p,
_("Enable this and set choose a sound file to play when a bot posts"
" or when someone @s you in racetime.gg chat"))
p = obs.obs_properties_add_path(media_player_group, "chat_ping_sound",
_("Chat media file"), obs.OBS_PATH_FILE,
"Audio Files (*.mp3 *.aac *.wav *.wma)",
None)
obs.obs_properties_add_path(media_player_group, "first_place_sound",
_("First Place Sound"), obs.OBS_PATH_FILE,
"Audio Files (*.mp3 *.aac *.wav *.wma)", None)
obs.obs_property_set_long_description(
p, _("Sound file to play when you finish first."))
def populate_participants(props, p=None, _settings=None):
if not client.channel:
return False
values = []
for nick, name, disc, uid in (
(x.nick, x.name, x.discriminator, x.id)
for x in sorted(client.channel.guild.members,
key=lambda x: x.display_name.lower() + '!')
if x != client.user):
label = (nick or name) + ' ('
if nick:
label += name + ' '
label += f'#{disc})'
values.append((label, uid))
for name in ['myself'] + [f'participant{i}' for i in range(SLOTS)]:
p = obs.obs_properties_get(props, name)
obs.obs_property_list_clear(p)
obs.obs_property_list_add_string(p, '(none)', '')
for label, uid in values:
obs.obs_property_list_add_string(p, label, str(uid))
return True
def script_timer_settings(props, rtgg_obs: RacetimeObs):
lang = gettext.translation("racetime-obs",
localedir=os.environ['LOCALEDIR'])
_ = lang.gettext
p = obs.obs_properties_add_bool(props, "use_podium",
_("Use custom color for podium finishes?"))
obs.obs_property_set_modified_callback(p, podium_toggled)
podium_group = obs.obs_properties_create()
obs.obs_properties_add_group(props, "podium_group", _("Podium Colors"),
obs.OBS_GROUP_NORMAL, podium_group)
obs.obs_property_set_visible(obs.obs_properties_get(props, "podium_group"),
rtgg_obs.timer.use_podium_colors)
obs.obs_properties_add_color(podium_group, "pre_color", _("Pre-race:"))
obs.obs_properties_add_color(podium_group, "racing_color",
_("Still racing:"))
obs.obs_properties_add_color(podium_group, "first_color", _("1st place:"))
obs.obs_properties_add_color(podium_group, "second_color", _("2nd place:"))
obs.obs_properties_add_color(podium_group, "third_color", _("3rd place:"))
obs.obs_properties_add_color(podium_group, "finished_color",
_("After podium:"))
def prop_modified(props, prop, settings):
# print('prop_modified ', obs.obs_property_name(prop))
status = 'Invalid Path' if not SERVER_ROOT else 'Invalid Port' if PORT == WS_PORT else 'OK'
obs.obs_data_set_string(
settings, 'info', '''Server Root:
%s
Page URL:
http://127.0.0.1:%d
Status:
%s
''' % (SERVER_ROOT or '<empty>', PORT, status))
level_p = obs.obs_properties_get(props, 'root_level')
obs.obs_property_int_set_limits(level_p, 1, total_levels(LIVE2D_FULL_PATH),
1)
return True
def media_trigger_settings(props, rtgg_obs: RacetimeObs, index: int):
lang = gettext.translation("racetime-obs",
localedir=os.environ['LOCALEDIR'])
_ = lang.gettext
media_player_group = obs.obs_properties_create()
name = f"media_trigger_#{index}"
obs.obs_properties_add_group(props, name,
_("Media Trigger #") + f"{index}",
obs.OBS_GROUP_NORMAL, media_player_group)
obs.obs_property_set_visible(
obs.obs_properties_get(props, "media_player_group"),
rtgg_obs.media_player.enabled)
obs.obs_properties_add_path(media_player_group, f"media_path_#{index}",
_("Sound File"), obs.OBS_PATH_FILE,
"Audio Files (*.mp3 *.aac *.wav *.wma)", None)
p = obs.obs_properties_add_list(media_player_group,
f"trigger_type_#{index}",
_("Type of Trigger"),
obs.OBS_COMBO_TYPE_LIST,
obs.OBS_COMBO_FORMAT_STRING)
obs.obs_property_list_add_string(p, "", "")
obs.obs_property_list_add_string(p, _("Chat"), "chat")
obs.obs_property_list_add_string(p, _("Finish Place"), "finish")
obs.obs_property_list_add_string(p, _("Timer"), "time")
obs.obs_property_set_modified_callback(p, media_type_changed)
p = obs.obs_properties_add_list(media_player_group,
f"monitoring_type_#{index}",
_("Monitoring Type"),
obs.OBS_COMBO_TYPE_LIST,
obs.OBS_COMBO_FORMAT_INT)
obs.obs_property_list_add_int(p, _("Only Listen"),
obs.OBS_MONITORING_TYPE_MONITOR_ONLY)
obs.obs_property_list_add_int(p, _("Only Stream"),
obs.OBS_MONITORING_TYPE_NONE)
obs.obs_property_list_add_int(p, _("Listen and Stream"),
obs.OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT)
def callback(props, prop, *args, **kwargs): # pass settings implicitly
p = obs.obs_properties_get(props, "button")
n = next(counter)
obs.obs_property_set_description(p, f"refresh pressed {n} times")
return True
def coop_toggled(props, prop, settings):
vis = obs.obs_data_get_bool(settings, "use_coop")
obs.obs_property_set_visible(obs.obs_properties_get(props, "coop_group"),
vis)
return True
def qualifier_toggled(props, prop, settings):
vis = obs.obs_data_get_bool(settings, "use_qualifier")
obs.obs_property_set_visible(
obs.obs_properties_get(props, "qualifier_group"), vis)
return True
def podium_toggled(props, prop, settings):
vis = obs.obs_data_get_bool(settings, "use_podium")
obs.obs_property_set_visible(obs.obs_properties_get(props, "podium_group"),
vis)
return True
def visible_prop(props, a, b):
x = obs.obs_properties_get(props, a)
obs.obs_property_set_enabled(x, b)
