diff --git a/.github/deploy/rtx/dev.json b/.github/deploy/rtx/dev.json new file mode 100644 index 000000000..fd9ce6ef0 --- /dev/null +++ b/.github/deploy/rtx/dev.json @@ -0,0 +1,12 @@ +{ + "args": [ + "--dev", + "--map-server", + "map-gen-2:5000", + "--seed-repository-url", + "s3:map-rando-seeds", + "--video-storage-url", + "https://map-rando-videos.b-cdn.net", + "--test-map-server" + ] +} diff --git a/.github/scripts/create_image_metadata.py b/.github/scripts/create_image_metadata.py new file mode 100644 index 000000000..a07e9d5fe --- /dev/null +++ b/.github/scripts/create_image_metadata.py @@ -0,0 +1,35 @@ +import json +import os +from pathlib import Path + + +def main(): + config_root = Path(".github/deploy") + deploy_configs = { + path.relative_to(config_root).with_suffix("").as_posix(): json.loads(path.read_text()) + for path in sorted(config_root.glob("*/*.json")) + } + if not deploy_configs: + raise ValueError("No deployment configurations found in .github/deploy/*/*.json") + metadata = { + "digest": os.environ["IMAGE_DIGEST"], + "commit": os.environ["GITHUB_SHA"], + "run_id": int(os.environ["GITHUB_RUN_ID"]), + "run_attempt": int(os.environ["GITHUB_RUN_ATTEMPT"]), + "deploy_configs": deploy_configs, + } + Path("image-metadata.json").write_text(json.dumps(metadata, indent=2) + "\n") + repository_url = f"{os.environ['GITHUB_SERVER_URL']}/{os.environ['GITHUB_REPOSITORY']}" + summary = ( + "### Published image\n\n" + f"- Image: `docker.io/bkerby/map-rando@{metadata['digest']}`\n" + f"- Commit: [{metadata['commit']}]({repository_url}/commit/{metadata['commit']})\n" + f"- Build: [run {metadata['run_id']}, attempt {metadata['run_attempt']}]" + f"({repository_url}/actions/runs/{metadata['run_id']}/attempts/{metadata['run_attempt']})\n" + ) + with Path(os.environ["GITHUB_STEP_SUMMARY"]).open("a") as summary_file: + summary_file.write(summary) + + +if __name__ == "__main__": + main() diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 2a5746378..a306c068b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -65,6 +65,9 @@ jobs: env: DOCKER_TAG: ${{ github.ref == 'refs/heads/main' && 'latest' || github.ref_name }} steps: + - + name: Check out deployment configurations + uses: actions/checkout@v4 - name: Set up Docker Buildx uses: docker/setup-buildx-action@v2 @@ -91,21 +94,7 @@ jobs: name: Write image metadata env: IMAGE_DIGEST: ${{ steps.build.outputs.digest }} - run: | - jq -n \ - --arg digest "$IMAGE_DIGEST" \ - --arg commit "$GITHUB_SHA" \ - --argjson run_id "$GITHUB_RUN_ID" \ - --argjson run_attempt "$GITHUB_RUN_ATTEMPT" \ - '{digest: $digest, commit: $commit, run_id: $run_id, run_attempt: $run_attempt}' \ - > image-metadata.json - - printf '### Published image\n\n- Image: `docker.io/bkerby/map-rando@%s`\n- Commit: [%s](%s/%s/commit/%s)\n- Build: [run %s, attempt %s](%s/%s/actions/runs/%s/attempts/%s)\n' \ - "$IMAGE_DIGEST" \ - "$GITHUB_SHA" "$GITHUB_SERVER_URL" "$GITHUB_REPOSITORY" "$GITHUB_SHA" \ - "$GITHUB_RUN_ID" "$GITHUB_RUN_ATTEMPT" \ - "$GITHUB_SERVER_URL" "$GITHUB_REPOSITORY" "$GITHUB_RUN_ID" "$GITHUB_RUN_ATTEMPT" \ - >> "$GITHUB_STEP_SUMMARY" + run: python3 .github/scripts/create_image_metadata.py - name: Upload image metadata uses: actions/upload-artifact@v7 diff --git a/.github/workflows/deploy-dev.yml b/.github/workflows/deploy-dev.yml index 7eb63ce51..f75f33d3a 100644 --- a/.github/workflows/deploy-dev.yml +++ b/.github/workflows/deploy-dev.yml @@ -35,6 +35,10 @@ jobs: const fs = require('node:fs/promises'); const run = context.payload.workflow_run; const metadata = JSON.parse(await fs.readFile('image-metadata/image-metadata.json', 'utf8')); + const deployConfig = metadata.deploy_configs['rtx/dev']; + if (deployConfig === undefined) { + throw new Error('Build metadata is missing .github/deploy/rtx/dev.json'); + } // Rerunning this publisher creates a new request, including to retry a failed rollout. const response = await github.rest.repos.createDeployment({ ...context.repo, @@ -48,6 +52,7 @@ jobs: description: `CI run ${run.id}, attempt ${run.run_attempt}`, payload: { digest: metadata.digest, + deploy_config: deployConfig, build_run_id: run.id, build_run_attempt: run.run_attempt } diff --git a/.github/workflows/deploy-experimental.yml b/.github/workflows/deploy-experimental.yml index 4f75c0781..474075397 100644 --- a/.github/workflows/deploy-experimental.yml +++ b/.github/workflows/deploy-experimental.yml @@ -35,6 +35,10 @@ jobs: const fs = require('node:fs/promises'); const run = context.payload.workflow_run; const metadata = JSON.parse(await fs.readFile('image-metadata/image-metadata.json', 'utf8')); + const deployConfig = metadata.deploy_configs['rtx/experimental']; + if (deployConfig === undefined) { + throw new Error('Build metadata is missing .github/deploy/rtx/experimental.json'); + } // Rerunning this publisher creates a new request, including to retry a failed rollout. const response = await github.rest.repos.createDeployment({ ...context.repo, @@ -48,6 +52,7 @@ jobs: description: `Experimental CI run ${run.id}, attempt ${run.run_attempt}`, payload: { digest: metadata.digest, + deploy_config: deployConfig, build_run_id: run.id, build_run_attempt: run.run_attempt } diff --git a/rust/Cargo.lock b/rust/Cargo.lock index 6d6c75e89..d70853586 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -1787,6 +1787,7 @@ dependencies = [ "parse_int", "pathfinding", "rand 0.8.5", + "reqwest", "serde", "serde-xml-rs", "serde_derive", @@ -2502,6 +2503,7 @@ checksum = "43e734407157c3c2034e0258f5e4473ddb361b1e85f95a66690d67264d7cd1da" dependencies = [ "base64", "bytes", + "futures-channel", "futures-core", "futures-util", "h2 0.4.10", diff --git a/rust/data/presets/full-settings/Community Race Season 5.json b/rust/data/presets/full-settings/Community Race Season 5.json index c17023f44..28d19a6ba 100644 --- a/rust/data/presets/full-settings/Community Race Season 5.json +++ b/rust/data/presets/full-settings/Community Race Season 5.json @@ -4904,7 +4904,7 @@ 0.21052631578947367 ] }, - "reward_missing_connect_utility": 1.0, + "reward_missing_connect_utility": 2.0, "reward_area_x": 10.0, "reward_area_y": 10.0, "target_area_rooms": [ diff --git a/rust/data/presets/full-settings/Default.json b/rust/data/presets/full-settings/Default.json index 8e9ac0d22..991854e2e 100644 --- a/rust/data/presets/full-settings/Default.json +++ b/rust/data/presets/full-settings/Default.json @@ -4820,7 +4820,8 @@ 0.7 ] }, - "reward_missing_connect_utility": 1.0, + "reward_missing_connect_utility": 2.0, + "max_return_distance": 13.0, "reward_area_x": 10.0, "reward_area_y": 10.0, "target_area_rooms": [ diff --git a/rust/data/presets/full-settings/Mentor Tournament.json b/rust/data/presets/full-settings/Mentor Tournament.json index 28c7d4ab1..1615e97b8 100644 --- a/rust/data/presets/full-settings/Mentor Tournament.json +++ b/rust/data/presets/full-settings/Mentor Tournament.json @@ -4904,7 +4904,7 @@ 0.21052631578947367 ] }, - "reward_missing_connect_utility": 1.0, + "reward_missing_connect_utility": 2.0, "reward_area_x": 10.0, "reward_area_y": 10.0, "target_area_rooms": [ diff --git a/rust/data/presets/full-settings/Summer Series Expert Challenge.json b/rust/data/presets/full-settings/Summer Series Expert Challenge.json index e97f98fdb..9d5c5a312 100644 --- a/rust/data/presets/full-settings/Summer Series Expert Challenge.json +++ b/rust/data/presets/full-settings/Summer Series Expert Challenge.json @@ -4816,7 +4816,7 @@ 0.21052631578947367 ] }, - "reward_missing_connect_utility": 1.0, + "reward_missing_connect_utility": 2.0, "reward_area_x": 10.0, "reward_area_y": 10.0, "target_area_rooms": [ diff --git a/rust/maprando-game/src/lib.rs b/rust/maprando-game/src/lib.rs index ae5bb301b..118b9c2d0 100644 --- a/rust/maprando-game/src/lib.rs +++ b/rust/maprando-game/src/lib.rs @@ -3107,7 +3107,7 @@ impl GameData { .notable_map .unwrap() .get(¬able_name) - .context(format!("Undefined notable: {}", ¬able_name))?; + .context(format!("Undefined notable: {}", notable_name))?; return Ok(Requirement::Notable(notable_idx)); } else if key == "heatFramesWithEnergyDrops" { let frames = self.parse_numeric(&value["frames"]).unwrap_or_else(|e| { diff --git a/rust/maprando-web/src/main.rs b/rust/maprando-web/src/main.rs index 3aae6a80c..c42427e21 100644 --- a/rust/maprando-web/src/main.rs +++ b/rust/maprando-web/src/main.rs @@ -18,7 +18,7 @@ use actix_web::{ use askama::Template; use clap::Parser; use hashbrown::HashMap; -use log::{error, info}; +use log::{error, info, warn}; use rand::{RngCore, SeedableRng}; use serde_derive::{Deserialize, Serialize}; use serde_variant::to_variant_name; @@ -71,7 +71,7 @@ struct Args { port: u16, #[arg(long)] map_server: Option, - /// Send a test generation request during startup. + /// Test each full-settings preset's map source and request fresh-map refills during startup. #[arg(long, requires = "map_server")] test_map_server: bool, } @@ -149,12 +149,10 @@ fn build_app_data() -> AppData { let vanilla_map_repository = OfflineMapRepository::new(vec![("Vanilla", vanilla_map_path)]).unwrap(); + let mut vanilla_settings = preset_data.default_preset.clone(); + vanilla_settings.map_settings = MapSettings::from_preset(MapPreset::Vanilla, false); let vanilla_map = vanilla_map_repository - .get_map_batch( - 0, - &MapSettings::from_preset(MapPreset::Vanilla, false), - &game_data, - ) + .get_map_batch(0, &vanilla_settings, &game_data) .unwrap()[0] .clone(); let map_repository: Box = Box::new(SelectableMapRepository { @@ -165,27 +163,32 @@ fn build_app_data() -> AppData { ("Wild", wild_maps_path), ]) .unwrap(), - fresh: args.map_server.as_ref().map(|server| { - let repository = HttpMapRepository::new(server).unwrap(); - if args.test_map_server { - info!("Sending test generation request to map server {server}"); - let start = Instant::now(); - let maps = repository - .get_map_batch( - 0, - &MapSettings::from_preset(MapPreset::Standard, true), - &game_data, - ) - .expect("Map server test request failed"); - info!( - "Map server test request succeeded: {} maps in {:.3}s", - maps.len(), - start.elapsed().as_secs_f32() - ); - } - repository - }), + fresh: args + .map_server + .as_ref() + .map(|server| HttpMapRepository::new(server, &preset_data.skill_presets).unwrap()), }); + if args.test_map_server { + for settings in &preset_data.full_presets { + let name = settings.name.as_deref().unwrap(); + info!( + "Testing map source {:?} for {name}", + settings.map_settings.source + ); + let start = Instant::now(); + let maps = map_repository + .get_map_batch(0, settings, &game_data) + .unwrap_or_else(|e| panic!("Map source test failed for {name}: {e:#}")); + map_repository + .request_refill(settings) + .unwrap_or_else(|e| panic!("Map server refill failed for {name}: {e:#}")); + info!( + "Map source test succeeded for {name}: {} maps in {:.3}s", + maps.len(), + start.elapsed().as_secs_f32() + ); + } + } let logic_data = LogicData::new( &game_data, @@ -547,7 +550,6 @@ struct AttemptOutput { #[derive(Debug)] enum AttemptError { - TooManyAttempts, TimedOut, MapGeneration(anyhow::Error), } @@ -589,31 +591,33 @@ fn handle_randomize_request( app_data.game_data.vertex_isv.keys.len(), 0, ); - let max_attempts = 2000; - let attempts_timeout = Duration::from_secs(25); + let attempts_timeout = Duration::from_secs(60); let max_attempts_per_map = if settings.start_location_settings.mode == StartLocationMode::Random { - 10 + 100 } else { - 1 + 10 }; - let max_map_attempts = max_attempts / max_attempts_per_map; info!( - "Random seed={random_seed}, max_attempts_per_map={max_attempts_per_map}, max_map_attempts={max_map_attempts}, difficulty={:?}", + "Random seed={random_seed}, max_attempts_per_map={max_attempts_per_map}, difficulty={:?}", difficulty_tiers[0] ); let time_start_attempts = Instant::now(); let mut attempt_num = 0; + let mut map_batch_attempt = 0; let mut map_batch: Vec = vec![]; - for _ in 0..max_map_attempts { + loop { let map_seed = (rng.next_u64() & 0xFFFFFFFF) as usize; - let door_randomization_seed = (rng.next_u64() & 0xFFFFFFFF) as usize; if map_batch.is_empty() { + if time_start_attempts.elapsed() > attempts_timeout { + return Err(AttemptError::TimedOut); + } + map_batch_attempt += 1; map_batch = app_data .map_repository - .get_map_batch(map_seed, &settings.map_settings, &app_data.game_data) + .get_map_batch(map_seed, &settings, &app_data.game_data) .map_err(AttemptError::MapGeneration)?; } @@ -623,44 +627,44 @@ fn handle_randomize_request( continue; } let objectives = get_objectives(&settings, Some(&map), &app_data.game_data, &mut rng); - let locked_door_data = randomize_doors( - &app_data.game_data, - &map, - &settings, - &objectives, - door_randomization_seed, - ); - let randomizer = Randomizer::new( - &map, - &locked_door_data, - objectives.clone(), - &settings, - &difficulty_tiers, - &app_data.game_data, - &filtered_base_links_data, - &mut rng, - ); for _ in 0..max_attempts_per_map { + let door_randomization_seed = (rng.next_u64() & 0xFFFFFFFF) as usize; + let locked_door_data = randomize_doors( + &app_data.game_data, + &map, + &settings, + &objectives, + door_randomization_seed, + ); + let randomizer = Randomizer::new( + &map, + &locked_door_data, + objectives.clone(), + &settings, + &difficulty_tiers, + &app_data.game_data, + &filtered_base_links_data, + &mut rng, + ); let item_placement_seed = (rng.next_u64() & 0xFFFFFFFF) as usize; attempt_num += 1; info!( - "Attempt {attempt_num}/{max_attempts}: Map seed={map_seed}, door randomization seed={door_randomization_seed}, item placement seed={item_placement_seed}" + "Attempt {attempt_num}, map batch {map_batch_attempt}: Map seed={map_seed}, door randomization seed={door_randomization_seed}, item placement seed={item_placement_seed}" ); let randomization_result = randomizer.randomize(attempt_num, item_placement_seed, display_seed, true); let (randomization, spoiler_log) = match randomization_result { Ok(x) => x, Err(e) => { - info!("Attempt {attempt_num}/{max_attempts}: Randomization failed: {e}"); - if time_start_attempts.elapsed() > attempts_timeout { - return Err(AttemptError::TimedOut); - } + info!( + "Attempt {attempt_num}, map batch {map_batch_attempt}: Randomization failed: {e}" + ); continue; } }; info!( - "Successful attempt {attempt_num}/{attempt_num}/{max_attempts}: display_seed={}, random_seed={random_seed}, map_seed={map_seed}, door_randomization_seed={door_randomization_seed}, item_placement_seed={item_placement_seed}", + "Successful attempt {attempt_num}, map batch {map_batch_attempt}: display_seed={}, random_seed={random_seed}, map_seed={map_seed}, door_randomization_seed={door_randomization_seed}, item_placement_seed={item_placement_seed}", randomization.display_seed, ); @@ -680,7 +684,6 @@ fn handle_randomize_request( return output_result; } } - Err(AttemptError::TooManyAttempts) } #[post("/randomize")] @@ -750,10 +753,6 @@ async fn randomize( return HttpResponse::InternalServerError() .body("Failed too many randomization attempts (timeout reached)"); } - Err(AttemptError::TooManyAttempts) => { - return HttpResponse::InternalServerError() - .body("Failed too many randomization attempts (maximum attempt count reached)"); - } }; let timestamp = match SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) { @@ -860,6 +859,18 @@ async fn randomize( .await .unwrap(); + let refill_app = app_data.clone(); + let refill_settings = settings.clone(); + match actix_web::rt::task::spawn_blocking(move || { + refill_app.map_repository.request_refill(&refill_settings) + }) + .await + { + Ok(Ok(())) => {} + Ok(Err(e)) => warn!("Map server refill notification failed: {e:#}"), + Err(e) => warn!("Map server refill notification task failed: {e}"), + } + HttpResponse::Ok().json(RandomizeResponse { seed_url: format!("/seed/{seed_name}/"), seed_hash: get_seed_hash(output.randomization.display_seed), @@ -967,7 +978,11 @@ async fn main() { env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")) .format_timestamp_millis() .init(); - let app_data = actix_web::web::Data::new(build_app_data()); + let app_data = actix_web::web::Data::new( + actix_web::rt::task::spawn_blocking(build_app_data) + .await + .unwrap(), + ); let port = app_data.port; diff --git a/rust/maprando-web/templates/generate/map_settings.html b/rust/maprando-web/templates/generate/map_settings.html index 96edcaac1..5a6ed5f88 100644 --- a/rust/maprando-web/templates/generate/map_settings.html +++ b/rust/maprando-web/templates/generate/map_settings.html @@ -499,6 +499,14 @@

