cyberpresidentvanellope/Bubberstation
1
0
Fork 0
mirror of https://github.com/Bubberstation/Bubberstation.git synced 2026-01-27 09:31:54 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
41d9f73631e34a7182ae888e4fc2728423a65cf2
Bubberstation/code/controllers/subsystem/dynamic/dynamic_admin.dm
MrMelbert e0bdfc3f5f Dynamic Rework (#91290) 
Implements https://hackmd.io/@tgstation/SkeUS7lSp , rewriting Dynamic
from the ground-up

- Dynamic configuration is now vastly streamlined, making it far far far
easier to understand and edit

- Threat is gone entirely; round chaos is now determined by dynamic
tiers
   - There's 5 dynamic tiers, 0 to 4.
      - 0 is a pure greenshift.
- Tiers are just picked via weight - "16% chance of getting a high chaos
round".
- Tiers have min pop ranges. "Tier 4 (high chaos) requires 25 pop to be
selected".
- Tier determines how much of every ruleset is picked. "Tier 4 (High
Chaos) will pick 3-4 roundstart[1], 1-2 light, 1-2 heavy, and 2-3
latejoins".
- The number of rulesets picked depends on how many people are in the
server - this is also configurable[2]. As an example, a tier that
demands "1-3" rulesets will not spawn 3 rulesets if population <= 40 and
will not spawn 2 rulesets if population <= 25.
- Tiers also determine time before light, heavy, and latejoin rulesets
are picked, as well as the cooldown range between spawns. More chaotic
tiers may send midrounds sooner or wait less time between sending them.

- On the ruleset side of things, "requirements", "scaling", and
"enemies" is gone.
- You can configure a ruleset's min pop and weight flat, or per tier.
- For example a ruleset like Obsession is weighted higher for tiers 1-2
and lower for tiers 3-4.
- Rather than scaling up, roundstart rulesets can just be selected
multiple times.
- Rulesets also have `min_antag_cap` and `max_antag_cap`.
`min_antag_cap` determines how many candidates are needed for it to run,
and `max_antag_cap` determines how many candidates are selected.

- Rulesets attempt to run every 2.5 minutes. [3]

- Light rulesets will ALWAYS be picked before heavy rulesets. [4]

- Light injection chance is no longer 100%, heavy injection chance
formula has been simplified.
- Chance simply scales based on number of dead players / total number
off players, with a flag 50% chance if no antags exist. [5]

[1] This does not guarantee you will actually GET 3-4 roundstart
rulesets. If a roundstart ruleset is picked, and it ends up being unable
to execute (such as "not enough candidates", that slot is effectively a
wash.) This might be revisited.

[2] Currently, this is a hard limit - below X pop, you WILL get a
quarter or a half of the rulesets. This might be revisited to just be
weighted - you are just MORE LIKELY to get a quarter or a half.

[3] Little worried about accidentally frontloading everything so we'll
see about this

[4] This may be revisited but in most contexts it seems sensible.

[5] This may also be revisited, I'm not 100% sure what the best / most
simple way to tackle midround chances is.

Other implementation details

- The process of making rulesets has been streamlined as well. Many
rulesets only amount to a definition and `assign_role`.

- Dynamic.json -> Dynamic.toml

- Dynamic event hijacked was ripped out entirely.
- Most midround antag random events are now dynamic rulesets. Fugitives,
Morphs, Slaughter Demons, etc.
      - The 1 weight slaughter demon event is gone. RIP in peace.
- There is now a hidden midround event that simply adds +1 latejoin, +1
light, or +1 heavy ruleset.

- `mind.special_role` is dead. Minds have a lazylist of special roles
now but it's essentially only used for traitor panel.

- Revs refactored almost entirely. Revs can now exist without a dynamic
ruleset.

- Cult refactored a tiny bit.

- Antag datums cleaned up.

- Pre round setup is less centralized on Dynamic.

