unlocksDoors tests, and bypassesDoorShell 'free' fix

Author: blkerby

rust/maprando-game/src/lib.rs

@@ -4127,7 +4127,8 @@ impl GameData {
         } else {
             (None, None)
         };
-        let bypasses_door_shell = strat_json["bypassesDoorShell"].as_str().unwrap_or("no") == "yes";
+        let bypasses_door_shell =
+            ["yes", "free"].contains(&strat_json["bypassesDoorShell"].as_str().unwrap_or("no"));
         let (exit_condition, exit_req) = if strat_json.has_key("exitCondition") {
             ensure!(strat_json["exitCondition"].is_object());
             let (e, r) = self.parse_exit_condition(
@@ -4188,7 +4189,7 @@ impl GameData {
             let strat_name = strat_json["name"].as_str().unwrap().to_string();
             let strat_notes = self.parse_note(&strat_json["note"]);
 
-            if bypasses_door_shell {
+            if strat_json["bypassesDoorShell"].as_str().unwrap_or("no") == "yes" {
                 requires_vec.push(Requirement::Tech(
                     self.tech_isv.index_by_key[&TECH_ID_CAN_SKIP_DOOR_LOCK],
                 ));

rust/maprando/src/randomize.rs

@@ -2521,10 +2521,7 @@ impl<'a> Preprocessor<'a> {
         }
     }
 
-    fn get_come_in_with_r_mode_reqs(
-        &self,
-        exit_condition: &ExitCondition,
-    ) -> Option<Requirement> {
+    fn get_come_in_with_r_mode_reqs(&self, exit_condition: &ExitCondition) -> Option<Requirement> {
         match exit_condition {
             ExitCondition::LeaveWithGModeSetup { .. } => {
                 let reqs: Vec<Requirement> = vec![
@@ -3149,6 +3146,49 @@ fn get_walls(map: &Map, game_data: &GameData) -> Vec<DoorPtrPair> {
     out
 }
 
+pub fn make_locked_door_data(
+    locked_doors: Vec<LockedDoor>,
+    game_data: &GameData,
+) -> LockedDoorData {
+    let mut locked_door_node_map: HashMap<(RoomId, NodeId), usize> = HashMap::new();
+    for (i, door) in locked_doors.iter().enumerate() {
+        let (src_room_id, src_node_id) = game_data.door_ptr_pair_map[&door.src_ptr_pair];
+        locked_door_node_map.insert((src_room_id, src_node_id), i);
+        if door.bidirectional {
+            let (dst_room_id, dst_node_id) = game_data.door_ptr_pair_map[&door.dst_ptr_pair];
+            locked_door_node_map.insert((dst_room_id, dst_node_id), i);
+        }
+    }
+
+    // Homing Geemer Room left door -> West Ocean Bridge left door
+    if let Some(&idx) = locked_door_node_map.get(&(313, 1)) {
+        locked_door_node_map.insert((32, 7), idx);
+    }
+
+    // Homing Geemer Room right door -> West Ocean Bridge right door
+    if let Some(&idx) = locked_door_node_map.get(&(313, 2)) {
+        locked_door_node_map.insert((32, 8), idx);
+    }
+
+    // Pants Room right door -> East Pants Room right door
+    if let Some(&idx) = locked_door_node_map.get(&(322, 2)) {
+        locked_door_node_map.insert((220, 2), idx);
+    }
+
+    let mut locked_door_vertex_ids = vec![vec![]; locked_doors.len()];
+    for (&(room_id, node_id), vertex_ids) in &game_data.node_door_unlock {
+        if let Some(&locked_door_idx) = locked_door_node_map.get(&(room_id, node_id)) {
+            locked_door_vertex_ids[locked_door_idx].extend(vertex_ids);
+        }
+    }
+
+    LockedDoorData {
+        locked_doors,
+        locked_door_node_map,
+        locked_door_vertex_ids,
+    }
+}
+
 pub fn randomize_doors(
     game_data: &GameData,
     map: &Map,
@@ -3239,43 +3279,7 @@ pub fn randomize_doors(
         });
     }
 
-    let mut locked_door_node_map: HashMap<(RoomId, NodeId), usize> = HashMap::new();
-    for (i, door) in locked_doors.iter().enumerate() {
-        let (src_room_id, src_node_id) = game_data.door_ptr_pair_map[&door.src_ptr_pair];
-        locked_door_node_map.insert((src_room_id, src_node_id), i);
-        if door.bidirectional {
-            let (dst_room_id, dst_node_id) = game_data.door_ptr_pair_map[&door.dst_ptr_pair];
-            locked_door_node_map.insert((dst_room_id, dst_node_id), i);
-        }
-    }
-
-    // Homing Geemer Room left door -> West Ocean Bridge left door
-    if let Some(&idx) = locked_door_node_map.get(&(313, 1)) {
-        locked_door_node_map.insert((32, 7), idx);
-    }
-
-    // Homing Geemer Room right door -> West Ocean Bridge right door
-    if let Some(&idx) = locked_door_node_map.get(&(313, 2)) {
-        locked_door_node_map.insert((32, 8), idx);
-    }
-
-    // Pants Room right door -> East Pants Room right door
-    if let Some(&idx) = locked_door_node_map.get(&(322, 2)) {
-        locked_door_node_map.insert((220, 2), idx);
-    }
-
-    let mut locked_door_vertex_ids = vec![vec![]; locked_doors.len()];
-    for (&(room_id, node_id), vertex_ids) in &game_data.node_door_unlock {
-        if let Some(&locked_door_idx) = locked_door_node_map.get(&(room_id, node_id)) {
-            locked_door_vertex_ids[locked_door_idx].extend(vertex_ids);
-        }
-    }
-
-    LockedDoorData {
-        locked_doors,
-        locked_door_node_map,
-        locked_door_vertex_ids,
-    }
+    make_locked_door_data(locked_doors, game_data)
 }
 
 // An inexpensive way to evaluate whether a requirement may be possible to satisfy,

rust/maprando/tests/logic_scenarios.rs

@@ -3,7 +3,7 @@ use std::{env, path::Path};
 use anyhow::{Context, Result, bail};
 use hashbrown::HashMap;
 use maprando::{
-    randomize::{DifficultyConfig, Preprocessor},
+    randomize::{DifficultyConfig, LockedDoor, Preprocessor, make_locked_door_data},
     settings::{
         DisableETankSetting, InitialMapRevealSettings, ItemProgressionSettings, Objective,
         ObjectiveSettings, OtherSettings, QualityOfLifeSettings, RandomizerSettings,
@@ -12,8 +12,8 @@ use maprando::{
     traverse::{LockedDoorData, Traverser},
 };
 use maprando_game::{
-    Capacity, GameData, LinksDataGroup, NodeId, NotableId, ObstacleMask, RoomId, VertexId,
-    VertexKey,
+    BeamType, Capacity, DoorPtrPair, DoorType, GameData, LinksDataGroup, NodeId, NotableId,
+    ObstacleMask, RoomId, VertexId, VertexKey,
 };
 use maprando_logic::{GlobalState, Inventory, LocalState, ResourceLevel};
 use serde::Deserialize;
@@ -45,6 +45,8 @@ struct Scenario {
     #[serde(default)]
     settings: ScenarioSettings,
     global_state: Option<ScenarioGlobalState>,
+    #[serde(default)]
+    locked_doors: Vec<ScenarioLockedDoor>,
     start_room_id: usize,
     start_node_id: usize,
     #[serde(default)]
@@ -111,6 +113,28 @@ struct ScenarioGlobalState {
     pool_max_power_bombs: Option<Capacity>,
 }
 
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct ScenarioLockedDoor {
+    room_id: RoomId,
+    node_id: NodeId,
+    type_: ScenarioLockedDoorType,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+enum ScenarioLockedDoorType {
+    Red,
+    Green,
+    Yellow,
+    Charge,
+    Ice,
+    Spazer,
+    Wave,
+    Plasma,
+    Wall,
+}
+
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct ScenarioNotable {
@@ -355,6 +379,7 @@ fn get_global_state(
     game_data: &GameData,
     difficulty: &DifficultyConfig,
     scenario: &Scenario,
+    locked_door_data: &LockedDoorData,
 ) -> Result<GlobalState> {
     let mut flags = vec![false; game_data.flag_isv.keys.len()];
 
@@ -449,7 +474,7 @@ fn get_global_state(
         inventory,
         pool_inventory,
         flags,
-        doors_unlocked: vec![],
+        doors_unlocked: vec![false; locked_door_data.locked_doors.len()],
         weapon_mask,
     })
 }
@@ -542,7 +567,31 @@ fn test_scenario(
         game_data.vertex_isv.keys.len(),
         game_data.base_links_data.links.len(),
     );
-    let global_state = get_global_state(game_data, &difficulty, scenario)?;
+
+    let mut locked_doors: Vec<LockedDoor> = vec![];
+    for door in scenario.locked_doors.iter() {
+        let door_ptr_pair = get_door_ptr_pair(door.room_id, door.node_id);
+        let door_type = match door.type_ {
+            ScenarioLockedDoorType::Red => DoorType::Red,
+            ScenarioLockedDoorType::Green => DoorType::Green,
+            ScenarioLockedDoorType::Yellow => DoorType::Yellow,
+            ScenarioLockedDoorType::Charge => DoorType::Beam(BeamType::Charge),
+            ScenarioLockedDoorType::Ice => DoorType::Beam(BeamType::Ice),
+            ScenarioLockedDoorType::Spazer => DoorType::Beam(BeamType::Spazer),
+            ScenarioLockedDoorType::Wave => DoorType::Beam(BeamType::Wave),
+            ScenarioLockedDoorType::Plasma => DoorType::Beam(BeamType::Plasma),
+            ScenarioLockedDoorType::Wall => DoorType::Wall,
+        };
+        locked_doors.push(LockedDoor {
+            src_ptr_pair: door_ptr_pair,
+            dst_ptr_pair: (None, None),
+            door_type,
+            bidirectional: false,
+        });
+    }
+    let locked_door_data = make_locked_door_data(locked_doors, game_data);
+
+    let global_state = get_global_state(game_data, &difficulty, scenario, &locked_door_data)?;
     let start_local_state = get_local_state(&scenario.start_state);
     let end_local_state = get_local_state(&scenario.end_state);
     let objectives = vec![
@@ -585,11 +634,6 @@ fn test_scenario(
         .context("End vertex not found")?;
 
     let num_vertices = game_data.vertex_isv.keys.len();
-    let locked_door_data = LockedDoorData {
-        locked_doors: vec![],
-        locked_door_node_map: HashMap::new(),
-        locked_door_vertex_ids: vec![],
-    };
     let inventory = &global_state.inventory;
 
     for (state, name) in [(start_local_state, "start"), (end_local_state, "end")] {
@@ -834,6 +878,11 @@ fn test_scenario(
     Ok(())
 }
 
+fn get_door_ptr_pair(room_id: RoomId, node_id: NodeId) -> DoorPtrPair {
+    let fake_ptr = (room_id << 16) | node_id;
+    (Some(fake_ptr), Some(fake_ptr))
+}
+
 #[test]
 fn test_logic_scenarios() -> Result<()> {
     let base_game_data = GameData::load_minimal(Path::new(".."))?;
@@ -849,6 +898,16 @@ fn test_logic_scenarios() -> Result<()> {
         game_data.load_rooms(&room_pattern)?;
         game_data.make_links_data(&|_, _| (0, 1));
 
+        for &(room_id, node_id) in game_data.node_json_map.keys().clone() {
+            let node_json = &game_data.node_json_map[&(room_id, node_id)];
+            if node_json["nodeType"] == "door" {
+                let ptr_pair = get_door_ptr_pair(room_id, node_id);
+                game_data
+                    .door_ptr_pair_map
+                    .insert(ptr_pair, (room_id, node_id));
+            }
+        }
+
         let connections_path = entry.path().join("connections.json");
         let connections_list: ConnectionsList = if connections_path.exists() || num_rooms > 1 {
             let connections_str = std::fs::read_to_string(connections_path.clone())

rust/maprando/tests/scenarios/electricity-hit/room.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "../../../../../sm-json-data/schema/m3-room.schema.json",
+  "roomEnvironments": [{"heated": false}],
+  "id": 0,
+  "roomAddress": "0x0000",
+  "name": "Test Room",
+  "area": "Test Area",
+  "subarea": "Test Subarea",
+  "mapTileMask": [
+    [1]
+  ],
+  "nodes": [
+    {
+      "id": 1,
+      "name": "Starting Node",
+      "nodeType": "junction",
+      "nodeSubType": "junction",
+      "mapTileMask": [
+        [1]
+      ]
+    },
+    {
+      "id": 2,
+      "name": "Ending Node",
+      "nodeType": "junction",
+      "nodeSubType": "junction",
+      "mapTileMask": [
+        [1]
+      ]
+    }
+  ],
+  "strats": [
+    {
+      "link": [1, 2],
+      "name": "Base",
+      "requires": [
+        {"electricityHits": 2}
+      ],
+      "flashSuitChecked": true
+    }
+  ]
+}

rust/maprando/tests/scenarios/electricity-hit/scenarios.json

@@ -0,0 +1,43 @@
+{
+  "$schema": "../../schema/scenarios.schema.json",
+  "scenarios": [
+    {
+      "name": "Enough Energy",
+      "startRoomId": 0,
+      "startNodeId": 1,
+      "startState": {
+        "energy": {"remaining": 61}
+      },
+      "endRoomId": 0,
+      "endNodeId": 2
+    },
+    {
+      "name": "Not Enough Energy",
+      "globalState": {
+        "maxEnergy": 199
+      },
+      "startRoomId": 0,
+      "startNodeId": 1,
+      "startState": {
+        "energy": {"remaining": 60}
+      },
+      "endRoomId": 0,
+      "endNodeId": 2,
+      "fail": true
+    },
+    {
+      "name": "Reserves",
+      "globalState": {
+        "maxReserves": 100
+      },
+      "startRoomId": 0,
+      "startNodeId": 1,
+      "startState": {
+        "reserves": {"remaining": 60}
+      },
+      "endRoomId": 0,
+      "endNodeId": 2,
+      "reverse": "weak"
+    }
+  ]
+}