make ui a bit more clear, spawn ragdolls when you die in perma death

bgkillas · bgkillas · commit e9bddda90428 · 2024-12-07T11:17:03.000-05:00
diff --git a/noita-proxy/assets/lang/en-US/main.ftl b/noita-proxy/assets/lang/en-US/main.ftl
@@ -106,6 +106,8 @@ shared_health_desc_1 = Health is shared, but scales with player count.
 shared_health_desc_2 = Percentage-based damage and full heals are adjusted.
 shared_health_desc_3 = The original mode.
 Local-health = Local health
+Local-health-alt = Local health alternate
+Local-health-perma = Local health perma death
 Shared-health = Shared health
 Game-mode = Game mode
 world-sync-is-pixel-sync-note = Note: World sync refers to the part that syncs pixels(materials) of the world. Enemies and other entities aren't affected by this.
diff --git a/noita-proxy/src/lib.rs b/noita-proxy/src/lib.rs
@@ -59,24 +59,28 @@ const DEFAULT_PORT: u16 = 5123;
 #[derive(Debug, Decode, Encode, Clone, Serialize, Deserialize, PartialEq, Eq, Copy)]
 pub(crate) enum GameMode {
     SharedHealth,
-    LocalHealth,
+    LocalHealth(LocalHealthMode),
     // MestariMina, // TODO later
 }
 