Return paths

+
+
+ +
+
+ +
+
Missing-connection utility reward diff --git a/rust/maprando-web/templates/generate/map_settings_scripts.html b/rust/maprando-web/templates/generate/map_settings_scripts.html index 5231413e0..096353441 100644 --- a/rust/maprando-web/templates/generate/map_settings_scripts.html +++ b/rust/maprando-web/templates/generate/map_settings_scripts.html @@ -75,6 +75,7 @@ break; case 'loops': g.reward_missing_connect_utility = mapPresets[value === 'Short' ? 'Standard' : 'Wild'].generation.reward_missing_connect_utility; + g.max_return_distance = mapPresets[value === 'Short' ? 'Standard' : 'Wild'].generation.max_return_distance; break; case 'sizes': g.target_area_rooms = value === 'Familiar' ? [...mapPresets.Standard.generation.target_area_rooms] : Array(6).fill(1); @@ -155,8 +156,10 @@ && g.reward_area_y === mapPresets.Standard.generation.reward_area_y && same(g.target_area_x, mapPresets.Standard.generation.target_area_x) && same(g.target_area_y, mapPresets.Standard.generation.target_area_y) ? 'Preferred' : null); - select('loops', g.reward_missing_connect_utility === mapPresets.Wild.generation.reward_missing_connect_utility ? 'Unrestricted' - : g.reward_missing_connect_utility === mapPresets.Standard.generation.reward_missing_connect_utility ? 'Short' : null); + select('loops', g.reward_missing_connect_utility === mapPresets.Wild.generation.reward_missing_connect_utility + && g.max_return_distance == null ? 'Unrestricted' + : g.reward_missing_connect_utility === mapPresets.Standard.generation.reward_missing_connect_utility + && g.max_return_distance === mapPresets.Standard.generation.max_return_distance ? 'Short' : null); select('sizes', g.target_area_rooms.every(x => x > 0 && x === g.target_area_rooms[0]) ? 'Unbiased' : same(g.target_area_rooms, mapPresets.Standard.generation.target_area_rooms) ? 'Familiar' : null); for (const input of document.querySelectorAll('[data-map-number]')) { diff --git a/rust/maprando/Cargo.toml b/rust/maprando/Cargo.toml index 0390e3735..e09d21afa 100644 --- a/rust/maprando/Cargo.toml +++ b/rust/maprando/Cargo.toml @@ -29,6 +29,7 @@ pathfinding = "4.2.1" env_logger = "0.10.0" log = "0.4.17" object_store = { version = "0.10.2", features=["aws", "gcp"] } +reqwest = { version = "0.12", default-features = false, features = ["blocking", "json"] } futures = "0.3.25" zstd = "0.12.2" crypto-hash = "0.3.4" diff --git a/rust/maprando/src/bin/extract-initial-item-graph.rs b/rust/maprando/src/bin/extract-initial-item-graph.rs new file mode 100644 index 000000000..169f50b73 --- /dev/null +++ b/rust/maprando/src/bin/extract-initial-item-graph.rs @@ -0,0 +1,297 @@ +use std::{ + collections::BTreeSet, + fs::File, + io::{BufWriter, Write}, + path::Path, + process::Command, +}; + +use anyhow::{Context, Result, ensure}; +use clap::Parser; +use hashbrown::HashMap; +use maprando::{ + preset::PresetData, + randomize::DifficultyConfig, + settings::WallJump, + traverse::{LockedDoorData, Traverser, apply_requirement, simple_cost_config}, +}; +use maprando_game::{ + ExitCondition, GameData, LinksDataGroup, MainEntranceCondition, NodeId, Requirement, RoomId, + VertexId, VertexKey, +}; +use maprando_logic::{GlobalState, Inventory, LocalState}; +use serde::Serialize; + +#[derive(Parser)] +#[command(about = "Extract approximate room-local, empty-inventory reachability graphs")] +struct Args { + #[arg(long)] + output: std::path::PathBuf, +} + +#[derive(Serialize)] +struct Node { + room_id: RoomId, + node_id: NodeId, + name: String, + door: bool, + item: bool, + start: bool, +} + +struct Endpoint { + node: Node, + sources: Vec<(VertexId, Requirement)>, + targets: Vec<(VertexId, Requirement)>, +} + +#[derive(Serialize)] +struct Graph { + difficulty: String, + wall_jump: bool, + edges: BTreeSet<(usize, usize)>, +} + +#[derive(Serialize)] +struct Source { + revision: String, + tracked_changes: bool, +} + +fn source(path: &Path) -> Result { + let revision = Command::new("git") + .args(["rev-parse", "HEAD"]) + .current_dir(path) + .output()?; + ensure!( + revision.status.success(), + "Cannot read revision at {path:?}" + ); + let status = Command::new("git") + .args(["status", "--porcelain", "--untracked-files=no"]) + .current_dir(path) + .output()?; + ensure!(status.status.success(), "Cannot read status at {path:?}"); + Ok(Source { + revision: String::from_utf8(revision.stdout)?.trim().to_string(), + tracked_changes: !status.stdout.is_empty(), + }) +} + +fn endpoints(game: &GameData) -> Vec { + let mut doors: BTreeSet<_> = game.node_entrance_conditions.keys().copied().collect(); + doors.extend(game.node_exit_conditions.keys().copied()); + let items: HashMap<_, _> = game + .item_locations + .iter() + .copied() + .zip(&game.item_vertex_ids) + .collect(); + let mut nodes = doors.clone(); + nodes.extend(items.keys().copied()); + nodes.extend(game.start_location_id_map.keys().copied()); + nodes.insert((8, 5)); // Ship start + let mut out = Vec::new(); + for (room_id, node_id) in nodes { + let mut sources: Vec<_> = game + .node_entrance_conditions + .get(&(room_id, node_id)) + .into_iter() + .flatten() + .filter(|(_, entrance)| { + matches!(entrance.main, MainEntranceCondition::ComeInNormally {}) + }) + .map(|(vertex, _)| (*vertex, Requirement::Free)) + .collect(); + let mut targets: Vec<_> = game + .node_exit_conditions + .get(&(room_id, node_id)) + .into_iter() + .flatten() + .filter(|exit| matches!(exit.exit_condition, ExitCondition::LeaveNormally {})) + .map(|exit| (exit.vertex_id, exit.exit_req.clone())) + .collect(); + if let Some(vertices) = items.get(&(room_id, node_id)) { + sources.extend(vertices.iter().map(|&vertex| (vertex, Requirement::Free))); + targets.extend(vertices.iter().map(|&vertex| (vertex, Requirement::Free))); + } + let start_requirement = if (room_id, node_id) == (8, 5) { + Some(Requirement::Free) + } else { + game.start_location_id_map + .get(&(room_id, node_id)) + .map(|&idx| game.start_locations[idx].requires_parsed.clone().unwrap()) + }; + let start = start_requirement.is_some(); + if let Some(requirement) = start_requirement { + let vertex = game.vertex_isv.index_by_key[&VertexKey { + room_id, + node_id, + obstacle_mask: 0, + actions: vec![], + }]; + sources.push((vertex, requirement)); + targets.push((vertex, Requirement::Free)); + } + out.push(Endpoint { + node: Node { + room_id, + node_id, + name: game.node_json_map[&(room_id, node_id)]["name"] + .as_str() + .unwrap() + .to_string(), + door: doors.contains(&(room_id, node_id)), + item: items.contains_key(&(room_id, node_id)), + start, + }, + sources, + targets, + }); + } + out +} + +fn extract( + game: &GameData, + preset: &PresetData, + difficulty: &DifficultyConfig, + endpoints: &[Endpoint], + wall_jump: bool, +) -> Graph { + let mut settings = preset.default_preset.clone(); + settings.other_settings.wall_jump = if wall_jump { + WallJump::Vanilla + } else { + WallJump::Collectible + }; + let inventory = Inventory { + items: vec![false; game.item_isv.keys.len()], + max_energy: 99, + max_reserves: 0, + max_missiles: 0, + max_supers: 0, + max_power_bombs: 0, + collectible_missile_packs: 0, + collectible_super_packs: 0, + collectible_power_bomb_packs: 0, + collectible_reserve_tanks: 0, + }; + let global = GlobalState { + weapon_mask: game.get_weapon_mask(&inventory.items, &difficulty.tech), + pool_inventory: inventory.clone(), + inventory, + flags: vec![false; game.flag_isv.keys.len()], + doors_unlocked: vec![], + }; + let door_map = HashMap::new(); + let locked_doors = LockedDoorData { + locked_doors: vec![], + locked_door_node_map: HashMap::new(), + locked_door_vertex_ids: vec![], + }; + let cost = simple_cost_config(); + let num_vertices = game.vertex_isv.keys.len(); + let empty_links = LinksDataGroup::new(vec![], num_vertices, game.links.len()); + let mut traverser = Traverser::new(num_vertices, false, LocalState::full(false), &global); + let mut edges = BTreeSet::new(); + for (from, endpoint) in endpoints.iter().enumerate() { + for (vertex, requirement) in &endpoint.sources { + if let Some(initial_local) = apply_requirement( + requirement, + &global, + LocalState::full(false), + false, + &settings, + difficulty, + game, + &door_map, + &locked_doors, + &[], + &cost, + ) { + traverser.add_origin(initial_local, &global.inventory, *vertex); + } + } + traverser.traverse( + &game.base_links_data, + &empty_links, + &global, + &settings, + difficulty, + game, + &door_map, + &locked_doors, + &[], + 0, + ); + for (to, target) in endpoints.iter().enumerate() { + if from == to || target.node.room_id != endpoint.node.room_id { + continue; + } + if target.targets.iter().any(|(vertex, requirement)| { + traverser.lsr[*vertex].local.iter().any(|&local| { + apply_requirement( + requirement, + &global, + local, + false, + &settings, + difficulty, + game, + &door_map, + &locked_doors, + &[], + &cost, + ) + .is_some() + }) + }) { + edges.insert((from, to)); + } + } + traverser.pop_step(); + } + Graph { + difficulty: difficulty.name.clone(), + wall_jump, + edges, + } +} + +fn main() -> Result<()> { + let args = Args::parse(); + let mut game = GameData::load(Path::new("."))?; + game.make_links_data(&|_, _| (0, 1)); + let preset = PresetData::load( + Path::new("data/tech_data.json"), + Path::new("data/notable_data.json"), + Path::new("data/presets"), + &game, + )?; + let endpoints = endpoints(&game); + let mut graphs = Vec::new(); + for difficulty in preset.difficulty_tiers.iter().rev() { + for wall_jump in [false, true] { + graphs.push(extract(&game, &preset, difficulty, &endpoints, wall_jump)); + } + } + let nodes: Vec<_> = endpoints.iter().map(|e| &e.node).collect(); + let rooms: std::collections::BTreeMap<_, _> = game + .room_json_map + .iter() + .map(|(&id, room)| (id, room["name"].as_str().unwrap())) + .collect(); + let output = serde_json::json!({ + "format": "initial-item-graph-v1", + "sources": { "map_randomizer": source(Path::new("."))?, "sm_json_data": source(Path::new("../sm-json-data"))? }, + "rooms": rooms, "nodes": nodes, "graphs": graphs + }); + let mut writer = BufWriter::new( + File::create(&args.output) + .with_context(|| format!("Creating {}", args.output.display()))?, + ); + serde_json::to_writer(&mut writer, &output)?; + writer.flush()?; + Ok(()) +} diff --git a/rust/maprando/src/bin/maprando-test.rs b/rust/maprando/src/bin/maprando-test.rs index 5b5c5eb8c..9e214dee1 100644 --- a/rust/maprando/src/bin/maprando-test.rs +++ b/rust/maprando/src/bin/maprando-test.rs @@ -164,7 +164,7 @@ fn get_randomization( if map_batch.is_empty() { map_batch = app .map_repo - .get_map_batch(map_seed, &settings.map_settings, game_data) + .get_map_batch(map_seed, &settings, game_data) .unwrap(); } diff --git a/rust/maprando/src/map_repository.rs b/rust/maprando/src/map_repository.rs index 7d220282d..839e43e97 100644 --- a/rust/maprando/src/map_repository.rs +++ b/rust/maprando/src/map_repository.rs @@ -5,23 +5,25 @@ use rand::{SeedableRng, rngs::StdRng, seq::SliceRandom}; use serde::{Deserialize, Serialize}; use std::{ fs::File, - io::{BufReader, Read, Write}, - net::TcpStream, + io::BufReader, path::{Path, PathBuf}, time::Duration, }; use crate::map_settings::{Landmark, MapSettings, MapSource}; use crate::randomize::Randomizer; +use crate::settings::{RandomizerSettings, SkillAssumptionSettings, StartLocationMode, WallJump}; use maprando_game::{GameData, Map, NodeId, RoomId}; pub trait MapRepository: Send + Sync { fn get_map_batch( &self, seed: usize, - settings: &MapSettings, + settings: &RandomizerSettings, game_data: &GameData, ) -> Result>; + + fn request_refill(&self, settings: &RandomizerSettings) -> Result<()>; } pub struct SelectableMapRepository { @@ -33,10 +35,10 @@ impl MapRepository for SelectableMapRepository { fn get_map_batch( &self, seed: usize, - settings: &MapSettings, + settings: &RandomizerSettings, game_data: &GameData, ) -> Result> { - if settings.source == MapSource::Fresh { + if settings.map_settings.source == MapSource::Fresh { self.fresh .as_ref() .context("Fresh map generation is not configured")? @@ -45,6 +47,16 @@ impl MapRepository for SelectableMapRepository { self.offline.get_map_batch(seed, settings, game_data) } } + + fn request_refill(&self, settings: &RandomizerSettings) -> Result<()> { + if settings.map_settings.source == MapSource::Fresh { + self.fresh + .as_ref() + .context("Fresh map generation is not configured")? + .request_refill(settings)?; + } + Ok(()) + } } pub struct OfflineMapRepository { @@ -109,13 +121,17 @@ impl OfflineMapRepository { } impl MapRepository for OfflineMapRepository { + fn request_refill(&self, _settings: &RandomizerSettings) -> Result<()> { + Ok(()) + } + fn get_map_batch( &self, seed: usize, - settings: &MapSettings, + settings: &RandomizerSettings, game_data: &GameData, ) -> Result> { - let pool_name = Self::pool_name(settings)?; + let pool_name = Self::pool_name(&settings.map_settings)?; let pool = self .pools .get(pool_name) @@ -168,13 +184,14 @@ impl OfflineMapPool { } pub struct HttpMapRepository { - host: String, - port: u16, - path: String, + base_url: String, + client: reqwest::blocking::Client, + difficulty_bins: Vec<(String, f32)>, } #[derive(Serialize)] struct GenerateRequest { + num_maps: usize, episode_length: usize, recommended_candidates: usize, shortlist_candidates: usize, @@ -190,6 +207,10 @@ struct GenerateRequest { reward_phantoon_pair: f64, reward_phantoon_area: f64, reward_success: f64, + reward_initial_item: f64, + initial_item_start: Option<(RoomId, NodeId)>, + initial_item_difficulty: String, + initial_item_wall_jump: bool, reward_ship_in_crateria: f64, reward_kraid_in_brinstar: f64, reward_ridley_in_norfair: f64, @@ -256,7 +277,7 @@ struct GenerateResponseEdges { } impl HttpMapRepository { - pub fn new(server: &str) -> Result { + pub fn new(server: &str, skill_presets: &[SkillAssumptionSettings]) -> Result { let server = server .strip_prefix("http://") .unwrap_or(server) @@ -265,19 +286,72 @@ impl HttpMapRepository { bail!("Map generation server must use HTTP, not HTTPS"); } let (host, port) = if let Some((host, port)) = server.rsplit_once(':') { - (host.to_string(), port.parse()?) + (host, port.parse::()?) } else { bail!("Map generation server must be in host:port format"); }; + let mut difficulty_bins: Vec<_> = skill_presets + .iter() + .filter(|preset| preset.preset.as_deref() != Some("Implicit")) + .map(|preset| { + ( + preset.preset.clone().unwrap(), + preset.escape_timer_multiplier, + ) + }) + .collect(); + difficulty_bins.sort_by(|a, b| b.1.total_cmp(&a.1)); Ok(Self { - host, - port, - path: "/generate".to_string(), + base_url: format!("http://{host}:{port}"), + client: reqwest::blocking::Client::builder() + .timeout(Duration::from_secs(300)) + .no_proxy() + .redirect(reqwest::redirect::Policy::none()) + .build() + .context("Failed to create map generation HTTP client")?, + difficulty_bins, }) } - fn generate_request(settings: &MapSettings) -> GenerateRequest { - let g = &settings.generation; + fn initial_item_difficulty(&self, skill: &SkillAssumptionSettings) -> Result { + if let Some(name) = &skill.preset { + if !self + .difficulty_bins + .iter() + .any(|(preset, _)| preset == name) + { + bail!("Unsupported initial-item difficulty preset: {name}"); + } + return Ok(name.clone()); + } + // Midpoints belong to the larger multiplier (the more conservative tier). + let preset = self + .difficulty_bins + .windows(2) + .find(|pair| skill.escape_timer_multiplier >= (pair[0].1 + pair[1].1) / 2.0); + Ok(preset.map_or_else( + || self.difficulty_bins.last().unwrap().0.clone(), + |pair| pair[0].0.clone(), + )) + } + + fn generate_request(&self, settings: &RandomizerSettings) -> Result { + let g = &settings.map_settings.generation; + let initial_item_start = match settings.start_location_settings.mode { + StartLocationMode::Ship => Some((8, 5)), + StartLocationMode::Custom => Some(( + settings + .start_location_settings + .room_id + .context("expected start room_id")?, + settings + .start_location_settings + .node_id + .context("expected start node_id")?, + )), + StartLocationMode::Random | StartLocationMode::Escape => None, + }; + let initial_item_wall_jump = settings.other_settings.wall_jump == WallJump::Vanilla; let water = g.maridia_water.effective_probabilities(g.area_share(4)); let heat = g.norfair_heat.effective_probabilities(g.area_share(2)); let ship = g.landmarks.contains(&Landmark::Ship); @@ -286,7 +360,8 @@ impl HttpMapRepository { let phantoon = g.landmarks.contains(&Landmark::Phantoon); let draygon = g.landmarks.contains(&Landmark::Draygon); let mother_brain = g.landmarks.contains(&Landmark::MotherBrain); - GenerateRequest { + Ok(GenerateRequest { + num_maps: 1, episode_length: 253, recommended_candidates: 8, shortlist_candidates: 1024, @@ -302,6 +377,15 @@ impl HttpMapRepository { reward_phantoon_pair: 1.0, reward_phantoon_area: 1.0, reward_success: 0.0, + reward_initial_item: if initial_item_start.is_some() { + 1.0 + } else { + 0.0 + }, + initial_item_start, + initial_item_difficulty: self + .initial_item_difficulty(&settings.skill_assumption_settings)?, + initial_item_wall_jump, reward_ship_in_crateria: if ship { 1.0 } else { 0.0 }, reward_kraid_in_brinstar: if kraid { 1.0 } else { 0.0 }, reward_ridley_in_norfair: if ridley { 1.0 } else { 0.0 }, @@ -325,7 +409,7 @@ impl HttpMapRepository { reward_save_distance: g.reward_save_distance, reward_refill_distance: g.reward_refill_distance, reward_missing_connect_utility: g.reward_missing_connect_utility, - max_return_distance: None, + max_return_distance: g.max_return_distance, reward_area_distinct_crossing: g.reward_area_distinct_crossing, reward_area_crossing: 0.0, reward_area_size_valid: 1.0, @@ -339,7 +423,7 @@ impl HttpMapRepository { min_rooms: g.small_map.then_some(120), max_rooms: g.small_map.then_some(180), target_rooms: g.small_map.then_some(150), - } + }) } fn response_to_maps(response: GenerateResponse, game_data: &GameData) -> Result> { @@ -354,42 +438,32 @@ impl HttpMapRepository { Ok(maps) } - fn request_generate(&self, settings: &MapSettings) -> Result { - let body = serde_json::to_vec(&Self::generate_request(settings))?; - let mut stream = - TcpStream::connect((self.host.as_str(), self.port)).with_context(|| { - format!( - "Failed to connect to map generation server {}:{}", - self.host, self.port - ) - })?; - stream.set_read_timeout(Some(Duration::from_secs(300)))?; - stream.set_write_timeout(Some(Duration::from_secs(30)))?; - - write!( - stream, - "POST {} HTTP/1.1\r\n\ - Host: {}:{}\r\n\ - Content-Type: application/json\r\n\ - Content-Length: {}\r\n\ - Connection: close\r\n\ - \r\n", - self.path, - self.host, - self.port, - body.len() - )?; - stream.write_all(&body)?; - stream.flush()?; - - let mut response_bytes = Vec::new(); - stream.read_to_end(&mut response_bytes)?; - parse_generate_response(&response_bytes).with_context(|| { - format!( - "Failed to parse response from map generation server {}:{}", - self.host, self.port - ) - }) + fn request_generate(&self, settings: &RandomizerSettings) -> Result { + serde_json::from_value(self.post("/generate", settings)?) + .context("Failed to parse map generation response JSON") + } + + fn post(&self, path: &str, settings: &RandomizerSettings) -> Result { + let url = format!("{}{path}", self.base_url); + let response = self + .client + .post(&url) + .json(&self.generate_request(settings)?) + .send() + .with_context(|| format!("Map generation request failed: {url}"))?; + let status = response.status(); + if !status.is_success() { + let body = response + .text() + .context("Failed to read map generation error response")?; + bail!( + "Map generation server returned HTTP status {}: {body}", + status.as_u16() + ); + } + response + .json() + .with_context(|| format!("Failed to parse response from map generation server {url}")) } } @@ -397,10 +471,10 @@ impl MapRepository for HttpMapRepository { fn get_map_batch( &self, _seed: usize, - settings: &MapSettings, + settings: &RandomizerSettings, game_data: &GameData, ) -> Result> { - settings.generation.validate()?; + settings.map_settings.generation.validate()?; // TODO: if it is feasible to make fresh map generation reproducible, // plumb the `_seed` through to the request. It is ignored for now. let response = self.request_generate(settings)?; @@ -410,6 +484,11 @@ impl MapRepository for HttpMapRepository { } Ok(maps) } + + fn request_refill(&self, settings: &RandomizerSettings) -> Result<()> { + self.post("/refill", settings)?; + Ok(()) + } } fn stored_map_to_map(stored_map: StoredMap, game_data: &GameData) -> Result { @@ -747,29 +826,3 @@ fn validate_response_lengths(response: &GenerateResponse, map_count: usize) -> R } Ok(()) } - -fn parse_generate_response(response_bytes: &[u8]) -> Result { - let header_end = response_bytes - .windows(4) - .position(|window| window == b"\r\n\r\n") - .with_context(|| "HTTP response missing header terminator")?; - let header_bytes = &response_bytes[..header_end]; - let body_bytes = &response_bytes[header_end + 4..]; - let header_text = std::str::from_utf8(header_bytes)?; - let mut header_lines = header_text.lines(); - let status_line = header_lines - .next() - .with_context(|| "HTTP response missing status line")?; - let status = status_line - .split_whitespace() - .nth(1) - .with_context(|| format!("Malformed HTTP status line: {status_line}"))? - .parse::()?; - if !(200..300).contains(&status) { - bail!( - "Map generation server returned HTTP status {status}: {}", - String::from_utf8_lossy(body_bytes) - ); - } - serde_json::from_slice(body_bytes).context("Failed to parse map generation response JSON") -} diff --git a/rust/maprando/src/map_settings.rs b/rust/maprando/src/map_settings.rs index 772d2161d..9d4a29c01 100644 --- a/rust/maprando/src/map_settings.rs +++ b/rust/maprando/src/map_settings.rs @@ -51,6 +51,7 @@ pub struct MapGenerationSettings { pub maridia_water: AreaPreference, pub norfair_heat: AreaPreference, pub reward_missing_connect_utility: f64, + pub max_return_distance: Option, pub reward_area_x: f64, pub reward_area_y: f64, pub target_area_rooms: [f64; 6], @@ -99,6 +100,11 @@ impl MapGenerationSettings { if !self.reward_area_distinct_crossing.is_finite() { bail!("Distinct area crossings reward must be finite"); } + if let Some(distance) = self.max_return_distance + && (!distance.is_finite() || distance < 0.0) + { + bail!("Max return distance must be finite and nonnegative"); + } for (name, preference, area) in [ ("Water in Maridia", self.maridia_water, 4), ("Heat in Norfair", self.norfair_heat, 2), @@ -170,7 +176,15 @@ impl MapSettings { }, maridia_water: climate, norfair_heat: climate, - reward_missing_connect_utility: if preset == MapPreset::Wild { 0.0 } else { 1.0 }, + reward_missing_connect_utility: if preset == MapPreset::Wild { 0.0 } else { 2.0 }, + max_return_distance: if matches!( + preset, + MapPreset::Small | MapPreset::Familiar | MapPreset::Standard + ) { + Some(13.0) + } else { + None + }, reward_area_x: if preferred { 10.0 } else { 0.0 }, reward_area_y: if preferred { 10.0 } else { 0.0 }, target_area_rooms: if preset == MapPreset::Wild { diff --git a/rust/maprando/src/patch/decompress.rs b/rust/maprando/src/patch/decompress.rs index 367da6452..cd52d77b2 100644 --- a/rust/maprando/src/patch/decompress.rs +++ b/rust/maprando/src/patch/decompress.rs @@ -43,11 +43,10 @@ pub fn decompress(rom: &Rom, mut addr: usize) -> Result> { } 3 => { // Incrementing sequence - let mut b = rom.read_u8(addr)? as u8; + let b = rom.read_u8(addr)? as u8; addr += 1; - for _ in 0..size { + for b in (b..).take(size) { out.push(b); - b += 1; } } 4 => { diff --git a/rust/maprando/src/patch/map_tiles.rs b/rust/maprando/src/patch/map_tiles.rs index 4ecb37c8a..4305be9c4 100644 --- a/rust/maprando/src/patch/map_tiles.rs +++ b/rust/maprando/src/patch/map_tiles.rs @@ -2434,7 +2434,7 @@ impl<'a> MapPatcher<'a> { .rom .read_u16(snes2pc(0xB6F000) + 2 * (0x20 + i as usize))?; self.rom - .write_u16(snes2pc(0xB6F000) + 2 * (0x40 + i as usize), color as isize)?; + .write_u16(snes2pc(0xB6F000) + 2 * (0x40 + i as usize), color)?; } // Substitute palette 2 with palette 4 in pause tilemaps: