+use super::{Context, Result};

+use crate::bot::get_nextblock;

+use futures_util::StreamExt;

+use poise::serenity_prelude::*;

+use tokio::sync::Mutex;

+use tokio::sync::{broadcast, OnceCell};

+

+macro_rules! val {

+ ($($k:ident($v:ty)),+) => {

+ #[derive(Clone, Debug)]

+ pub enum Val {

+ $($k($v)),+

+ }

+

+ $(

+ impl From<$v> for Val {

+ fn from(value: $v) -> Self {

+ Self::$k(value)

+ }

+ }

+ )+

+

+ impl std::fmt::Display for Val {

+ fn fmt(&self, f:&mut std::fmt::Formatter<'_>) -> std::fmt::Result {

+ match self {

+ $(Self::$k(x) => write!(f, "{x}"),)+

+ }

+ }

+ }

+ }

+}

+

+val! {

+ Bool(bool),

+ Float(f32),

+ Int(i32),

+ Str(String)

+}

+

+macro_rules! rules {

+ { of $s: ident :

+ $($k:literal: $ty:ty [$doc:literal]),+ $(,)?

+ } => { paste::paste! {

+ impl $s {

+ pub fn reduce(&self) -> impl Iterator<Item = (&'static str, Val)> {

+ [$(self. [ < $k : snake > ].clone().map(Val::from).map(|x| ($k, x))),+].into_iter().filter_map(|x| x.clone())

+ }

+

+ pub fn name() -> &'static [&'static str] {

+ &[$(stringify!([<$k:snake>])),+]

+ }

+

+ pub fn set(&mut self, x: &str,to: &str) -> Result<()> {

+ match x {

+ $(stringify!([< $k : snake> ]) => {

+ self.[ < $k : snake >] = Some(to.parse()?);

+ }),+

+ _ => anyhow::bail!("no such field"),

+ }

+ Ok(())

+ }

+

+ /// returns [`None`] if field not found,

+ /// returns [`Some`](if the field was not none)

+ pub fn delete(&mut self, x: &str) -> Option<bool> {

+ match x {

+ $(stringify!([< $k : snake> ]) => {

+ match &mut self.[ < $k : snake >] {

+ y @ Some(_) => {

+ *y = None;

+ Some(true)

+ },

+ _ => {

+ Some(false)

+ }

+ }

+ }),+

+ _ => None,

+ }

+ }

+ }

+

+

+ #[derive(serde_derive::Serialize, serde_derive::Deserialize)]

+ pub struct $s {

+ $(

+ #[serde(default)]

+ #[serde(rename = $k)]

+ #[serde(skip_serializing_if = "Option::is_none")]

+ pub [< $k : snake>]: Option<$ty>,

+ )+

+ }

+ } }

+}

+

