src/zones.rs 12 K · 361 lines · raw · history

1 use std::collections::HashSet;
2
3 use bevy::prelude::*;
4
5 use crate::{
6 actions::Action,
7 pathfinding::nearest_tile,
8 selection::{Cursor, update_cursor},
9 ui::PointerOverUi,
10 world::{TILE_SIZE, WorldMap},
11 worldgen::WorldGenerated,
12 };
13
14 pub struct ZonesPlugin;
15
16 impl Plugin for ZonesPlugin {
17 fn build(&self, app: &mut App) {
18 app.init_resource::<Zones>()
19 .init_resource::<ZoneTool>()
20 .add_systems(Update, clear_zones.run_if(on_message::<WorldGenerated>))
21 .add_systems(
22 PostUpdate,
23 (zone_tool, draw_zone_preview).chain().after(update_cursor),
24 );
25 }
26 }
27
28 pub const NEW_STOCKPILE_SIZE: u32 = 4;
29 const STOCKPILE_SITE_SEARCH_TILES: usize = 4000;
30 const PREVIEW_ADD_COLOR: Color = Color::srgba(0.4, 0.7, 1.0, 0.9);
31 const PREVIEW_REMOVE_COLOR: Color = Color::srgba(1.0, 0.4, 0.4, 0.9);
32
33 #[derive(Resource, Default, Debug, Clone, PartialEq)]
34 pub struct Zones {
35 stockpile: HashSet<UVec2>,
36 }
37
38 impl Zones {
39 pub fn is_stockpile(&self, tile: UVec2) -> bool {
40 self.stockpile.contains(&tile)
41 }
42
43 #[cfg(test)]
44 pub fn stockpile_tiles(&self) -> impl Iterator<Item = UVec2> + '_ {
45 self.stockpile.iter().copied()
46 }
47
48 pub fn has_stockpile(&self) -> bool {
49 !self.stockpile.is_empty()
50 }
51
52 pub fn empty_stockpile_tiles(&self, occupied: &HashSet<UVec2>) -> usize {
53 self.stockpile.difference(occupied).count()
54 }
55
56 pub fn add_stockpile(&mut self, map: &WorldMap, a: IVec2, b: IVec2) {
57 self.add_tiles(map, rect_tiles(a, b).filter_map(|t| t.try_into().ok()));
58 }
59
60 pub fn add_tiles(&mut self, map: &WorldMap, tiles: impl IntoIterator<Item = UVec2>) {
61 for tile in tiles {
62 if can_zone(map, tile.as_ivec2()) {
63 self.stockpile.insert(tile);
64 }
65 }
66 }
67
68 pub fn remove_stockpile(&mut self, a: IVec2, b: IVec2) {
69 for tile in rect_tiles(a, b) {
70 if tile.x >= 0 && tile.y >= 0 {
71 self.stockpile.remove(&tile.as_uvec2());
72 }
73 }
74 }
75 }
76
77 pub fn plan_expansion(map: &WorldMap, zones: &Zones, count: usize) -> Vec<UVec2> {
78 if zones.stockpile.is_empty() {
79 return Vec::new();
80 }
81 let centroid =
82 zones.stockpile.iter().map(|t| t.as_vec2()).sum::<Vec2>() / zones.stockpile.len() as f32;
83 let preference = |t: UVec2| {
84 (
85 map.plant(t.as_ivec2()).is_some(),
86 t.as_vec2().distance_squared(centroid),
87 t.y,
88 t.x,
89 )
90 };
91 let mut planned: Vec<UVec2> = Vec::new();
92 while planned.len() < count {
93 let taken = |t: UVec2| zones.is_stockpile(t) || planned.contains(&t);
94 let best = zones
95 .stockpile
96 .iter()
97 .chain(planned.iter())
98 .flat_map(|t| {
99 [IVec2::X, IVec2::NEG_X, IVec2::Y, IVec2::NEG_Y].map(|d| t.as_ivec2() + d)
100 })
101 .filter(|&t| can_zone(map, t) && !taken(t.as_uvec2()))
102 .map(|t| t.as_uvec2())
103 .min_by(|&a, &b| {
104 let (ka, kb) = (preference(a), preference(b));
105 ka.0.cmp(&kb.0)
106 .then(ka.1.total_cmp(&kb.1))
107 .then((ka.2, ka.3).cmp(&(kb.2, kb.3)))
108 });
109 match best {
110 Some(tile) => planned.push(tile),
111 None => break,
112 }
113 }
114 planned
115 }
116
117 pub fn can_zone(map: &WorldMap, tile: IVec2) -> bool {
118 map.move_cost(tile).is_some() && !map.get(tile).is_some_and(|t| t.is_water())
119 }
120
121 fn rect_tiles(a: IVec2, b: IVec2) -> impl Iterator<Item = IVec2> {
122 let (min, max) = (a.min(b), a.max(b));
123 (min.y..=max.y).flat_map(move |y| (min.x..=max.x).map(move |x| IVec2::new(x, y)))
124 }
125
126 #[derive(Resource, Default, Debug)]
127 pub struct ZoneTool {
128 pub active: bool,
129 drag_start: Option<UVec2>,
130 }
131
132 fn clear_zones(mut zones: ResMut<Zones>) {
133 *zones = Zones::default();
134 }
135
136 pub fn new_stockpile_tiles(corner: UVec2) -> impl Iterator<Item = UVec2> {
137 (0..NEW_STOCKPILE_SIZE)
138 .flat_map(move |y| (0..NEW_STOCKPILE_SIZE).map(move |x| corner + UVec2::new(x, y)))
139 }
140
141 fn is_open_square(map: &WorldMap, corner: UVec2) -> bool {
142 new_stockpile_tiles(corner)
143 .all(|t| can_zone(map, t.as_ivec2()) && map.plant(t.as_ivec2()).is_none())
144 }
145
146 pub fn find_stockpile_site(map: &WorldMap, near: UVec2) -> Option<UVec2> {
147 nearest_tile(map, near, STOCKPILE_SITE_SEARCH_TILES, |p| {
148 is_open_square(map, p)
149 })
150 .or_else(|| {
151 nearest_tile(map, near, STOCKPILE_SITE_SEARCH_TILES, |p| {
152 can_zone(map, p.as_ivec2())
153 })
154 })
155 }
156
157 fn removing(keys: &ButtonInput<KeyCode>) -> bool {
158 keys.any_pressed([KeyCode::ShiftLeft, KeyCode::ShiftRight])
159 }
160
161 fn zone_tool(
162 mut actions: MessageReader<Action>,
163 keys: Res<ButtonInput<KeyCode>>,
164 buttons: Res<ButtonInput<MouseButton>>,
165 over_ui: Res<PointerOverUi>,
166 cursor: Res<Cursor>,
167 map: Res<WorldMap>,
168 mut tool: ResMut<ZoneTool>,
169 mut zones: ResMut<Zones>,
170 ) {
171 for action in actions.read() {
172 match action {
173 Action::ToggleStockpileTool => tool.active = !tool.active,
174 Action::Cancel => tool.active = false,
175 _ => continue,
176 }
177 tool.drag_start = None;
178 return;
179 }
180 if !tool.active {
181 return;
182 }
183 if buttons.just_pressed(MouseButton::Left) && !over_ui.0 {
184 tool.drag_start = cursor.tile;
185 }
186 if !buttons.just_released(MouseButton::Left) {
187 return;
188 }
189 if let (Some(start), Some(end)) = (tool.drag_start.take(), cursor.tile) {
190 if removing(&keys) {
191 zones.remove_stockpile(start.as_ivec2(), end.as_ivec2());
192 } else {
193 zones.add_stockpile(&map, start.as_ivec2(), end.as_ivec2());
194 }
195 }
196 }
197
198 fn draw_zone_preview(
199 keys: Res<ButtonInput<KeyCode>>,
200 cursor: Res<Cursor>,
201 tool: Res<ZoneTool>,
202 mut gizmos: Gizmos,
203 ) {
204 let (Some(start), Some(end)) = (tool.drag_start, cursor.tile) else {
205 return;
206 };
207 let (min, max) = (start.min(end), start.max(end));
208 let center = (WorldMap::tile_center(min) + WorldMap::tile_center(max)) / 2.0;
209 let size = (max - min + 1).as_vec2() * TILE_SIZE;
210 let color = if removing(&keys) {
211 PREVIEW_REMOVE_COLOR
212 } else {
213 PREVIEW_ADD_COLOR
214 };
215 gizmos.rect_2d(center, size, color);
216 }
217
218 #[cfg(test)]
219 mod tests {
220 use super::*;
221 use crate::world::Terrain;
222
223 #[test]
224 fn stockpiles_only_cover_walkable_dry_land() {
225 let mut map = WorldMap::filled(UVec2::new(4, 1), Terrain::Grass);
226 map.set(UVec2::new(1, 0), Terrain::Stone);
227 map.set(UVec2::new(2, 0), Terrain::ShallowWater);
228 let mut zones = Zones::default();
229 zones.add_stockpile(&map, IVec2::new(3, 0), IVec2::new(-1, 0));
230 let mut tiles: Vec<_> = zones.stockpile_tiles().collect();
231 tiles.sort_by_key(|t| t.x);
232 assert_eq!(tiles, vec![UVec2::new(0, 0), UVec2::new(3, 0)]);
233 }
234
235 #[test]
236 fn expansion_grows_compactly_around_the_stockpile() {
237 let map = WorldMap::filled(UVec2::splat(10), Terrain::Grass);
238 let mut zones = Zones::default();
239 zones.add_stockpile(&map, IVec2::new(4, 4), IVec2::new(5, 5));
240 let plan = plan_expansion(&map, &zones, 8);
241 assert_eq!(plan.len(), 8);
242 assert!(plan.iter().all(|t| !zones.is_stockpile(*t)));
243 let beyond_one_ring = plan_expansion(&map, &zones, 20);
244 assert_eq!(beyond_one_ring.len(), 20);
245 assert!(
246 plan.iter()
247 .all(|t| (3..=6).contains(&t.x) && (3..=6).contains(&t.y))
248 );
249 }
250
251 // Trees can be zoned, but stockpiling on open ground keeps forests intact and avoids
252 // colonists cutting trees just to make room, so expansion only takes trees as a last resort.
253 #[test]
254 fn expansion_prefers_open_ground_over_trees_and_skips_unzonable_tiles() {
255 let mut map = WorldMap::filled(UVec2::splat(10), Terrain::Grass);
256 map.set(UVec2::new(3, 4), Terrain::Stone);
257 map.set_plant(UVec2::new(5, 4), Some(crate::world::Plant::Tree));
258 let mut zones = Zones::default();
259 zones.add_stockpile(&map, IVec2::new(4, 4), IVec2::new(4, 4));
260 let plan = plan_expansion(&map, &zones, 2);
261 assert_eq!(plan.len(), 2);
262 assert!(!plan.contains(&UVec2::new(3, 4)));
263 assert!(!plan.contains(&UVec2::new(5, 4)));
264 }
265
266 #[test]
267 fn no_expansion_without_a_stockpile() {
268 let map = WorldMap::filled(UVec2::splat(10), Terrain::Grass);
269 assert!(plan_expansion(&map, &Zones::default(), 8).is_empty());
270 }
271
272 #[test]
273 fn removing_clears_a_rectangle() {
274 let map = WorldMap::filled(UVec2::new(4, 4), Terrain::Grass);
275 let mut zones = Zones::default();
276 zones.add_stockpile(&map, IVec2::ZERO, IVec2::splat(3));
277 zones.remove_stockpile(IVec2::new(1, 1), IVec2::new(2, 2));
278 assert_eq!(zones.stockpile_tiles().count(), 12);
279 assert!(!zones.is_stockpile(UVec2::new(1, 2)));
280 assert!(zones.is_stockpile(UVec2::new(0, 2)));
281 }
282
283 fn tool_app() -> App {
284 let mut app = App::new();
285 app.insert_resource(WorldMap::filled(UVec2::splat(8), Terrain::Grass))
286 .init_resource::<Zones>()
287 .init_resource::<ButtonInput<KeyCode>>()
288 .init_resource::<ButtonInput<MouseButton>>()
289 .insert_resource(ZoneTool {
290 active: true,
291 drag_start: None,
292 })
293 .init_resource::<Cursor>()
294 .init_resource::<PointerOverUi>()
295 .add_message::<Action>()
296 .add_systems(Update, zone_tool);
297 app
298 }
299
300 fn drag(app: &mut App, from: UVec2, to: UVec2) {
301 app.world_mut().resource_mut::<Cursor>().tile = Some(from);
302 app.world_mut()
303 .resource_mut::<ButtonInput<MouseButton>>()
304 .press(MouseButton::Left);
305 app.update();
306 app.world_mut().resource_mut::<Cursor>().tile = Some(to);
307 let mut buttons = app.world_mut().resource_mut::<ButtonInput<MouseButton>>();
308 buttons.clear();
309 buttons.release(MouseButton::Left);
310 app.update();
311 app.world_mut()
312 .resource_mut::<ButtonInput<MouseButton>>()
313 .clear();
314 }
315
316 #[test]
317 fn dragging_adds_and_shift_dragging_removes() {
318 let mut app = tool_app();
319 drag(&mut app, UVec2::new(1, 1), UVec2::new(3, 2));
320 assert_eq!(app.world().resource::<Zones>().stockpile_tiles().count(), 6);
321 app.world_mut()
322 .resource_mut::<ButtonInput<KeyCode>>()
323 .press(KeyCode::ShiftLeft);
324 drag(&mut app, UVec2::new(3, 2), UVec2::new(3, 1));
325 assert_eq!(app.world().resource::<Zones>().stockpile_tiles().count(), 4);
326 }
327
328 #[test]
329 fn dragging_does_nothing_when_the_tool_is_off() {
330 let mut app = tool_app();
331 app.world_mut().resource_mut::<ZoneTool>().active = false;
332 drag(&mut app, UVec2::new(1, 1), UVec2::new(3, 2));
333 assert_eq!(app.world().resource::<Zones>().stockpile_tiles().count(), 0);
334 }
335
336 #[test]
337 fn new_worlds_start_without_stockpiles() {
338 let map = WorldMap::filled(UVec2::splat(8), Terrain::Grass);
339 let mut app = App::new();
340 app.init_resource::<Zones>()
341 .add_message::<WorldGenerated>()
342 .add_systems(Update, clear_zones.run_if(on_message::<WorldGenerated>));
343 app.world_mut()
344 .resource_mut::<Zones>()
345 .add_stockpile(&map, IVec2::ZERO, IVec2::ONE);
346 app.world_mut().write_message(WorldGenerated);
347 app.update();
348 assert!(!app.world().resource::<Zones>().has_stockpile());
349 }
350
351 #[test]
352 fn new_stockpiles_go_on_the_nearest_fully_open_ground() {
353 let mut map = WorldMap::filled(UVec2::splat(12), Terrain::Grass);
354 for y in 0..12 {
355 map.set_plant(UVec2::new(4, y), Some(crate::world::Plant::Tree));
356 map.set(UVec2::new(7, y), Terrain::DeepWater);
357 }
358 let site = find_stockpile_site(&map, UVec2::new(5, 5)).unwrap();
359 assert!(new_stockpile_tiles(site).all(|t| t.x < 4));
360 }
361 }