game/edit/
crosswalks.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
use geom::Distance;
use map_model::{IntersectionID, TurnID, TurnType};
use widgetry::mapspace::{ObjectID, World, WorldOutcome};
use widgetry::{
    Color, EventCtx, GfxCtx, HorizontalAlignment, Key, Line, Outcome, Panel, State, TextExt,
    VerticalAlignment, Widget,
};

use crate::app::App;
use crate::app::Transition;
use crate::edit::apply_map_edits;

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
struct ID(TurnID);

impl ObjectID for ID {}

pub struct CrosswalkEditor {
    id: IntersectionID,
    world: World<ID>,
    panel: Panel,
}

impl CrosswalkEditor {
    pub fn new_state(ctx: &mut EventCtx, app: &mut App, id: IntersectionID) -> Box<dyn State<App>> {
        app.primary.current_selection = None;

        let map = &app.primary.map;
        let mut world = World::new();
        for turn in &map.get_i(id).turns {
            if turn.turn_type.pedestrian_crossing() {
                let width = Distance::meters(3.0);
                let hitbox = if let Some(line) = turn.crosswalk_line() {
                    line.make_polygons(width)
                } else {
                    turn.geom.make_polygons(width)
                };
                world
                    .add(ID(turn.id))
                    .hitbox(hitbox)
                    .draw_color(Color::RED.alpha(0.5))
                    .hover_alpha(0.3)
                    .clickable()
                    .build(ctx);
            }
        }

        Box::new(Self {
            id,
            world,
            panel: Panel::new_builder(Widget::col(vec![
            Line("Crosswalks editor").small_heading().into_widget(ctx),
            "Click a crosswalk to toggle it between marked and unmarked".text_widget(ctx),
            Line("Pedestrians can cross using both, but have priority over vehicles at marked zebra crossings").secondary().into_widget(ctx),
            ctx.style()
                .btn_solid_primary
                .text("Finish")
                .hotkey(Key::Escape)
                .build_def(ctx),
        ]))
        .aligned(HorizontalAlignment::Center, VerticalAlignment::Top)
        .build(ctx),
        })
    }
}

impl State<App> for CrosswalkEditor {
    fn event(&mut self, ctx: &mut EventCtx, app: &mut App) -> Transition {
        if let WorldOutcome::ClickedObject(ID(turn)) = self.world.event(ctx) {
            let mut edits = app.primary.map.get_edits().clone();
            edits
                .commands
                .push(app.primary.map.edit_intersection_cmd(self.id, |new| {
                    new.crosswalks.insert(
                        turn,
                        if new.crosswalks[&turn] == TurnType::Crosswalk {
                            TurnType::UnmarkedCrossing
                        } else {
                            TurnType::Crosswalk
                        },
                    );
                }));
            apply_map_edits(ctx, app, edits);
            return Transition::Replace(Self::new_state(ctx, app, self.id));
        }

        if let Outcome::Clicked(ref x) = self.panel.event(ctx) {
            match x.as_ref() {
                "Finish" => {
                    return Transition::Pop;
                }
                _ => unreachable!(),
            }
        }

        Transition::Keep
    }

    fn draw(&self, g: &mut GfxCtx, _: &App) {
        self.panel.draw(g);
        self.world.draw(g);
    }
}