+rules!(

+ of Rules:

+ "infiniteResources": bool ["Sandbox mode: Enables infinite resources, build range and build speed."],

+ // mindustry does a wackky thing here, but

+ // "teams": HashMap<u8, TeamRule> ["Team-specific rules."],

+ "coreCapture": bool ["Whether cores change teams when they are destroyed."],

+ "reactorExplosions": bool ["Whether reactors can explode and damage other blocks."],

+ "possessionAllowed": bool ["Whether to allow manual unit control."],

+ "schematicsAllowed": bool ["Whether schematics are allowed."],

+ "damageExplosions": bool ["Whether friendly explosions can occur and set fire/damage other blocks."],

+ "fire": bool ["Whether fire (and neoplasm spread) is enabled."],

+ "unitAmmo": bool ["Whether units use and require ammo."],

+ "unitPayloadUpdate": bool ["EXPERIMENTAL! If true, blocks will update in units and share power."],

+ "unitCapVariable": bool ["Whether cores add to unit limit"],

+ "showSpawns": bool ["If true, unit spawn points are shown."],

+ "solarMultiplier": f32 ["Multiplies power output of solar panels."],

+ "unitBuildSpeedMultiplier": f32 ["How fast unit factories build units."],

+ "unitCostMultiplier": f32 ["Multiplier of resources that units take to build."],

+ "unitDamageMultiplier": f32 ["How much damage units deal."],

+ "unitHealthMultiplier": f32 ["How much health units start with."],

+ "unitCrashDamageMultiplier": f32 ["How much damage unit crash damage deals. (Compounds with unitDamageMultiplier)"],

+ "ghostBlocks": bool ["If true, ghost blocks will appear upon destruction, letting builder blocks/units rebuild them."],

+ "logicUnitBuild": bool ["Whether to allow units to build with logic."],

+ "disableWorldProcessors": bool ["If true, world processors no longer update. Used for testing."],

+ "blockHealthMultiplier": f32 ["How much health blocks start with."],

+ "blockDamageMultiplier": f32 ["How much damage blocks (turrets) deal."],

+ "buildCostMultiplier": f32 ["Multiplier for buildings resource cost."],

+ "buildSpeedMultiplier": f32 ["Multiplier for building speed."],

+ "deconstructRefundMultiplier": f32 ["Multiplier for percentage of materials refunded when deconstructing."],

+ "enemyCoreBuildRadius": f32 ["No-build zone around enemy core radius."],

+ "polygonCoreProtection": bool ["If true, no-build zones are calculated based on the closest core."],

+ "placeRangeCheck": bool ["If true, blocks cannot be placed near blocks that are near the enemy team."],

+ "cleanupDeadTeams": bool ["If true, dead teams in PvP automatically have their blocks & units converted to derelict upon death."],

+ "onlyDepositCore": bool ["If true, items can only be deposited in the core."],

+ "coreDestroyClear": bool ["If true, every enemy block in the radius of the (enemy) core is destroyed upon death. Used for campaign maps."],

+ "hideBannedBlocks": bool ["If true, banned blocks are hidden from the build menu."],

+ "blockWhitelist": bool ["If true, bannedBlocks becomes a whitelist."],

+ "unitWhitelist": bool ["If true, bannedUnits becomes a whitelist."],

+ "unitCap": i32 ["Base unit cap. Can still be increased by blocks."],

+ "dragMultiplier": f32 ["Environment drag multiplier."],

+ "env": i32["Environmental flags that dictate visuals & how blocks function."],

+ // TODO

+ // "weather": Vec<Weather> ["Weather events that occur here."],

+ // "bannedBlocks": Vec<Block> ["Blocks that cannot be placed."],

+ // "bannedUnits": Vec<Unit> ["Units that cannot be built."],

+ // "revealedBlocks": Vec<Block> ["Reveals blocks normally hidden by build visibility."],

+ // "hiddenBuildItems": Vec<Item> ["Block containing these items as requirements are hidden."],

+ // "objectives": MapObjectives ["In-map objective executor."],

+ // "objectiveFlags": ObjectSet<String> ["Flags set by objectives. Used in world processors."],

+ // "planet": Planet ["Rules from this planet are applied. If it's "sun", mixed tech is enabled."],

+ "fog": bool ["If true, fog of war is enabled. Enemy units and buildings are hidden unless in radar view."],

+ "staticFog": bool ["If fog = true, this is whether static (black) fog is enabled."],

+ "staticColor": String ["Color for static, undiscovered fog of war areas."],

+ "dynamicColor": String ["Color for discovered but un-monitored fog of war areas."],

+ "lighting": bool ["Whether ambient lighting is enabled."],

+ "ambientLight": String ["Ambient light color, used when lighting is enabled."],

+ "modeName": String ["name of the custom mode that this ruleset describes, or null."],

+ "mission": String ["Mission string displayed instead of wave/core counter. Null to disable."],

+ "coreIncinerates": bool ["Whether cores incinerate items when full, just like in the campaign."],

+ "borderDarkness": bool ["If false, borders fade out into darkness. Only use with custom backgrounds!"],

+ "backgroundTexture": String ["path to background texture with extension (e.g. \"sprites/space.png\")"],

+ "backgroundSpeed": f32 ["background texture move speed scaling - bigger numbers mean slower movement. 0 to disable."],

+ "backgroundScl": f32 ["background texture scaling factor"],

+ "backgroundOffsetX": f32 ["background UV offsets"],

+

+);

+

+// rules!(

+// of TeamRule:

+// "aiCoreSpawn": bool ["Whether, when AI is enabled, ships should be spawned from the core."],

+// "cheat": bool ["If true, blocks don't require power or resources."],

+// "infiniteResources": bool ["If true, resources are not consumed when building."],

+// "infiniteAmmo": bool ["If true, this team has infinite unit ammo."],

+// "buildAi": bool ["AI that builds random schematics."],

+// "buildAiTier": f32 ["Tier of builder AI. [0, 1]"],