+#[derive(Debug, Decode, Encode, Clone, Serialize, Deserialize, PartialEq, Eq, Copy)]
+pub(crate) enum LocalHealthMode {
+    Normal,
+    Alternate,
+    PermaDeath,
+}
+
 #[derive(Debug, Decode, Encode, Clone, Serialize, Deserialize, PartialEq, Default)]
 #[serde(default)]
 pub struct GameSettings {
     seed: u64,
     world_num: u16,
     debug_mode: Option<bool>,
-    world_sync_version: Option<u32>,
     use_constant_seed: bool,
     item_dedup: Option<bool>,
     enemy_hp_mult: Option<f32>,
-    world_sync_interval: Option<u32>,
     game_mode: Option<GameMode>,
     friendly_fire: Option<bool>,
-    enemy_sync_interval: Option<u32>,
     randomize_perks: Option<bool>,
     progress: Vec<String>,
     max_players: Option<u32>,
@@ -85,10 +89,8 @@ pub struct GameSettings {
     no_material_damage: Option<bool>,
     global_hp_loss: Option<bool>,
     perk_ban_list: Option<String>,
-    perma_death: Option<bool>,
     physics_damage: Option<bool>,
     share_gold: Option<bool>,
-    no_notplayer: Option<bool>,
 }
 impl GameSettings {
     fn show_editor(&mut self, ui: &mut Ui, enabled: bool) {
@@ -102,7 +104,25 @@ impl GameSettings {
                     .radio_value(&mut temp, GameMode::SharedHealth, tr("Shared-health"))
                     .changed()
                     || ui
-                        .radio_value(&mut temp, GameMode::LocalHealth, tr("Local-health"))
+                        .radio_value(
+                            &mut temp,
+                            GameMode::LocalHealth(LocalHealthMode::Normal),
+                            tr("Local-health"),
+                        )
+                        .changed()
+                    || ui
+                        .radio_value(
+                            &mut temp,
+                            GameMode::LocalHealth(LocalHealthMode::Alternate),
+                            tr("Local-health-alt"),
+                        )
+                        .changed()
+                    || ui
+                        .radio_value(
+                            &mut temp,
+                            GameMode::LocalHealth(LocalHealthMode::PermaDeath),
+                            tr("Local-health-perma"),
+                        )
                         .changed()
                 {
                     game_settings.game_mode = Some(temp)
@@ -124,55 +144,64 @@ impl GameSettings {
                             game_settings.health_per_player = Some(temp)
                         }
                     }
-                    GameMode::LocalHealth => {
+                    GameMode::LocalHealth(mode) => {
                         ui.label(tr("local_health_desc_1"));
-                        ui.label(tr("local_health_desc_2"));
-                        ui.add_space(5.0);
-                        ui.label(tr("Health-percent-lost-on-reviving"));
-                        {
-                            let mut temp = game_settings
-                                .health_lost_on_revive
-                                .unwrap_or(def.health_lost_on_revive);
-                            if ui.add(Slider::new(&mut temp, 0..=100)).changed() {
-                                game_settings.health_lost_on_revive = Some(temp)
-                            }
-                        }
-                        {
-                            let mut temp =
-                                game_settings.global_hp_loss.unwrap_or(def.global_hp_loss);
-                            if ui.checkbox(&mut temp, tr("global_hp_loss")).changed() {
-                                game_settings.global_hp_loss = Some(temp)
-                            }
-                        }
-                        {
-                            let mut temp = game_settings
-                                .no_material_damage
-                                .unwrap_or(def.no_material_damage);
-                            if ui.checkbox(&mut temp, tr("no_material_damage")).changed() {
-                                game_settings.no_material_damage = Some(temp)
-                            }
-                        }
-                        ui.add_space(1.0);
-                        {
-                            let mut temp = game_settings.perma_death.unwrap_or(def.perma_death);
-                            if ui.checkbox(&mut temp, tr("perma_death")).changed() {
-                                game_settings.perma_death = Some(temp)
-                            }
-                        }
-                        ui.add_space(1.0);
-                        {
-                            let mut temp =
-                                game_settings.physics_damage.unwrap_or(def.physics_damage);
-                            if ui.checkbox(&mut temp, tr("physics_damage")).changed() {
-                                game_settings.physics_damage = Some(temp)
+                        match mode {
+                            LocalHealthMode::Normal => {
+                                ui.add_space(5.0);
+                                ui.label(tr("Health-percent-lost-on-reviving"));
+                                {
+                                    let mut temp = game_settings
+                                        .health_lost_on_revive
+                                        .unwrap_or(def.health_lost_on_revive);
+                                    if ui.add(Slider::new(&mut temp, 0..=100)).changed() {
+                                        game_settings.health_lost_on_revive = Some(temp)
+                                    }
+                                }
+                                {
+                                    let mut temp =
+                                        game_settings.global_hp_loss.unwrap_or(def.global_hp_loss);
+                                    if ui.checkbox(&mut temp, tr("global_hp_loss")).changed() {
+                                        game_settings.global_hp_loss = Some(temp)
+                                    }
+                                }
+                                {
+                                    let mut temp = game_settings
+                                        .no_material_damage
+                                        .unwrap_or(def.no_material_damage);
+                                    if ui.checkbox(&mut temp, tr("no_material_damage")).changed() {
+                                        game_settings.no_material_damage = Some(temp)
+                                    }
+                                }
+                                ui.add_space(1.0);
+                                {
+                                    let mut temp =
+                                        game_settings.physics_damage.unwrap_or(def.physics_damage);
+                                    if ui.checkbox(&mut temp, tr("physics_damage")).changed() {
+                                        game_settings.physics_damage = Some(temp)
+                                    }
+                                }
                             }
-                        }
-                        ui.add_space(1.0);
-                        {
-                            let mut temp = game_settings.no_notplayer.unwrap_or(def.no_notplayer);
-                            if ui.checkbox(&mut temp, "no minua").changed() {
-                                game_settings.no_notplayer = Some(temp)
+                            LocalHealthMode::Alternate => {
+                                ui.add_space(5.0);
+                                ui.label(tr("Health-percent-lost-on-reviving"));
+                                {
+                                    let mut temp = game_settings
+                                        .health_lost_on_revive
+                                        .unwrap_or(def.health_lost_on_revive);
+                                    if ui.add(Slider::new(&mut temp, 0..=100)).changed() {
+                                        game_settings.health_lost_on_revive = Some(temp)
+                                    }
+                                }
+                                {
+                                    let mut temp =
+                                        game_settings.global_hp_loss.unwrap_or(def.global_hp_loss);
+                                    if ui.checkbox(&mut temp, tr("global_hp_loss")).changed() {
+                                        game_settings.global_hp_loss = Some(temp)
+                                    }
+                                }
                             }
+                            LocalHealthMode::PermaDeath => {}
                         }
                     }
                 }
@@ -284,38 +313,30 @@ impl GameSettings {
 }
 pub struct DefaultSettings {
     debug_mode: bool,
-    world_sync_version: u32,
     item_dedup: bool,
     enemy_hp_mult: f32,
-    world_sync_interval: u32,
     game_mode: GameMode,
     friendly_fire: bool,
-    enemy_sync_interval: u32,
     randomize_perks: bool,
     max_players: u32,
     health_per_player: u32,
     health_lost_on_revive: u32,
     no_material_damage: bool,
     global_hp_loss: bool,
     perk_ban_list: String,
-    perma_death: bool,
     physics_damage: bool,
     share_gold: bool,
-    no_notplayer: bool,
 }
 
 impl Default for DefaultSettings {
     fn default() -> Self {
         DefaultSettings {
             debug_mode: false,
-            world_sync_version: 2,
             item_dedup: true,
             randomize_perks: true,
             enemy_hp_mult: 1.0,
-            world_sync_interval: 3,
-            game_mode: GameMode::LocalHealth,
+            game_mode: GameMode::LocalHealth(LocalHealthMode::Normal),
             friendly_fire: false,
-            enemy_sync_interval: 3,
             max_players: 250,
             health_per_player: 100,
             health_lost_on_revive: 0,
@@ -324,10 +345,8 @@ impl Default for DefaultSettings {
             perk_ban_list:
                 "GLOBAL_GORE,GLASS_CANNON,REVENGE_RATS,PLAGUE_RATS,VOMIT_RATS,CORDYCEPS,MOLD"
                     .to_string(),
-            perma_death: false,
             physics_damage: true,
             share_gold: false,
-            no_notplayer: false,
         }
     }
 }
diff --git a/noita-proxy/src/net.rs b/noita-proxy/src/net.rs
@@ -27,7 +27,7 @@ use crate::mod_manager::{get_mods, ModmanagerSettings};
 use crate::player_cosmetics::{create_player_png, PlayerPngDesc};
 use crate::{
     bookkeeping::save_state::{SaveState, SaveStateEntry},
-    DefaultSettings, GameSettings,
+    DefaultSettings, GameMode, GameSettings, LocalHealthMode,
 };
 pub mod messages;
 mod proxy_opt;
@@ -508,12 +508,6 @@ impl NetManager {
         );
         state.try_ws_write_option("share_gold", settings.share_gold.unwrap_or(def.share_gold));
         state.try_ws_write_option("debug", settings.debug_mode.unwrap_or(def.debug_mode));
-        state.try_ws_write_option(
-            "world_sync_version",
-            settings
-                .world_sync_version
-                .unwrap_or(def.world_sync_version),
-        );
         state.try_ws_write_option("item_dedup", settings.item_dedup.unwrap_or(def.item_dedup));
         state.try_ws_write_option(
             "randomize_perks",
@@ -523,39 +517,27 @@ impl NetManager {
             "enemy_hp_scale",
             settings.enemy_hp_mult.unwrap_or(def.enemy_hp_mult),
         );
-        state.try_ws_write_option(
-            "world_sync_interval",
-            settings
-                .world_sync_interval
-                .unwrap_or(def.world_sync_interval),
-        );
-        state.try_ws_write_option("game_mode", settings.game_mode.unwrap_or(def.game_mode));
+        let mode = settings.game_mode.unwrap_or(def.game_mode);
+        state.try_ws_write_option("game_mode", mode);
+        if let GameMode::LocalHealth(mode) = mode {
+            match mode {
+                LocalHealthMode::Normal => {}
+                LocalHealthMode::PermaDeath => state.try_ws_write_option("perma_death", true),
+                LocalHealthMode::Alternate => state.try_ws_write_option("no_notplayer", true),
+            }
+        }
         state.try_ws_write_option(
             "health_per_player",
             settings.health_per_player.unwrap_or(def.health_per_player),
         );
-        state.try_ws_write_option(
-            "enemy_sync_interval",
-            settings
-                .enemy_sync_interval
-                .unwrap_or(def.enemy_sync_interval),
-        );
         state.try_ws_write_option(
             "global_hp_loss",
             settings.global_hp_loss.unwrap_or(def.global_hp_loss),
         );
-        state.try_ws_write_option(
-            "perma_death",
-            settings.perma_death.unwrap_or(def.perma_death),
-        );
         state.try_ws_write_option(
             "physics_damage",
             settings.physics_damage.unwrap_or(def.physics_damage),
         );
-        state.try_ws_write_option(
-            "no_notplayer",
-            settings.no_notplayer.unwrap_or(def.no_notplayer),
-        );
         let lst = settings.clone();
         state.try_ws_write_option(
             "perk_ban_list",
diff --git a/noita-proxy/src/net/proxy_opt.rs b/noita-proxy/src/net/proxy_opt.rs
@@ -1,6 +1,5 @@
-use std::io::Write;
-
 use crate::GameMode;
+use std::io::Write;
 
 /// Trait that allows to pass value to mod as proxy options.
 pub(crate) trait ProxyOpt {
@@ -43,7 +42,7 @@ impl ProxyOpt for GameMode {
             GameMode::SharedHealth => {
                 write!(buf, "proxy_opt {} shared_health", key).unwrap();
             }
-            GameMode::LocalHealth => {
+            GameMode::LocalHealth(_) => {
                 write!(buf, "proxy_opt {} local_health", key).unwrap();
             }
         }
diff --git a/quant.ew/files/system/local_health/local_health.lua b/quant.ew/files/system/local_health/local_health.lua
@@ -292,6 +292,11 @@ local function no_notplayer()
     polymorph.switch_entity(ent + 1)
 end
 
+rpc.opts_everywhere()
+function rpc.spawn_ragdoll(x, y)
+    LoadRagdoll("mods/quant.ew/files/system/player/tmp/".. ctx.rpc_peer_id.."_ragdoll.txt", x, y)
+end
+
 local function player_died()
     if ctx.my_player.entity == nil then
         return
@@ -315,11 +320,13 @@ local function player_died()
     end
     if ctx.proxy_opt.perma_death then
         remove_inventory()
+        local x, y = EntityGetTransform(ctx.my_player.entity)
         local ent = LoadGameEffectEntityTo(ctx.my_player.entity, "mods/quant.ew/files/system/local_health/notplayer/cessation.xml")
         EntityAddTag(ent + 1, "ew_notplayer")
         polymorph.switch_entity(ent + 1)
         GameAddFlagRun("msg_gods_looking")
         GameAddFlagRun("msg_gods_looking2")
+        rpc.spawn_ragdoll(x, y)
         return
     end
     local gold = get_gold()
@@ -389,6 +396,11 @@ local function do_game_over(message)
     GameRemoveFlagRun("ew_flag_notplayer_active")
     set_camera_free(true, ctx.my_player.entity)
 
+    if ctx.proxy_opt.perma_death then
+        GameTriggerGameOver()
+        return
+    end
+
     if not GameHasFlagRun("ending_game_completed") then
         for peer_id, data in pairs(ctx.players) do
             if peer_id ~= ctx.my_id

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`		`-use std::io::Write;`
`2`		`-`
`3`	`1`	`use crate::GameMode;`
	`2`	`+use std::io::Write;`
`4`	`3`
`5`	`4`	`/// Trait that allows to pass value to mod as proxy options.`
`6`	`5`	`pub(crate) trait ProxyOpt {`
`@@ -43,7 +42,7 @@ impl ProxyOpt for GameMode {`
`43`	`42`	`GameMode::SharedHealth => {`
`44`	`43`	`write!(buf, "proxy_opt {} shared_health", key).unwrap();`
`45`	`44`	`}`
`46`		`- GameMode::LocalHealth => {`
	`45`	`+ GameMode::LocalHealth(_) => {`
`47`	`46`	`write!(buf, "proxy_opt {} local_health", key).unwrap();`
`48`	`47`	`}`
`49`	`48`	`}`