- Admins have a whole panel for interfacing with dynamic. It's pretty
slapdash I'm sure someone could make a nicer looking one.

![image](https://github.com/user-attachments/assets/e99ca607-20b0-4d30-ab4a-f602babe7ac7)

![image](https://github.com/user-attachments/assets/470c3c20-c354-4ee6-b63b-a8f36dda4b5c)

- Maybe some other things.

See readme for more info.

Will you see a massive change in how rounds play out? My hunch says
rounds will spawn less rulesets on average, but it's ultimately to how
it's configured

🆑 Melbert
refactor: Dynamic rewritten entirely, report any strange rounds
config: Dynamic config reworked, it's now a TOML file
refactor: Refactored antag roles somewhat, report any oddities
refactor: Refactored Revolution entirely, report any oddities
del: Deleted most midround events that spawn antags - they use dynamic
rulesets now
add: Dynamic rulesets can now be false alarms
add: Adds a random event that gives dynamic the ability to run another
ruleset later
admin: Adds a panel for messing around with dynamic
admin: Adds a panel for chance for every dynamic ruleset to be selected
admin: You can spawn revs without using dynamic now
fix: Nuke team leaders get their fun title back
/🆑

(cherry picked from commit 4c277dc572)
2025-06-26 20:12:17 -04:00

255 lines
12 KiB
Plaintext
Raw Blame History

ADMIN_VERB(dynamic_panel, R_ADMIN, "Dynamic Panel", "Mess with dynamic.", ADMIN_CATEGORY_GAME)
dynamic_panel(user.mob)
/proc/dynamic_panel(mob/user)
if(!check_rights(R_ADMIN))
return
var/datum/dynamic_panel/tgui = new()
tgui.ui_interact(user)
log_admin("[key_name(user)] opened the Dynamic Panel.")
if(!isobserver(user))
message_admins("[key_name_admin(user)] opened the Dynamic Panel.")
BLACKBOX_LOG_ADMIN_VERB("Dynamic Panel")
/datum/dynamic_panel
/datum/dynamic_panel/ui_state(mob/user)
return ADMIN_STATE(R_ADMIN)
/datum/dynamic_panel/ui_close()
qdel(src)
/datum/dynamic_panel/ui_interact(mob/user, datum/tgui/ui)
ui = SStgui.try_update_ui(user, src, ui)
if(!ui)
ui = new(user, src, "DynamicAdmin")
ui.open()
/datum/dynamic_panel/ui_data(mob/user)
var/list/data = list()
if(SSdynamic.current_tier)
data["current_tier"] = list(
"number" = SSdynamic.current_tier.tier,
"name" = SSdynamic.current_tier.name,
)
data["ruleset_count"] = list()
for(var/category in SSdynamic.rulesets_to_spawn)
data["ruleset_count"][category] = max(SSdynamic.rulesets_to_spawn[category], 0)
data["full_config"] = SSdynamic.get_config()
data["config_even_enabled"] = CONFIG_GET(flag/dynamic_config_enabled) && length(data["full_config"])
data["queued_rulesets"] = list()
for(var/i in 1 to length(SSdynamic.queued_rulesets))
data["queued_rulesets"] += list(ruleset_to_data(SSdynamic.queued_rulesets[i]) + list("index" = i))
data["active_rulesets"] = list()
for(var/i in 1 to length(SSdynamic.executed_rulesets))
data["active_rulesets"] += list(ruleset_to_data(SSdynamic.executed_rulesets[i]) + list("index" = i))
data["all_rulesets"] = list()
for(var/ruleset_type in subtypesof(/datum/dynamic_ruleset/roundstart))
data["all_rulesets"][ROUNDSTART] += list(ruleset_to_data(ruleset_type))
for(var/ruleset_type in subtypesof(/datum/dynamic_ruleset/midround))
var/datum/dynamic_ruleset/midround/midround = ruleset_type
switch(initial(midround.midround_type))
if(HEAVY_MIDROUND)
data["all_rulesets"][HEAVY_MIDROUND] += list(ruleset_to_data(ruleset_type))
if(LIGHT_MIDROUND)
data["all_rulesets"][LIGHT_MIDROUND] += list(ruleset_to_data(ruleset_type))
for(var/ruleset_type in subtypesof(/datum/dynamic_ruleset/latejoin))
data["all_rulesets"][LATEJOIN] += list(ruleset_to_data(ruleset_type))
data["time_until_lights"] = COOLDOWN_TIMELEFT(SSdynamic, light_ruleset_start)
data["time_until_heavies"] = COOLDOWN_TIMELEFT(SSdynamic, heavy_ruleset_start)
data["time_until_latejoins"] = COOLDOWN_TIMELEFT(SSdynamic, latejoin_ruleset_start)
data["time_until_next_midround"] = COOLDOWN_TIMELEFT(SSdynamic, midround_cooldown)
data["time_until_next_latejoin"] = COOLDOWN_TIMELEFT(SSdynamic, latejoin_cooldown)
data["failed_latejoins"] = SSdynamic.failed_latejoins
data["light_midround_chance"] = SSdynamic.get_midround_chance(LIGHT_MIDROUND)
data["heavy_midround_chance"] = SSdynamic.get_midround_chance(HEAVY_MIDROUND)
data["latejoin_chance"] = SSdynamic.get_latejoin_chance()
data["roundstarted"] = SSticker.HasRoundStarted()
data["light_chance_maxxed"] = SSdynamic.admin_forcing_next_light
data["heavy_chance_maxxed"] = SSdynamic.admin_forcing_next_heavy
data["latejoin_chance_maxxed"] = SSdynamic.admin_forcing_next_latejoin
data["next_dynamic_tick"] = SSdynamic.next_fire ? SSdynamic.next_fire - world.time : SSticker.GetTimeLeft()
data["antag_events_enabled"] = SSdynamic.antag_events_enabled
return data
/// Pass a ruleset typepath or a ruleset instance
/datum/dynamic_panel/proc/ruleset_to_data(datum/dynamic_ruleset/ruleset)
var/list/data = list()
var/ruleset_path = isdatum(ruleset) ? ruleset.type : ruleset
data["name"] = initial(ruleset.name)
data["id"] = initial(ruleset.config_tag)
data["typepath"] = ruleset_path
data["selected_players"] = list()
data["admin_disabled"] = (ruleset_path in SSdynamic.admin_disabled_rulesets)
if(isdatum(ruleset))
for(var/datum/mind/player as anything in ruleset.selected_minds)
data["selected_players"] += list(list(
"key" = player.key,
))
data["hidden"] = (ruleset in SSdynamic.unreported_rulesets)
return data
/datum/dynamic_panel/ui_act(action, list/params, datum/tgui/ui, datum/ui_state/state)
. = ..()
if(.)
return
switch(action)
if("remove_queued_ruleset")
var/index = params["ruleset_index"]
if(length(SSdynamic.queued_rulesets) < index)
return
var/datum/dynamic_ruleset/ruleset = SSdynamic.queued_rulesets[index]
if(!ruleset)
return
SSdynamic.queued_rulesets -= ruleset
message_admins("[key_name_admin(ui.user)] removed [ruleset.config_tag] from the dynamic ruleset queue.")
log_admin("[key_name_admin(ui.user)] removed [ruleset.config_tag] from the dynamic ruleset queue.")
qdel(ruleset)
return TRUE
if("add_queued_ruleset")
var/datum/dynamic_ruleset/ruleset_path = text2path(params["ruleset_type"])
if(!ruleset_path)
return
SSdynamic.queue_ruleset(ruleset_path)
message_admins("[key_name_admin(ui.user)] added [initial(ruleset_path.config_tag)] to the dynamic ruleset queue.")
log_admin("[key_name_admin(ui.user)] added [initial(ruleset_path.config_tag)] to the dynamic ruleset queue.")
return TRUE
if("dynamic_vv")
ui.user?.client?.debug_variables(SSdynamic)
return TRUE
if("add_ruleset_category_count")
var/category = params["ruleset_category"]
if(!category)
return
SSdynamic.rulesets_to_spawn[category] += 1
message_admins("[key_name_admin(ui.user)] added 1 to the [category] ruleset category.")
log_admin("[key_name_admin(ui.user)] added 1 to the [category] ruleset category.")
return TRUE
if("set_ruleset_category_count")
var/category = params["ruleset_category"]
var/count = params["ruleset_count"]
if(!category || !isnum(count))
return
SSdynamic.rulesets_to_spawn[category] = count
message_admins("[key_name_admin(ui.user)] set the [category] ruleset category to [count].")
log_admin("[key_name_admin(ui.user)] set the [category] ruleset category to [count].")
return TRUE
if("execute_ruleset")
var/datum/dynamic_ruleset/ruleset_path = text2path(params["ruleset_type"])
if(!ruleset_path)
return
message_admins("[key_name_admin(ui.user)] executed the ruleset [initial(ruleset_path.config_tag)].")
log_admin("[key_name_admin(ui.user)] executed the ruleset [initial(ruleset_path.config_tag)].")
ASYNC
SSdynamic.force_run_midround(ruleset_path, alert_admins_on_fail = TRUE, admin = ui.user)
return TRUE
if("disable_ruleset")
var/ruleset_path = text2path(params["ruleset_type"])
if(!ruleset_path)
return
if(ruleset_path in SSdynamic.admin_disabled_rulesets)
SSdynamic.admin_disabled_rulesets -= ruleset_path
message_admins("[key_name_admin(ui.user)] enabled [ruleset_path] to be selected.")
log_admin("[key_name_admin(ui.user)] enabled [ruleset_path] to be selected.")
else
SSdynamic.admin_disabled_rulesets += ruleset_path
message_admins("[key_name_admin(ui.user)] disabled [ruleset_path] from being selected.")
log_admin("[key_name_admin(ui.user)] disabled [ruleset_path] from being selected.")
return TRUE
if("disable_all")
SSdynamic.admin_disabled_rulesets |= subtypesof(/datum/dynamic_ruleset)
message_admins("[key_name_admin(ui.user)] disabled all rulesets from being selected.")
log_admin("[key_name_admin(ui.user)] disabled all rulesets from being selected.")
if("enable_all")
SSdynamic.admin_disabled_rulesets.Cut()
message_admins("[key_name_admin(ui.user)] re-enabled all rulesets.")
log_admin("[key_name_admin(ui.user)] re_enabled all rulesets.")
if("set_tier")
if(SSdynamic.current_tier && SSticker.HasRoundStarted())
return TRUE
var/list/tiers = list()
for(var/datum/dynamic_tier/tier as anything in subtypesof(/datum/dynamic_tier))
tiers[initial(tier.name)] = tier
var/datum/dynamic_tier/picked = tgui_input_list(ui.user, "Pick a dynamic tier before the game starts", "Pick tier", tiers, ui_state = ADMIN_STATE(R_ADMIN))
if(picked && !SSticker.HasRoundStarted())
SSdynamic.set_tier(tiers[picked])
message_admins("[key_name_admin(ui.user)] set the dynamic tier to [initial(picked.tier)].")
log_admin("[key_name_admin(ui.user)] set the dynamic tier to [initial(picked.tier)].")
return TRUE
if("max_light_chance")
SSdynamic.admin_forcing_next_light = !SSdynamic.admin_forcing_next_light
message_admins("[key_name_admin(ui.user)] [SSdynamic.admin_forcing_next_light ? "forced" : "reset"] the next light ruleset chance.")
log_admin("[key_name_admin(ui.user)] [SSdynamic.admin_forcing_next_light ? "forced" : "reset"] the next light ruleset chance.")
return TRUE
if("max_heavy_chance")
SSdynamic.admin_forcing_next_heavy = !SSdynamic.admin_forcing_next_heavy
message_admins("[key_name_admin(ui.user)] [SSdynamic.admin_forcing_next_heavy ? "forced" : "reset"] the next heavy ruleset chance.")
log_admin("[key_name_admin(ui.user)] [SSdynamic.admin_forcing_next_heavy ? "forced" : "reset"] the next heavy ruleset chance.")
return TRUE
if("max_latejoin_chance")
SSdynamic.admin_forcing_next_latejoin = !SSdynamic.admin_forcing_next_latejoin
message_admins("[key_name_admin(ui.user)] [SSdynamic.admin_forcing_next_latejoin ? "forced" : "reset"] the next latejoin ruleset chance.")
log_admin("[key_name_admin(ui.user)] [SSdynamic.admin_forcing_next_latejoin ? "forced" : "reset"] the next latejoin ruleset chance.")
return TRUE
if("light_start_now")
COOLDOWN_RESET(SSdynamic, light_ruleset_start)
message_admins("[key_name_admin(ui.user)] reset the light ruleset start cooldown.")
log_admin("[key_name_admin(ui.user)] reset the light ruleset start cooldown.")
return TRUE
if("heavy_start_now")
COOLDOWN_RESET(SSdynamic, heavy_ruleset_start)
message_admins("[key_name_admin(ui.user)] reset the heavy ruleset start cooldown.")
log_admin("[key_name_admin(ui.user)] reset the heavy ruleset start cooldown.")
return TRUE
if("latejoin_start_now")
COOLDOWN_RESET(SSdynamic, latejoin_ruleset_start)
message_admins("[key_name_admin(ui.user)] reset the latejoin ruleset start cooldown.")
log_admin("[key_name_admin(ui.user)] reset the latejoin ruleset start cooldown.")
return TRUE
if("reset_midround_cooldown")
COOLDOWN_RESET(SSdynamic, midround_cooldown)
message_admins("[key_name_admin(ui.user)] reset the midround cooldown.")
log_admin("[key_name_admin(ui.user)] reset the midround cooldown.")
return TRUE
if("reset_latejoin_cooldown")
COOLDOWN_RESET(SSdynamic, latejoin_cooldown)
message_admins("[key_name_admin(ui.user)] reset the latejoin cooldown.")
log_admin("[key_name_admin(ui.user)] reset the latejoin cooldown.")
return TRUE
if("hide_ruleset")
var/index = params["ruleset_index"]
if(length(SSdynamic.executed_rulesets) < index)
return
var/datum/dynamic_ruleset/ruleset = SSdynamic.executed_rulesets[index]
if(!ruleset)
return
if(ruleset in SSdynamic.unreported_rulesets)
SSdynamic.unreported_rulesets -= ruleset
message_admins("[key_name_admin(ui.user)] hid [ruleset] from the roundend report.")
log_admin("[key_name_admin(ui.user)] hid [ruleset] from the roundend report.")
else
SSdynamic.unreported_rulesets += ruleset
message_admins("[key_name_admin(ui.user)] unhid [ruleset] from the roundend report.")
log_admin("[key_name_admin(ui.user)] unhid [ruleset] from the roundend report.")
return TRUE
if("toggle_antag_events")
SSdynamic.antag_events_enabled = !SSdynamic.antag_events_enabled
message_admins("[key_name_admin(ui.user)] [SSdynamic.antag_events_enabled ? "enabled" : "disabled"] antag events.")
log_admin("[key_name_admin(ui.user)] [SSdynamic.antag_events_enabled ? "enabled" : "disabled"] antag events.")
return TRUE
Reference in New Issue View Git Blame Copy Permalink