+// "rtsAi": bool ["Enables \"RTS\" unit AI."],

+// "rtsMinSquad": i32["Minimum size of attack squads."],

+// "rtsMaxSquad": i32["Maximum size of attack squads."],

+// "rtsMinWeight": f32 ["Minimum \"advantage\" needed for a squad to attack. Higher -> more cautious."],

+// "unitBuildSpeedMultiplier": f32 ["How fast unit factories build units."],

+// "unitDamageMultiplier": f32 ["How much damage units deal."],

+// "unitCrashDamageMultiplier": f32 ["How much damage unit crash damage deals. (Compounds with unitDamageMultiplier)"],

+// "unitCostMultiplier": f32 ["Multiplier of resources that units take to build."],

+// "unitHealthMultiplier": f32 ["How much health units start with."],

+// "blockHealthMultiplier": f32 ["How much health blocks start with."],

+// "blockDamageMultiplier": f32 ["How much damage blocks (turrets) deal."],

+// "buildSpeedMultiplier": f32 ["Multiplier for building speed."],

+// );

+

+pub async fn commit(stdin: &broadcast::Sender<String>) {

+ crate::send!(

+ stdin,

+ "rules {}",

+ serde_json::to_string(&*rules(stdin).await).unwrap()

+ )

+ .unwrap();

+}

+

+pub async fn rules(stdin: &broadcast::Sender<String>) -> tokio::sync::MutexGuard<Rules> {

+ static RULES: OnceCell<Mutex<Rules>> = OnceCell::const_new();

+ RULES

+ .get_or_init(|| async move {

+ crate::send!(stdin, "rules").unwrap();

+ let res = get_nextblock().await;

+ Mutex::new(deser_hjson::from_str(&res).unwrap())

+ })

+ .await

+ .lock()

+ .await

+}

+

+#[poise::command(slash_command, category = "Configuration", rename = "list_rules")]

+/// check them rules

+pub async fn list(ctx: Context<'_>) -> Result<()> {

+ poise::send_reply(

+ ctx,

+ poise::CreateReply::default().embed(

+ CreateEmbed::new()

+ .title("rules")

+ .fields(

+ rules(&ctx.data().stdin)

+ .await

+ .reduce()

+ .map(|(a, b)| (a.to_string(), b.to_string(), true)),

+ )

+ .color(super::SUCCESS),

+ ),

+ )

+ .await?;

+ Ok(())

+}

+

+pub async fn autocomplete<'a>(

+ _: Context<'a>,

+ partial: &'a str,

+) -> impl futures::Stream<Item = &'a str> + 'a {

+ futures::stream::iter(Rules::name())

+ .filter(move |name| futures::future::ready(name.starts_with(partial)))

+ .map(|&x| x)

+}

+

+#[poise::command(

+ slash_command,

+ category = "Configuration",

+ rename = "set_rule",

+ default_member_permissions = "ADMINISTRATOR",

+ required_permissions = "ADMINISTRATOR"

+)]

+/// set a rule

+pub async fn set(

+ ctx: Context<'_>,

+ #[description = "rule"]

+ #[autocomplete = "autocomplete"]

+ rule: String,

+ #[description = "lol"] value: String,

+) -> Result<()> {

+ rules(&ctx.data().stdin).await.set(&rule, &value)?;

+ commit(&ctx.data().stdin).await;

+ poise::say_reply(ctx, "<:ok:1182120559916625971>").await?;

+ Ok(())

+}

+

+#[poise::command(

+ slash_command,

+ category = "Configuration",

+ rename = "delete_rule",

+ default_member_permissions = "ADMINISTRATOR",

+ required_permissions = "ADMINISTRATOR"

+)]

+/// delete a rule

+pub async fn del(

+ ctx: Context<'_>,

+ #[description = "rule"]

+ #[autocomplete = "autocomplete"]

+ rule: String,

+) -> Result<()> {

+ match rules(&ctx.data().stdin).await.delete(&rule) {

+ Some(true) => poise::say_reply(ctx, "<:ok:1182120559916625971>"),

+ Some(false) => poise::say_reply(

+ ctx,

+ "<:warning:1182119952048726066> rule existed, but already none",

+ ),

+

+ None => poise::say_reply(ctx, "<:cancel:1182128899166064720> invalid rule!"),

+ }

+ .await?;

+ commit(&ctx.data().stdin).await;

+

+ Ok(())

+}