a-b-street/abstreet
1
1
Fork 0
mirror of https://github.com/a-b-street/abstreet.git synced 2024-12-25 07:25:47 +03:00
Code Issues Projects Releases Wiki Activity

refactoring wizards and loading/listing stuff

Browse Source
This commit is contained in:
Dustin Carlino 2018-10-08 11:57:23 -07:00
parent f1503c2de1
commit 23fc634eb4
6 changed files with 84 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
abstutil/src/io.rs
View File

@ -103,8 +103,9 @@ pub fn deserialize_multimap<
}
// Just list all things from a directory, return sorted by name, with file extension removed.
pub fn list_all_objects(dir: &str, map_name: &str) -> Vec<String> {
let mut results: BTreeSet<String> = BTreeSet::new();
// Pretty hacky that we return a (String, String).
pub fn list_all_objects(dir: &str, map_name: &str) -> Vec<(String, String)> {
let mut results: BTreeSet<(String, String)> = BTreeSet::new();
match std::fs::read_dir(format!("../data/{}/{}/", dir, map_name)) {
Ok(iter) => {
for entry in iter {
@ -114,7 +115,7 @@ pub fn list_all_objects(dir: &str, map_name: &str) -> Vec<String> {
.to_os_string()
.into_string()
.unwrap();
results.insert(name);
results.insert((name.clone(), name));
}
}
Err(ref e) if e.kind() == ErrorKind::NotFound => {}

34
editor/src/plugins/a_b_tests.rs
View File

@ -1,10 +1,9 @@
use abstutil;
use ezgui::{Canvas, GfxCtx, LogScroller, UserInput, Wizard, WrappedWizard};
use map_model::Map;
use objects::SIM_SETUP;
use piston::input::Key;
use plugins::Colorizer;
use sim::{ABTest, MapEdits, Scenario};
use plugins::{choose_edits, choose_scenario, load_ab_test, Colorizer};
use sim::ABTest;
pub enum ABTestManager {
Inactive,
@ -70,12 +69,7 @@ fn pick_ab_test(map: &Map, mut wizard: WrappedWizard) -> Option<ABTest> {
if wizard.choose_string("What A/B test to manage?", vec![load_existing, create_new])?
== load_existing
{
let map_name = map.get_name().to_string();
wizard
.choose_something::<ABTest>(
"Load which A/B test?",
Box::new(move || abstutil::load_all_objects("ab_tests", &map_name)),
).map(|(_, t)| t)
load_ab_test(map, &mut wizard, "Load which A/B test?")
} else {
let test_name = wizard.input_string("Name the A/B test")?;
let ab_test = ABTest {
@ -89,25 +83,3 @@ fn pick_ab_test(map: &Map, mut wizard: WrappedWizard) -> Option<ABTest> {
Some(ab_test)
}
}
// TODO it'd be neat to instead register parsers and choice generators on a wizard, then call them?
// these file-loading ones are especially boilerplate. maybe even just refactor that in the editor
// crate.
fn choose_scenario(map: &Map, wizard: &mut WrappedWizard, query: &str) -> Option<String> {
let map_name = map.get_name().to_string();
wizard
.choose_something::<Scenario>(
query,
Box::new(move || abstutil::load_all_objects("scenarios", &map_name)),
).map(|(n, _)| n)
}
fn choose_edits(map: &Map, wizard: &mut WrappedWizard, query: &str) -> Option<String> {
let map_name = map.get_name().to_string();
wizard
.choose_something::<MapEdits>(
query,
Box::new(move || abstutil::load_all_objects("edits", &map_name)),
).map(|(n, _)| n)
}

10
editor/src/plugins/draw_neighborhoods.rs
View File

@ -1,10 +1,9 @@
use abstutil;
use ezgui::{Canvas, GfxCtx, Text, UserInput, Wizard, WrappedWizard};
use geom::{Circle, Line, Polygon};
use map_model::Map;
use objects::EDIT_MAP;
use piston::input::Key;
use plugins::Colorizer;
use plugins::{load_neighborhood, Colorizer};
use sim::Neighborhood;
const POINT_RADIUS: f64 = 2.0;
@ -148,12 +147,7 @@ fn pick_neighborhood(map: &Map, mut wizard: WrappedWizard) -> Option<Neighborhoo
vec![load_existing, create_new],
)? == load_existing
{
let map_name = map.get_name().to_string();
wizard
.choose_something::<Neighborhood>(
"Load which neighborhood?",
Box::new(move || abstutil::load_all_objects("neighborhoods", &map_name)),
).map(|(_, n)| n)
load_neighborhood(map, &mut wizard, "Load which neighborhood?")
} else {
let name = wizard.input_string("Name the neighborhood")?;
Some(Neighborhood {

8
editor/src/plugins/map_edits.rs
View File

@ -1,11 +1,10 @@
use abstutil;
use control::ControlMap;
use ezgui::{Canvas, GfxCtx, UserInput, Wizard, WrappedWizard};
use map_model::Map;
use objects::SIM_SETUP;
use piston::input::Key;
use plugins::road_editor::RoadEditor;
use plugins::Colorizer;
use plugins::{choose_edits, Colorizer};
use sim::{MapEdits, SimFlags};
pub struct EditsManager {
@ -123,10 +122,7 @@ fn manage_edits(
Some(())
}
x if x == load => {
let map_name = map.get_name().to_string();
let edits = abstutil::list_all_objects("edits", &map_name);
let edit_refs = edits.iter().map(|s| s.as_str()).collect();
let load_name = wizard.choose_string("Load which map edits?", edit_refs)?;
let load_name = choose_edits(map, &mut wizard, "Load which map edits?")?;
let mut flags = current_flags.clone();
flags.edits_name = load_name;
*new_flags = Some(flags);

71
editor/src/plugins/mod.rs
View File

@ -20,11 +20,80 @@ pub mod traffic_signal_editor;
pub mod turn_cycler;
pub mod warp;
use ezgui::Color;
use abstutil;
use ezgui::{Color, WrappedWizard};
use map_model::Map;
use objects::{Ctx, ID};
use sim::{ABTest, Neighborhood, Scenario, Tick};
pub trait Colorizer {
fn color_for(&self, _obj: ID, _ctx: Ctx) -> Option<Color> {
None
}
}
// TODO Further refactoring should be done, but at least group these here to start.
// General principles are to avoid actually deserializing the objects unless needed.
pub fn choose_neighborhood(map: &Map, wizard: &mut WrappedWizard, query: &str) -> Option<String> {
let map_name = map.get_name().to_string();
// Load the full object, since various plugins visualize the neighborhood when menuing over it
wizard
.choose_something::<Neighborhood>(
query,
Box::new(move || abstutil::load_all_objects("neighborhoods", &map_name)),
).map(|(n, _)| n)
}
pub fn load_neighborhood(
map: &Map,
wizard: &mut WrappedWizard,
query: &str,
) -> Option<Neighborhood> {
let map_name = map.get_name().to_string();
wizard
.choose_something::<Neighborhood>(
query,
Box::new(move || abstutil::load_all_objects("neighborhoods", &map_name)),
).map(|(_, n)| n)
}
pub fn load_scenario(map: &Map, wizard: &mut WrappedWizard, query: &str) -> Option<Scenario> {
let map_name = map.get_name().to_string();
wizard
.choose_something::<Scenario>(
query,
Box::new(move || abstutil::load_all_objects("scenarios", &map_name)),
).map(|(_, s)| s)
}
pub fn choose_scenario(map: &Map, wizard: &mut WrappedWizard, query: &str) -> Option<String> {
let map_name = map.get_name().to_string();
wizard
.choose_something::<String>(
query,
Box::new(move || abstutil::list_all_objects("scenarios", &map_name)),
).map(|(n, _)| n)
}
pub fn choose_edits(map: &Map, wizard: &mut WrappedWizard, query: &str) -> Option<String> {
let map_name = map.get_name().to_string();
wizard
.choose_something::<String>(
query,
Box::new(move || abstutil::list_all_objects("edits", &map_name)),
).map(|(n, _)| n)
}
pub fn load_ab_test(map: &Map, wizard: &mut WrappedWizard, query: &str) -> Option<ABTest> {
let map_name = map.get_name().to_string();
wizard
.choose_something::<ABTest>(
query,
Box::new(move || abstutil::load_all_objects("ab_tests", &map_name)),
).map(|(_, t)| t)
}
pub fn input_tick(wizard: &mut WrappedWizard, query: &str) -> Option<Tick> {
wizard.input_something(query, Box::new(|line| Tick::parse(&line)))
}

27
editor/src/plugins/scenarios.rs
View File

@ -1,11 +1,10 @@
use abstutil;
use ezgui::{Canvas, GfxCtx, LogScroller, UserInput, Wizard, WrappedWizard};
use geom::Polygon;
use map_model::Map;
use objects::SIM_SETUP;
use piston::input::Key;
use plugins::Colorizer;
use sim::{Neighborhood, Scenario, SeedParkedCars, Sim, SpawnOverTime, Tick};
use plugins::{choose_neighborhood, input_tick, load_scenario, Colorizer};
use sim::{Neighborhood, Scenario, SeedParkedCars, Sim, SpawnOverTime};
pub enum ScenarioManager {
Inactive,
@ -99,12 +98,7 @@ fn pick_scenario(map: &Map, mut wizard: WrappedWizard) -> Option<Scenario> {
if wizard.choose_string("What scenario to edit?", vec![load_existing, create_new])?
== load_existing
{
let map_name = map.get_name().to_string();
wizard
.choose_something::<Scenario>(
"Load which scenario?",
Box::new(move || abstutil::load_all_objects("scenarios", &map_name)),
).map(|(_, s)| s)
load_scenario(map, &mut wizard, "Load which scenario?")
} else {
let scenario_name = wizard.input_string("Name the scenario")?;
Some(Scenario {
@ -146,18 +140,3 @@ fn edit_scenario(map: &Map, scenario: &mut Scenario, mut wizard: WrappedWizard)
Some(())
}
}
// TODO it'd be neat to instead register parsers and choice generators on a wizard, then call them?
fn choose_neighborhood(map: &Map, wizard: &mut WrappedWizard, query: &str) -> Option<String> {
let map_name = map.get_name().to_string();
wizard
.choose_something::<Neighborhood>(
query,
Box::new(move || abstutil::load_all_objects("neighborhoods", &map_name)),
).map(|(n, _)| n)
}
fn input_tick(wizard: &mut WrappedWizard, query: &str) -> Option<Tick> {
wizard.input_something(query, Box::new(|line| Tick::parse(&line)))
}