src/jobs.rs 55.7 K · 1680 lines · raw · history

1 use std::{
2 collections::{HashMap, HashSet},
3 ops::Range,
4 time::Duration,
5 };
6
7 use bevy::prelude::*;
8
9 use crate::{
10 colonist::{Colonist, Path, repath},
11 items::{
12 CARRY_CAPACITY, Carrying, Item, ItemAssets, ItemKind, ItemQuery, drop_items, room_for,
13 stock, take_items,
14 },
15 light::{LIT_BRIGHTNESS, LightMap, brightness, dark_soon, light_from},
16 needs::{EXHAUSTED_REST, Rest, SleepContext, done_sleeping, wants_sleep},
17 pathfinding::{find_path, find_path_adjacent, is_adjacent, nearest_tile},
18 rng::SimRng,
19 sim::{SimSystems, SimTick, hour_of_day},
20 structures::{Fuel, Structure, StructureAssets, StructureKind, spawn_structure},
21 world::{Plant, Terrain, TileChanged, TilePos, WorldMap},
22 worldgen::WorldGenerated,
23 zones::{Zones, can_zone, find_stockpile_site, new_stockpile_tiles, plan_expansion},
24 };
25
26 pub struct JobsPlugin;
27
28 impl Plugin for JobsPlugin {
29 fn build(&self, app: &mut App) {
30 app.insert_resource(SimRng::new(0x5EED))
31 .init_resource::<Reservations>()
32 .init_resource::<ColonyGoals>()
33 .add_message::<Order>()
34 .add_message::<TileChanged>()
35 .add_systems(
36 Update,
37 (
38 clear_reservations.run_if(on_message::<WorldGenerated>),
39 handle_orders,
40 ),
41 )
42 .add_systems(FixedUpdate, choose_jobs.in_set(SimSystems::Decide))
43 .add_systems(FixedUpdate, run_jobs.in_set(SimSystems::Act));
44 }
45 }
46
47 pub const EXPAND_WORK: u32 = 240;
48 pub const CAMPFIRE_MIN_FUEL: u32 = 3 * crate::sim::TICKS_PER_HOUR as u32;
49 pub const HOME_RADIUS: f32 = 10.0;
50 const LIT_WORK_RATE: u32 = 2;
51 const DARK_WORK_RATE: u32 = 1;
52 pub const EXPANSION_TILES: usize = 8;
53 pub const MIN_EMPTY_STOCKPILE_TILES: usize = 3;
54 const SEARCH_TILES: usize = 15000;
55 const WANDER_RADIUS: i32 = 8;
56 const IDLE_SECS: Range<f32> = 1.0..4.0;
57 const IDLE_AFTER_ORDER_SECS: f32 = 10.0;
58 const WORK_PAUSE_SECS: Range<f32> = 0.2..0.8;
59 const NEIGHBORS: [IVec2; 8] = [
60 IVec2::new(1, 0),
61 IVec2::new(-1, 0),
62 IVec2::new(0, 1),
63 IVec2::new(0, -1),
64 IVec2::new(1, 1),
65 IVec2::new(1, -1),
66 IVec2::new(-1, 1),
67 IVec2::new(-1, -1),
68 ];
69
70 #[derive(Component, Default, Debug, Clone, PartialEq)]
71 pub struct CurrentJob(pub Option<Job>);
72
73 #[derive(Debug, Clone, Copy, PartialEq)]
74 pub struct Job {
75 pub task: Task,
76 pub ordered: bool,
77 }
78
79 #[derive(Debug, Clone, Copy, PartialEq)]
80 pub enum Task {
81 MoveTo(UVec2),
82 Work {
83 site: UVec2,
84 kind: WorkKind,
85 progress: u32,
86 },
87 Haul {
88 pickup: Option<UVec2>,
89 to: UVec2,
90 },
91 ExpandStockpile {
92 site: UVec2,
93 progress: u32,
94 },
95 Build {
96 site: UVec2,
97 kind: StructureKind,
98 pickup: Option<UVec2>,
99 progress: u32,
100 },
101 Sleep {
102 spot: UVec2,
103 },
104 }
105
106 pub fn build_work(kind: StructureKind) -> u32 {
107 match kind {
108 StructureKind::Campfire => 360,
109 StructureKind::Torch => 120,
110 StructureKind::Bed => 600,
111 }
112 }
113
114 pub fn work_rate(light: &LightMap, tile: UVec2) -> u32 {
115 if light.is_lit(tile) {
116 LIT_WORK_RATE
117 } else {
118 DARK_WORK_RATE
119 }
120 }
121
122 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
123 pub enum WorkKind {
124 Chop,
125 Mine,
126 }
127
128 impl WorkKind {
129 pub fn work(self) -> u32 {
130 match self {
131 WorkKind::Chop => 480,
132 WorkKind::Mine => 720,
133 }
134 }
135
136 fn complete(self, map: &mut WorldMap, site: UVec2) {
137 match self {
138 WorkKind::Chop => map.set_plant(site, None),
139 WorkKind::Mine => map.set(site, Terrain::Gravel),
140 }
141 }
142 }
143
144 pub struct SiteWork {
145 pub kind: WorkKind,
146 pub item: ItemKind,
147 pub count: u32,
148 }
149
150 pub fn site_work(map: &WorldMap, site: UVec2) -> Option<SiteWork> {
151 let p = site.as_ivec2();
152 if map.plant(p) == Some(Plant::Tree) {
153 return Some(SiteWork {
154 kind: WorkKind::Chop,
155 item: ItemKind::Wood,
156 count: 10,
157 });
158 }
159 let (item, count) = match map.get(p)? {
160 Terrain::Stone => (ItemKind::Stone, 10),
161 Terrain::IronOre => (ItemKind::Iron, 10),
162 Terrain::GoldOre => (ItemKind::Gold, 5),
163 _ => return None,
164 };
165 Some(SiteWork {
166 kind: WorkKind::Mine,
167 item,
168 count,
169 })
170 }
171
172 #[derive(Component, Debug)]
173 pub struct IdleTimer(Timer);
174
175 impl Default for IdleTimer {
176 fn default() -> Self {
177 Self(Timer::from_seconds(IDLE_SECS.start, TimerMode::Once))
178 }
179 }
180
181 impl IdleTimer {
182 fn restart(&mut self, secs: f32) {
183 self.0.set_duration(Duration::from_secs_f32(secs));
184 self.0.reset();
185 }
186 }
187
188 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
189 pub enum Target {
190 Site(UVec2),
191 Pickup(UVec2),
192 Storage(UVec2),
193 StockpileExpansion,
194 SleepSpot(UVec2),
195 }
196
197 #[derive(Resource, Default, Debug)]
198 pub struct Reservations(HashMap<Target, Entity>);
199
200 impl Reservations {
201 pub fn reserve(&mut self, target: Target, by: Entity) {
202 self.0.insert(target, by);
203 }
204
205 pub fn holder(&self, target: Target) -> Option<Entity> {
206 self.0.get(&target).copied()
207 }
208
209 pub fn is_free(&self, target: Target) -> bool {
210 self.holder(target).is_none()
211 }
212
213 pub fn release(&mut self, target: Target) {
214 self.0.remove(&target);
215 }
216
217 pub fn release_all(&mut self, by: Entity) {
218 self.0.retain(|_, holder| *holder != by);
219 }
220 }
221
222 #[derive(Resource, Debug, Clone)]
223 pub struct ColonyGoals(pub HashMap<ItemKind, u32>);
224
225 impl Default for ColonyGoals {
226 fn default() -> Self {
227 Self(HashMap::from([
228 (ItemKind::Wood, 50),
229 (ItemKind::Stone, 40),
230 (ItemKind::Iron, 20),
231 (ItemKind::Gold, 10),
232 ]))
233 }
234 }
235
236 impl ColonyGoals {
237 pub fn goal(&self, kind: ItemKind) -> u32 {
238 self.0.get(&kind).copied().unwrap_or(0)
239 }
240
241 pub fn wanted(&self, kind: ItemKind, in_stock: u32, on_the_way: u32) -> bool {
242 in_stock + on_the_way < self.goal(kind)
243 }
244 }
245
246 #[derive(Message, Debug, Clone, Copy)]
247 pub struct Order {
248 pub colonist: Entity,
249 pub tile: UVec2,
250 }
251
252 fn clear_reservations(mut reservations: ResMut<Reservations>) {
253 reservations.0.clear();
254 }
255
256 fn handle_orders(
257 mut orders: MessageReader<Order>,
258 map: Res<WorldMap>,
259 zones: Res<Zones>,
260 items: Query<(&Item, &TilePos)>,
261 mut reservations: ResMut<Reservations>,
262 mut colonists: Query<(&TilePos, &mut Path, &mut CurrentJob)>,
263 ) {
264 for order in orders.read() {
265 let Ok((tile, mut path, mut job)) = colonists.get_mut(order.colonist) else {
266 continue;
267 };
268 let loose_item = items
269 .iter()
270 .find(|(_, pos)| pos.0 == order.tile && !zones.is_stockpile(pos.0));
271 let task = if let Some(work) = site_work(&map, order.tile) {
272 Some(Task::Work {
273 site: order.tile,
274 kind: work.kind,
275 progress: 0,
276 })
277 } else if let Some((item, _)) = loose_item {
278 find_storage(&map, &zones, &reservations, &items, order.tile, item.kind).map(|to| {
279 Task::Haul {
280 pickup: Some(order.tile),
281 to,
282 }
283 })
284 } else {
285 None
286 };
287 if let Some(task) = task {
288 reservations.release_all(order.colonist);
289 reserve_task(&mut reservations, task, order.colonist);
290 path.0.truncate(1);
291 job.0 = Some(Job {
292 task,
293 ordered: true,
294 });
295 } else if let Some(new_path) = repath(&map, tile.0, &path.0, order.tile) {
296 reservations.release_all(order.colonist);
297 path.0 = new_path;
298 job.0 = Some(Job {
299 task: Task::MoveTo(order.tile),
300 ordered: true,
301 });
302 }
303 }
304 }
305
306 fn reserve_task(reservations: &mut Reservations, task: Task, by: Entity) {
307 match task {
308 Task::MoveTo(_) => {}
309 Task::Work { site, .. } => reservations.reserve(Target::Site(site), by),
310 Task::Haul { pickup, to } => {
311 if let Some(pickup) = pickup {
312 reservations.reserve(Target::Pickup(pickup), by);
313 }
314 reservations.reserve(Target::Storage(to), by);
315 }
316 Task::ExpandStockpile { .. } => reservations.reserve(Target::StockpileExpansion, by),
317 Task::Sleep { spot } => reservations.reserve(Target::SleepSpot(spot), by),
318 Task::Build { site, pickup, .. } => {
319 reservations.reserve(Target::Site(site), by);
320 if let Some(pickup) = pickup {
321 reservations.reserve(Target::Pickup(pickup), by);
322 }
323 }
324 }
325 }
326
327 pub fn find_work(
328 map: &WorldMap,
329 reservations: &Reservations,
330 from: UVec2,
331 wanted: impl Fn(ItemKind) -> bool,
332 ) -> Option<Task> {
333 let mut found = None;
334 nearest_tile(map, from, SEARCH_TILES, |stand| {
335 found = NEIGHBORS.iter().find_map(|&d| {
336 let site = stand.as_ivec2() + d;
337 if site.x < 0 || site.y < 0 {
338 return None;
339 }
340 let site = site.as_uvec2();
341 let work = site_work(map, site)?;
342 (wanted(work.item) && reservations.is_free(Target::Site(site))).then_some(Task::Work {
343 site,
344 kind: work.kind,
345 progress: 0,
346 })
347 });
348 found.is_some()
349 })?;
350 found
351 }
352
353 pub fn find_storage<'a>(
354 map: &WorldMap,
355 zones: &Zones,
356 reservations: &Reservations,
357 items: impl IntoIterator<Item = (&'a Item, &'a TilePos)> + Clone,
358 from: UVec2,
359 kind: ItemKind,
360 ) -> Option<UVec2> {
361 nearest_tile(map, from, SEARCH_TILES, |p| {
362 zones.is_stockpile(p)
363 && reservations.is_free(Target::Storage(p))
364 && room_for(items.clone().into_iter(), p, kind) > 0
365 })
366 }
367
368 pub fn find_haul(
369 map: &WorldMap,
370 zones: &Zones,
371 reservations: &Reservations,
372 items: &[(Item, TilePos)],
373 from: UVec2,
374 ) -> Option<Task> {
375 let loose: HashSet<UVec2> = items
376 .iter()
377 .map(|(_, pos)| pos.0)
378 .filter(|&p| !zones.is_stockpile(p) && reservations.is_free(Target::Pickup(p)))
379 .collect();
380 if loose.is_empty() {
381 return None;
382 }
383 let pickup = nearest_tile(map, from, SEARCH_TILES, |p| loose.contains(&p))?;
384 let (item, _) = items.iter().find(|(_, pos)| pos.0 == pickup)?;
385 let refs = items.iter().map(|(i, p)| (i, p));
386 let to = find_storage(map, zones, reservations, refs, pickup, item.kind)?;
387 Some(Task::Haul {
388 pickup: Some(pickup),
389 to,
390 })
391 }
392
393 pub fn stockpile_too_full(zones: &Zones, items: &[(Item, TilePos)]) -> bool {
394 let occupied: HashSet<UVec2> = items.iter().map(|(_, pos)| pos.0).collect();
395 zones.has_stockpile() && zones.empty_stockpile_tiles(&occupied) < MIN_EMPTY_STOCKPILE_TILES
396 }
397
398 pub fn find_expansion(
399 map: &WorldMap,
400 zones: &Zones,
401 reservations: &Reservations,
402 items: &[(Item, TilePos)],
403 ) -> Option<Task> {
404 if !reservations.is_free(Target::StockpileExpansion) {
405 return None;
406 }
407 let site = if zones.has_stockpile() {
408 if !stockpile_too_full(zones, items) {
409 return None;
410 }
411 *plan_expansion(map, zones, EXPANSION_TILES).first()?
412 } else {
413 find_stockpile_site(map, central_item_tile(items)?)?
414 };
415 Some(Task::ExpandStockpile { site, progress: 0 })
416 }
417
418 fn central_item_tile(items: &[(Item, TilePos)]) -> Option<UVec2> {
419 let tiles: Vec<Vec2> = items.iter().map(|(_, pos)| pos.0.as_vec2()).collect();
420 let centroid = tiles.iter().sum::<Vec2>() / tiles.len().max(1) as f32;
421 items.iter().map(|(_, pos)| pos.0).min_by(|a, b| {
422 a.as_vec2()
423 .distance_squared(centroid)
424 .total_cmp(&b.as_vec2().distance_squared(centroid))
425 })
426 }
427
428 pub struct BuildContext<'a> {
429 pub map: &'a WorldMap,
430 pub zones: &'a Zones,
431 pub reservations: &'a Reservations,
432 pub items: &'a [(Item, TilePos)],
433 pub structures: &'a [(UVec2, StructureKind, u32)],
434 pub planned: &'a [(UVec2, StructureKind)],
435 }
436
437 impl BuildContext<'_> {
438 fn buildable(&self, tile: UVec2) -> bool {
439 can_zone(self.map, tile.as_ivec2())
440 && !self.zones.is_stockpile(tile)
441 && self.map.plant(tile.as_ivec2()).is_none()
442 && !self.structures.iter().any(|(pos, ..)| *pos == tile)
443 && !self.planned.iter().any(|(pos, _)| *pos == tile)
444 && !self.items.iter().any(|(_, pos)| pos.0 == tile)
445 && self.reservations.is_free(Target::Site(tile))
446 }
447
448 fn lights(&self) -> impl Iterator<Item = (UVec2, StructureKind)> + Clone + '_ {
449 self.structures
450 .iter()
451 .map(|&(pos, kind, _)| (pos, kind))
452 .chain(self.planned.iter().copied())
453 }
454
455 fn campfire_needed(&self, home: UVec2) -> bool {
456 let burning = self.structures.iter().any(|&(pos, kind, fuel)| {
457 kind == StructureKind::Campfire
458 && fuel >= CAMPFIRE_MIN_FUEL
459 && pos.as_vec2().distance(home.as_vec2()) <= HOME_RADIUS
460 });
461 let planned = self
462 .planned
463 .iter()
464 .any(|(_, kind)| *kind == StructureKind::Campfire);
465 !burning && !planned
466 }
467
468 fn darkest_stockpile_tile(&self, home: UVec2) -> Option<UVec2> {
469 self.zones
470 .stockpile_tiles()
471 .filter(|&t| brightness(light_from(t, self.lights())) < LIT_BRIGHTNESS)
472 .min_by(|a, b| {
473 a.as_vec2()
474 .distance_squared(home.as_vec2())
475 .total_cmp(&b.as_vec2().distance_squared(home.as_vec2()))
476 .then((a.y, a.x).cmp(&(b.y, b.x)))
477 })
478 }
479
480 fn site_near(&self, target: UVec2, max_distance: f32) -> Option<UVec2> {
481 nearest_tile(self.map, target, SEARCH_TILES, |p| self.buildable(p))
482 .filter(|site| site.as_vec2().distance(target.as_vec2()) <= max_distance)
483 }
484
485 fn count(&self, kind: StructureKind) -> usize {
486 let built = self.structures.iter().filter(|s| s.1 == kind).count();
487 built + self.planned.iter().filter(|p| p.1 == kind).count()
488 }
489
490 fn bed_anchor(&self, home: UVec2) -> UVec2 {
491 let positions = |kind: StructureKind| {
492 let built = self.structures.iter().map(|s| (s.0, s.1));
493 built
494 .chain(self.planned.iter().copied())
495 .filter(move |s| s.1 == kind)
496 .map(|s| s.0)
497 };
498 let nearest = |kind: StructureKind| {
499 positions(kind).min_by(|a, b| {
500 a.as_vec2()
501 .distance_squared(home.as_vec2())
502 .total_cmp(&b.as_vec2().distance_squared(home.as_vec2()))
503 })
504 };
505 nearest(StructureKind::Bed)
506 .or_else(|| nearest(StructureKind::Campfire))
507 .unwrap_or(home)
508 }
509
510 fn wood_source(&self, from: UVec2, amount: u32) -> Option<UVec2> {
511 nearest_tile(self.map, from, SEARCH_TILES, |p| {
512 self.reservations.is_free(Target::Pickup(p))
513 && self.items.iter().any(|(item, pos)| {
514 pos.0 == p && item.kind == ItemKind::Wood && item.count >= amount
515 })
516 })
517 }
518 }
519
520 pub fn find_lighting(ctx: &BuildContext, from: UVec2) -> Option<Task> {
521 let home = ctx.zones.home(from);
522 let (kind, site) = if ctx.campfire_needed(home) {
523 (StructureKind::Campfire, ctx.site_near(home, HOME_RADIUS)?)
524 } else {
525 let dark = ctx.darkest_stockpile_tile(home)?;
526 let reach = StructureKind::Torch.radius() * 0.6;
527 (StructureKind::Torch, ctx.site_near(dark, reach)?)
528 };
529 let pickup = ctx.wood_source(from, kind.wood_cost())?;
530 Some(Task::Build {
531 site,
532 kind,
533 pickup: Some(pickup),
534 progress: 0,
535 })
536 }
537
538 pub fn find_bed_site(ctx: &BuildContext, colonists: usize, from: UVec2) -> Option<Task> {
539 if ctx.count(StructureKind::Bed) >= colonists {
540 return None;
541 }
542 let anchor = ctx.bed_anchor(ctx.zones.home(from));
543 let site = ctx.site_near(anchor, HOME_RADIUS)?;
544 let pickup = ctx.wood_source(from, StructureKind::Bed.wood_cost())?;
545 Some(Task::Build {
546 site,
547 kind: StructureKind::Bed,
548 pickup: Some(pickup),
549 progress: 0,
550 })
551 }
552
553 fn on_the_way(map: &WorldMap, jobs: impl Iterator<Item = Option<Job>>) -> HashMap<ItemKind, u32> {
554 let mut totals = HashMap::new();
555 for job in jobs.flatten() {
556 if let Task::Work { site, .. } = job.task
557 && let Some(work) = site_work(map, site)
558 {
559 *totals.entry(work.item).or_insert(0) += work.count;
560 }
561 }
562 totals
563 }
564
565 #[allow(clippy::too_many_arguments)]
566 fn choose_jobs(
567 mut commands: Commands,
568 time: Res<Time>,
569 map: Res<WorldMap>,
570 zones: Res<Zones>,
571 goals: Res<ColonyGoals>,
572 item_assets: Res<ItemAssets>,
573 tick: Res<SimTick>,
574 mut rng: ResMut<SimRng>,
575 mut reservations: ResMut<Reservations>,
576 mut items: ItemQuery,
577 structures: Query<(&TilePos, &Structure, Option<&Fuel>), Without<Colonist>>,
578 mut colonists: Query<
579 (
580 Entity,
581 &TilePos,
582 &mut Path,
583 &mut CurrentJob,
584 &mut IdleTimer,
585 &mut Carrying,
586 &Rest,
587 ),
588 With<Colonist>,
589 >,
590 ) {
591 let colonist_count = colonists.iter().count();
592 let structures_list: Vec<(UVec2, StructureKind, u32)> = structures
593 .iter()
594 .map(|(pos, s, fuel)| (pos.0, s.kind, fuel.map_or(u32::MAX, |f| f.0)))
595 .collect();
596 let mut planned: Vec<(UVec2, StructureKind)> = colonists
597 .iter()
598 .filter_map(|c| match c.3.0?.task {
599 Task::Build { site, kind, .. } => Some((site, kind)),
600 _ => None,
601 })
602 .collect();
603 let dark = dark_soon(*tick);
604 let carried: Vec<Item> = colonists.iter().filter_map(|c| c.5.0).collect();
605 let stocks: HashMap<ItemKind, u32> = ItemKind::ALL
606 .iter()
607 .map(|&kind| {
608 let all = items.iter().map(|(_, item, _)| item).chain(carried.iter());
609 (kind, stock(all, kind))
610 })
611 .collect();
612 let mut pending = on_the_way(&map, colonists.iter().map(|c| c.3.0));
613 let hour = hour_of_day(*tick);
614 for (entity, tile, mut path, mut job, mut idle, mut carrying, rest) in &mut colonists {
615 let exhausted = rest.0 < EXHAUSTED_REST;
616 if exhausted
617 && job
618 .0
619 .is_some_and(|j| !j.ordered && !matches!(j.task, Task::Sleep { .. }))
620 {
621 reservations.release_all(entity);
622 job.0 = None;
623 path.0.truncate(1);
624 }
625 let rested = idle.0.tick(time.delta()).is_finished();
626 if job.0.is_some() || !path.0.is_empty() || !(rested || exhausted) {
627 continue;
628 }
629 let snapshot: Vec<(Item, TilePos)> =
630 items.iter().map(|(_, item, pos)| (*item, *pos)).collect();
631 let refs = snapshot.iter().map(|(i, p)| (i, p));
632 let wanted = |kind: ItemKind| {
633 goals.wanted(
634 kind,
635 stocks[&kind],
636 pending.get(&kind).copied().unwrap_or(0),
637 )
638 };
639 let sleep = SleepContext {
640 map: &map,
641 zones: &zones,
642 reservations: &reservations,
643 items: &snapshot,
644 structures: &structures_list,
645 };
646 let task = if wants_sleep(rest.0, hour) {
647 Some(Task::Sleep {
648 spot: sleep.spot(tile.0),
649 })
650 } else if let Some(load) = carrying.0 {
651 let storage = find_storage(&map, &zones, &reservations, refs, tile.0, load.kind);
652 if storage.is_none() {
653 drop_items(
654 &mut commands,
655 &mut items,
656 &item_assets,
657 tile.0,
658 load.kind,
659 load.count,
660 );
661 carrying.0 = None;
662 }
663 storage.map(|to| Task::Haul { pickup: None, to })
664 } else {
665 let build = BuildContext {
666 map: &map,
667 zones: &zones,
668 reservations: &reservations,
669 items: &snapshot,
670 structures: &structures_list,
671 planned: &planned,
672 };
673 find_expansion(&map, &zones, &reservations, &snapshot)
674 .or_else(|| dark.then(|| find_lighting(&build, tile.0)).flatten())
675 .or_else(|| find_work(&map, &reservations, tile.0, wanted))
676 .or_else(|| find_haul(&map, &zones, &reservations, &snapshot, tile.0))
677 .or_else(|| find_bed_site(&build, colonist_count, tile.0))
678 };
679 if let Some(task) = task {
680 if let Task::Work { site, .. } = task
681 && let Some(work) = site_work(&map, site)
682 {
683 *pending.entry(work.item).or_insert(0) += work.count;
684 }
685 if let Task::Build { site, kind, .. } = task {
686 planned.push((site, kind));
687 }
688 reserve_task(&mut reservations, task, entity);
689 job.0 = Some(Job {
690 task,
691 ordered: false,
692 });
693 continue;
694 }
695 let goal = tile.0.as_ivec2()
696 + IVec2::new(
697 rng.range_i32(-WANDER_RADIUS..WANDER_RADIUS + 1),
698 rng.range_i32(-WANDER_RADIUS..WANDER_RADIUS + 1),
699 );
700 if map.in_bounds(goal)
701 && let Some(wander_path) = find_path(&map, tile.0, goal.as_uvec2())
702 {
703 path.0 = wander_path.into();
704 idle.restart(rng.range_f32(IDLE_SECS));
705 }
706 }
707 }
708
709 enum Step {
710 Continue,
711 Done,
712 }
713
714 fn walk_to(map: &WorldMap, from: UVec2, to: UVec2, path: &mut Path) -> Step {
715 match find_path(map, from, to) {
716 Some(p) if !p.is_empty() => {
717 path.0 = p.into();
718 Step::Continue
719 }
720 _ => Step::Done,
721 }
722 }
723
724 #[allow(clippy::too_many_arguments)]
725 fn run_jobs(
726 mut commands: Commands,
727 mut map: ResMut<WorldMap>,
728 mut zones: ResMut<Zones>,
729 mut reservations: ResMut<Reservations>,
730 mut rng: ResMut<SimRng>,
731 item_assets: Res<ItemAssets>,
732 structure_assets: Res<StructureAssets>,
733 light: Res<LightMap>,
734 tick: Res<SimTick>,
735 mut items: ItemQuery,
736 structures: Query<&TilePos, (With<Structure>, Without<Colonist>)>,
737 mut changed: MessageWriter<TileChanged>,
738 mut colonists: Query<
739 (
740 Entity,
741 &TilePos,
742 &mut Path,
743 &mut CurrentJob,
744 &mut IdleTimer,
745 &mut Carrying,
746 &Rest,
747 ),
748 With<Colonist>,
749 >,
750 ) {
751 let hour = hour_of_day(*tick);
752 for (entity, tile, mut path, mut current, mut idle, mut carrying, rest) in &mut colonists {
753 let Some(mut job) = current.0 else {
754 continue;
755 };
756 if !path.0.is_empty() {
757 continue;
758 }
759 let step = match &mut job.task {
760 Task::MoveTo(_) => Step::Done,
761 Task::Sleep { spot } => {
762 if reservations.holder(Target::SleepSpot(*spot)) != Some(entity) {
763 Step::Done
764 } else if tile.0 != *spot {
765 let step = walk_to(&map, tile.0, *spot, &mut path);
766 if matches!(step, Step::Done) {
767 reservations.release(Target::SleepSpot(*spot));
768 *spot = tile.0;
769 reservations.reserve(Target::SleepSpot(*spot), entity);
770 }
771 Step::Continue
772 } else if done_sleeping(rest.0, hour) {
773 Step::Done
774 } else {
775 Step::Continue
776 }
777 }
778 Task::Work {
779 site,
780 kind,
781 progress,
782 } => {
783 let (site, kind) = (*site, *kind);
784 let work = site_work(&map, site).filter(|w| w.kind == kind);
785 let ours = reservations.holder(Target::Site(site)) == Some(entity);
786 match work {
787 Some(work) if ours => {
788 if !is_adjacent(tile.0.as_ivec2(), site.as_ivec2()) {
789 match find_path_adjacent(&map, tile.0, site) {
790 Some(p) if !p.is_empty() => {
791 path.0 = p.into();
792 Step::Continue
793 }
794 _ => Step::Done,
795 }
796 } else {
797 *progress += work_rate(&light, tile.0);
798 if *progress < kind.work() {
799 Step::Continue
800 } else {
801 kind.complete(&mut map, site);
802 changed.write(TileChanged(site));
803 drop_items(
804 &mut commands,
805 &mut items,
806 &item_assets,
807 site,
808 work.item,
809 work.count,
810 );
811 Step::Done
812 }
813 }
814 }
815 _ => Step::Done,
816 }
817 }
818 Task::ExpandStockpile { site, progress } => {
819 if tile.0 != *site {
820 walk_to(&map, tile.0, *site, &mut path)
821 } else {
822 *progress += work_rate(&light, tile.0);
823 if *progress >= EXPAND_WORK {
824 if zones.has_stockpile() {
825 let tiles = plan_expansion(&map, &zones, EXPANSION_TILES);
826 zones.add_tiles(&map, tiles);
827 } else {
828 zones.add_tiles(&map, new_stockpile_tiles(*site));
829 }
830 Step::Done
831 } else {
832 Step::Continue
833 }
834 }
835 }
836 Task::Build {
837 site,
838 kind,
839 pickup,
840 progress,
841 } => {
842 let (site, kind) = (*site, *kind);
843 let ours = reservations.holder(Target::Site(site)) == Some(entity);
844 let blocked = map.plant(site.as_ivec2()).is_some()
845 || structures.iter().any(|pos| pos.0 == site);
846 let cost = kind.wood_cost();
847 if !ours || blocked {
848 Step::Done
849 } else if let Some(from) = *pickup {
850 if reservations.holder(Target::Pickup(from)) != Some(entity) {
851 Step::Done
852 } else if tile.0 != from {
853 walk_to(&map, tile.0, from, &mut path)
854 } else {
855 let load = take_items(&mut commands, &mut items, from, cost)
856 .filter(|load| load.kind == ItemKind::Wood && load.count > 0);
857 carrying.0 = load;
858 match load {
859 Some(load) if load.count >= cost => {
860 reservations.release(Target::Pickup(from));
861 *pickup = None;
862 Step::Continue
863 }
864 _ => Step::Done,
865 }
866 }
867 } else if !carrying
868 .0
869 .is_some_and(|load| load.kind == ItemKind::Wood && load.count >= cost)
870 {
871 Step::Done
872 } else if !is_adjacent(tile.0.as_ivec2(), site.as_ivec2()) {
873 match find_path_adjacent(&map, tile.0, site) {
874 Some(p) if !p.is_empty() => {
875 path.0 = p.into();
876 Step::Continue
877 }
878 _ => Step::Done,
879 }
880 } else {
881 *progress += work_rate(&light, tile.0);
882 if *progress < build_work(kind) {
883 Step::Continue
884 } else {
885 carrying.0 = carrying.0.and_then(|load| {
886 (load.count > cost).then_some(Item {
887 count: load.count - cost,
888 ..load
889 })
890 });
891 spawn_structure(&mut commands, &structure_assets, site, kind);
892 Step::Done
893 }
894 }
895 }
896 Task::Haul { pickup, to } => {
897 let to = *to;
898 let destination_valid = zones.is_stockpile(to)
899 && reservations.holder(Target::Storage(to)) == Some(entity);
900 if !destination_valid {
901 Step::Done
902 } else if let Some(from) = *pickup {
903 if reservations.holder(Target::Pickup(from)) != Some(entity) {
904 Step::Done
905 } else if tile.0 != from {
906 walk_to(&map, tile.0, from, &mut path)
907 } else {
908 let kind = items
909 .iter()
910 .find(|(_, _, pos)| pos.0 == from)
911 .map(|(_, item, _)| item.kind);
912 let room = kind.map_or(0, |kind| {
913 room_for(items.iter().map(|(_, i, p)| (i, p)), to, kind)
914 });
915 match take_items(&mut commands, &mut items, from, CARRY_CAPACITY.min(room))
916 .filter(|load| load.count > 0)
917 {
918 Some(load) => {
919 carrying.0 = Some(load);
920 reservations.release(Target::Pickup(from));
921 *pickup = None;
922 Step::Continue
923 }
924 None => Step::Done,
925 }
926 }
927 } else if let Some(load) = carrying.0 {
928 if tile.0 != to {
929 walk_to(&map, tile.0, to, &mut path)
930 } else {
931 let room = room_for(items.iter().map(|(_, i, p)| (i, p)), to, load.kind);
932 let dropped = load.count.min(room);
933 if dropped > 0 {
934 drop_items(
935 &mut commands,
936 &mut items,
937 &item_assets,
938 to,
939 load.kind,
940 dropped,
941 );
942 }
943 carrying.0 = (load.count > dropped).then_some(Item {
944 count: load.count - dropped,
945 ..load
946 });
947 Step::Done
948 }
949 } else {
950 Step::Done
951 }
952 }
953 };
954 match step {
955 Step::Continue => current.0 = Some(job),
956 Step::Done => {
957 reservations.release_all(entity);
958 current.0 = None;
959 let ordered_move = matches!(
960 job,
961 Job {
962 task: Task::MoveTo(_),
963 ordered: true
964 }
965 );
966 idle.restart(if ordered_move {
967 IDLE_AFTER_ORDER_SECS
968 } else {
969 rng.range_f32(WORK_PAUSE_SECS)
970 });
971 }
972 }
973 }
974 }
975
976 #[cfg(test)]
977 mod tests {
978 use super::*;
979 use crate::{
980 colonist::follow_path,
981 items::STACK_LIMIT,
982 sim::{SimPos, sim_pos},
983 world::Terrain,
984 zones::NEW_STOCKPILE_SIZE,
985 };
986
987 const TICK: Duration = Duration::from_nanos(1_000_000_000 / 60);
988
989 fn test_app(map: WorldMap) -> App {
990 let mut app = App::new();
991 app.insert_resource(map)
992 .insert_resource(SimRng::new(1))
993 .init_resource::<Time>()
994 .init_resource::<Reservations>()
995 .init_resource::<ColonyGoals>()
996 .init_resource::<ItemAssets>()
997 .init_resource::<StructureAssets>()
998 .init_resource::<LightMap>()
999 .init_resource::<SimTick>()
1000 .init_resource::<Zones>()
1001 .add_message::<Order>()
1002 .add_message::<TileChanged>()
1003 .add_systems(
1004 Update,
1005 (
1006 handle_orders,
1007 choose_jobs,
1008 run_jobs,
1009 follow_path,
1010 crate::needs::update_rest,
1011 )
1012 .chain(),
1013 );
1014 app
1015 }
1016
1017 fn spawn_colonist(app: &mut App, tile: UVec2) -> Entity {
1018 app.world_mut()
1019 .spawn((
1020 Colonist {
1021 name: "Test".into(),
1022 },
1023 TilePos(tile),
1024 sim_pos(WorldMap::tile_center(tile)),
1025 ))
1026 .id()
1027 }
1028
1029 fn run_ticks(app: &mut App, ticks: u32) {
1030 for _ in 0..ticks {
1031 app.world_mut().resource_mut::<Time>().advance_by(TICK);
1032 app.update();
1033 }
1034 }
1035
1036 fn map_with_trees(trees: &[UVec2]) -> WorldMap {
1037 let mut map = WorldMap::filled(UVec2::new(20, 20), Terrain::Grass);
1038 for &t in trees {
1039 map.set_plant(t, Some(Plant::Tree));
1040 }
1041 map
1042 }
1043
1044 fn wood_on_map(app: &mut App) -> u32 {
1045 let world = app.world_mut();
1046 let items: Vec<Item> = world.query::<&Item>().iter(world).copied().collect();
1047 stock(items.iter(), ItemKind::Wood)
1048 }
1049
1050 fn items_at(app: &mut App) -> Vec<(UVec2, u32)> {
1051 let world = app.world_mut();
1052 let mut items: Vec<(UVec2, u32)> = world
1053 .query::<(&Item, &TilePos)>()
1054 .iter(world)
1055 .map(|(item, pos)| (pos.0, item.count))
1056 .collect();
1057 items.sort_by_key(|(p, _)| (p.y, p.x));
1058 items
1059 }
1060
1061 fn put_wood(app: &mut App, tile: UVec2, count: u32) {
1062 app.world_mut().spawn((
1063 Item {
1064 kind: ItemKind::Wood,
1065 count,
1066 },
1067 TilePos(tile),
1068 ));
1069 }
1070
1071 fn set_goals(app: &mut App, goals: &[(ItemKind, u32)]) {
1072 *app.world_mut().resource_mut::<ColonyGoals>() =
1073 ColonyGoals(goals.iter().copied().collect());
1074 }
1075
1076 fn stockpile_size(app: &App) -> usize {
1077 let map = app.world().resource::<WorldMap>();
1078 let zones = app.world().resource::<Zones>();
1079 map.positions().filter(|&p| zones.is_stockpile(p)).count()
1080 }
1081
1082 fn stored(app: &mut App) -> u32 {
1083 let zones = app.world().resource::<Zones>().clone();
1084 items_at(app)
1085 .iter()
1086 .filter(|(p, _)| zones.is_stockpile(*p))
1087 .map(|(_, c)| c)
1088 .sum()
1089 }
1090
1091 fn put_beds(app: &mut App, count: u32) {
1092 for x in 0..count {
1093 app.world_mut().spawn((
1094 Structure {
1095 kind: StructureKind::Bed,
1096 },
1097 TilePos(UVec2::new(19 - x, 19)),
1098 ));
1099 }
1100 }
1101
1102 fn hauling_app(stockpile: (IVec2, IVec2)) -> App {
1103 let mut app = test_app(map_with_trees(&[]));
1104 put_beds(&mut app, 2);
1105 set_goals(&mut app, &[]);
1106 let map = app.world().resource::<WorldMap>().clone();
1107 app.world_mut()
1108 .resource_mut::<Zones>()
1109 .add_stockpile(&map, stockpile.0, stockpile.1);
1110 app
1111 }
1112
1113 fn carrying(app: &App, colonist: Entity) -> Option<Item> {
1114 app.world().get::<Carrying>(colonist).unwrap().0
1115 }
1116
1117 fn job(app: &App, colonist: Entity) -> Option<Job> {
1118 app.world().get::<CurrentJob>(colonist).unwrap().0
1119 }
1120
1121 #[test]
1122 fn idle_colonists_cut_trees_when_the_colony_needs_wood() {
1123 let tree = UVec2::new(8, 5);
1124 let mut app = test_app(map_with_trees(&[tree]));
1125 spawn_colonist(&mut app, UVec2::new(2, 5));
1126 run_ticks(&mut app, 60 * 15);
1127 assert_eq!(
1128 app.world().resource::<WorldMap>().plant(tree.as_ivec2()),
1129 None
1130 );
1131 assert_eq!(wood_on_map(&mut app), 10);
1132 assert!(app.world().resource::<Reservations>().0.is_empty());
1133 }
1134
1135 #[test]
1136 fn colonists_leave_trees_alone_when_there_is_enough_wood() {
1137 let tree = UVec2::new(8, 5);
1138 let mut app = test_app(map_with_trees(&[tree]));
1139 set_goals(&mut app, &[]);
1140 spawn_colonist(&mut app, UVec2::new(2, 5));
1141 run_ticks(&mut app, 60 * 15);
1142 assert_eq!(
1143 app.world().resource::<WorldMap>().plant(tree.as_ivec2()),
1144 Some(Plant::Tree)
1145 );
1146 }
1147
1148 #[test]
1149 fn colonists_never_pick_the_same_tree() {
1150 let trees = [UVec2::new(10, 10), UVec2::new(10, 11)];
1151 let mut app = test_app(map_with_trees(&trees));
1152 let a = spawn_colonist(&mut app, UVec2::new(5, 10));
1153 let b = spawn_colonist(&mut app, UVec2::new(5, 11));
1154 run_ticks(&mut app, 61);
1155 let target = |c| match job(&app, c) {
1156 Some(Job {
1157 task: Task::Work { site, .. },
1158 ..
1159 }) => site,
1160 other => panic!("expected chop job, got {other:?}"),
1161 };
1162 assert_ne!(target(a), target(b));
1163 }
1164
1165 // Each tree or rock being worked will add its yield; counting that as material on the way
1166 // keeps the whole colony from felling a forest when only a little more wood is needed.
1167 #[test]
1168 fn work_in_progress_counts_towards_goals() {
1169 let goals = ColonyGoals(HashMap::from([(ItemKind::Wood, 25)]));
1170 assert!(goals.wanted(ItemKind::Wood, 10, 10));
1171 assert!(!goals.wanted(ItemKind::Wood, 10, 20));
1172 assert!(!goals.wanted(ItemKind::Wood, 30, 0));
1173 assert!(!goals.wanted(ItemKind::Gold, 0, 0));
1174 }
1175
1176 #[test]
1177 fn ordered_chop_ignores_the_wood_goal() {
1178 let tree = UVec2::new(8, 5);
1179 let mut app = test_app(map_with_trees(&[tree]));
1180 set_goals(&mut app, &[]);
1181 let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
1182 app.world_mut().write_message(Order {
1183 colonist,
1184 tile: tree,
1185 });
1186 run_ticks(&mut app, 60 * 15);
1187 assert_eq!(
1188 app.world().resource::<WorldMap>().plant(tree.as_ivec2()),
1189 None
1190 );
1191 }
1192
1193 #[test]
1194 fn ordering_a_move_cancels_the_current_job_and_frees_its_tree() {
1195 let tree = UVec2::new(15, 5);
1196 let mut app = test_app(map_with_trees(&[tree]));
1197 let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
1198 run_ticks(&mut app, 61);
1199 assert!(matches!(
1200 job(&app, colonist),
1201 Some(Job {
1202 task: Task::Work { .. },
1203 ..
1204 })
1205 ));
1206 app.world_mut().write_message(Order {
1207 colonist,
1208 tile: UVec2::new(2, 15),
1209 });
1210 run_ticks(&mut app, 1);
1211 assert_eq!(
1212 job(&app, colonist).map(|j| j.task),
1213 Some(Task::MoveTo(UVec2::new(2, 15)))
1214 );
1215 assert!(
1216 app.world()
1217 .resource::<Reservations>()
1218 .is_free(Target::Site(tree))
1219 );
1220 }
1221
1222 #[test]
1223 fn idle_colonists_haul_loose_items_into_the_stockpile() {
1224 let mut app = hauling_app((IVec2::new(15, 15), IVec2::new(17, 15)));
1225 put_wood(&mut app, UVec2::new(5, 5), 20);
1226 spawn_colonist(&mut app, UVec2::new(2, 5));
1227 run_ticks(&mut app, 60 * 15);
1228 assert_eq!(items_at(&mut app), vec![(UVec2::new(15, 15), 20)]);
1229 }
1230
1231 #[test]
1232 fn large_stacks_take_several_trips_and_spill_into_more_stockpile_tiles() {
1233 let mut app = hauling_app((IVec2::new(15, 15), IVec2::new(17, 15)));
1234 put_wood(&mut app, UVec2::new(5, 5), STACK_LIMIT + 10);
1235 spawn_colonist(&mut app, UVec2::new(2, 5));
1236 run_ticks(&mut app, 60 * 40);
1237 let stacks = items_at(&mut app);
1238 assert_eq!(stored(&mut app), STACK_LIMIT + 10);
1239 assert!(stacks.len() >= 2);
1240 assert!(stacks.iter().all(|(_, count)| *count <= STACK_LIMIT));
1241 }
1242
1243 #[test]
1244 fn items_already_in_a_stockpile_stay_put() {
1245 let mut app = hauling_app((IVec2::new(5, 5), IVec2::new(16, 16)));
1246 put_wood(&mut app, UVec2::new(5, 5), 20);
1247 let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
1248 run_ticks(&mut app, 60 * 5);
1249 assert_eq!(items_at(&mut app), vec![(UVec2::new(5, 5), 20)]);
1250 assert_eq!(carrying(&app, colonist), None);
1251 }
1252
1253 #[test]
1254 fn colonists_found_a_stockpile_when_items_need_storing() {
1255 let mut app = test_app(map_with_trees(&[]));
1256 put_beds(&mut app, 1);
1257 set_goals(&mut app, &[]);
1258 put_wood(&mut app, UVec2::new(5, 5), 20);
1259 spawn_colonist(&mut app, UVec2::new(2, 5));
1260 run_ticks(&mut app, 60 * 15);
1261 assert_eq!(
1262 stockpile_size(&app),
1263 (NEW_STOCKPILE_SIZE * NEW_STOCKPILE_SIZE) as usize
1264 );
1265 assert_eq!(stored(&mut app), 20);
1266 }
1267
1268 #[test]
1269 fn no_stockpile_is_founded_while_there_is_nothing_to_store() {
1270 let mut app = test_app(map_with_trees(&[]));
1271 set_goals(&mut app, &[]);
1272 spawn_colonist(&mut app, UVec2::new(2, 5));
1273 run_ticks(&mut app, 60 * 5);
1274 assert_eq!(stockpile_size(&app), 0);
1275 }
1276
1277 #[test]
1278 fn two_colonists_never_haul_the_same_stack() {
1279 let mut app = hauling_app((IVec2::new(15, 15), IVec2::new(16, 16)));
1280 put_wood(&mut app, UVec2::new(5, 5), 10);
1281 put_wood(&mut app, UVec2::new(5, 6), 10);
1282 let a = spawn_colonist(&mut app, UVec2::new(2, 5));
1283 let b = spawn_colonist(&mut app, UVec2::new(2, 6));
1284 run_ticks(&mut app, 61);
1285 let pickup = |c| match job(&app, c).map(|j| j.task) {
1286 Some(Task::Haul { pickup, .. }) => pickup,
1287 other => panic!("expected haul, got {other:?}"),
1288 };
1289 assert_ne!(pickup(a), pickup(b));
1290 }
1291
1292 // Orders interrupt whatever a colonist is doing, but whatever it is carrying stays in its
1293 // hands; once it is idle again it finishes delivering it instead of dropping it anywhere.
1294 #[test]
1295 fn interrupted_haulers_deliver_their_load_later() {
1296 let mut app = hauling_app((IVec2::new(15, 15), IVec2::new(17, 15)));
1297 put_wood(&mut app, UVec2::new(4, 5), 20);
1298 let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
1299 let mut ticks = 0;
1300 while carrying(&app, colonist).is_none() && ticks < 60 * 10 {
1301 run_ticks(&mut app, 1);
1302 ticks += 1;
1303 }
1304 app.world_mut().write_message(Order {
1305 colonist,
1306 tile: UVec2::new(2, 2),
1307 });
1308 run_ticks(&mut app, 60 * 3);
1309 assert!(carrying(&app, colonist).is_some());
1310 run_ticks(&mut app, 60 * 20);
1311 assert_eq!(carrying(&app, colonist), None);
1312 assert_eq!(stored(&mut app), 20);
1313 }
1314
1315 #[test]
1316 fn right_clicking_loose_items_orders_a_haul() {
1317 let mut app = hauling_app((IVec2::new(15, 15), IVec2::new(15, 15)));
1318 set_goals(&mut app, &[(ItemKind::Wood, 1000)]);
1319 put_wood(&mut app, UVec2::new(5, 5), 20);
1320 let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
1321 app.world_mut().write_message(Order {
1322 colonist,
1323 tile: UVec2::new(5, 5),
1324 });
1325 run_ticks(&mut app, 1);
1326 assert!(matches!(
1327 job(&app, colonist),
1328 Some(Job {
1329 task: Task::Haul { .. },
1330 ordered: true
1331 })
1332 ));
1333 }
1334
1335 fn mining_map() -> WorldMap {
1336 let mut map = WorldMap::filled(UVec2::new(20, 20), Terrain::Grass);
1337 for y in 0..20 {
1338 map.set(UVec2::new(10, y), Terrain::Stone);
1339 }
1340 map.set(UVec2::new(10, 5), Terrain::IronOre);
1341 map
1342 }
1343
1344 fn items_of(app: &mut App, kind: ItemKind) -> u32 {
1345 let world = app.world_mut();
1346 let items: Vec<Item> = world.query::<&Item>().iter(world).copied().collect();
1347 stock(items.iter(), kind)
1348 }
1349
1350 #[test]
1351 fn colonists_mine_rock_the_colony_needs_and_leave_gravel() {
1352 let mut app = test_app(mining_map());
1353 set_goals(&mut app, &[(ItemKind::Stone, 10)]);
1354 spawn_colonist(&mut app, UVec2::new(8, 12));
1355 run_ticks(&mut app, 60 * 12);
1356 assert_eq!(items_of(&mut app, ItemKind::Stone), 10);
1357 assert_eq!(items_of(&mut app, ItemKind::Iron), 0);
1358 let map = app.world().resource::<WorldMap>();
1359 let gravel = map
1360 .positions()
1361 .filter(|p| map.get(p.as_ivec2()) == Some(Terrain::Gravel))
1362 .count();
1363 assert_eq!(gravel, 1);
1364 }
1365
1366 #[test]
1367 fn colonists_walk_past_rock_they_do_not_need() {
1368 let mut app = test_app(mining_map());
1369 set_goals(&mut app, &[(ItemKind::Iron, 10)]);
1370 spawn_colonist(&mut app, UVec2::new(8, 15));
1371 run_ticks(&mut app, 60 * 15);
1372 assert_eq!(items_of(&mut app, ItemKind::Iron), 10);
1373 assert_eq!(items_of(&mut app, ItemKind::Stone), 0);
1374 assert_eq!(
1375 app.world().resource::<WorldMap>().get(IVec2::new(10, 5)),
1376 Some(Terrain::Gravel)
1377 );
1378 }
1379
1380 #[test]
1381 fn right_clicking_rock_orders_mining_regardless_of_goals() {
1382 let mut app = test_app(mining_map());
1383 set_goals(&mut app, &[]);
1384 let colonist = spawn_colonist(&mut app, UVec2::new(8, 12));
1385 app.world_mut().write_message(Order {
1386 colonist,
1387 tile: UVec2::new(10, 12),
1388 });
1389 run_ticks(&mut app, 60 * 10);
1390 assert_eq!(
1391 app.world().resource::<WorldMap>().get(IVec2::new(10, 12)),
1392 Some(Terrain::Gravel)
1393 );
1394 }
1395
1396 #[test]
1397 fn colonists_expand_a_stockpile_that_is_nearly_full() {
1398 let mut app = hauling_app((IVec2::new(5, 5), IVec2::new(6, 5)));
1399 let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
1400 run_ticks(&mut app, 61);
1401 assert!(matches!(
1402 job(&app, colonist).map(|j| j.task),
1403 Some(Task::ExpandStockpile { .. })
1404 ));
1405 run_ticks(&mut app, 60 * 5);
1406 assert_eq!(stockpile_size(&app), 2 + EXPANSION_TILES);
1407 }
1408
1409 #[test]
1410 fn roomy_stockpiles_are_left_alone() {
1411 let mut app = hauling_app((IVec2::new(5, 5), IVec2::new(8, 5)));
1412 spawn_colonist(&mut app, UVec2::new(2, 5));
1413 run_ticks(&mut app, 60 * 5);
1414 assert_eq!(stockpile_size(&app), 4);
1415 }
1416
1417 fn set_hour(app: &mut App, hour: u64) {
1418 let ticks = (hour + 24 - 6) % 24 * crate::sim::TICKS_PER_HOUR;
1419 *app.world_mut().resource_mut::<SimTick>() = SimTick(ticks);
1420 }
1421
1422 fn structures(app: &mut App) -> Vec<(UVec2, StructureKind)> {
1423 let world = app.world_mut();
1424 world
1425 .query::<(&TilePos, &Structure)>()
1426 .iter(world)
1427 .map(|(pos, s)| (pos.0, s.kind))
1428 .collect()
1429 }
1430
1431 fn put_campfire(app: &mut App, tile: UVec2) {
1432 app.world_mut().spawn((
1433 Structure {
1434 kind: StructureKind::Campfire,
1435 },
1436 Fuel(StructureKind::Campfire.fuel_ticks().unwrap()),
1437 TilePos(tile),
1438 ));
1439 }
1440
1441 #[test]
1442 fn colonists_light_a_campfire_near_the_stockpile_when_night_falls() {
1443 let mut app = hauling_app((IVec2::new(10, 10), IVec2::new(12, 12)));
1444 put_wood(&mut app, UVec2::new(10, 10), 20);
1445 set_hour(&mut app, 18);
1446 spawn_colonist(&mut app, UVec2::new(2, 5));
1447 run_ticks(&mut app, 60 * 20);
1448 let built = structures(&mut app);
1449 let campfire = built
1450 .iter()
1451 .find(|(_, kind)| *kind == StructureKind::Campfire)
1452 .expect("a campfire");
1453 assert!(campfire.0.as_vec2().distance(Vec2::new(11.0, 11.0)) <= HOME_RADIUS);
1454 assert_eq!(wood_on_map(&mut app), 10);
1455 }
1456
1457 #[test]
1458 fn no_fires_are_built_during_the_day() {
1459 let mut app = hauling_app((IVec2::new(10, 10), IVec2::new(12, 12)));
1460 put_wood(&mut app, UVec2::new(10, 10), 20);
1461 set_hour(&mut app, 10);
1462 spawn_colonist(&mut app, UVec2::new(2, 5));
1463 run_ticks(&mut app, 60 * 10);
1464 assert!(
1465 structures(&mut app)
1466 .iter()
1467 .all(|(_, kind)| kind.light().is_none())
1468 );
1469 }
1470
1471 #[test]
1472 fn without_wood_nothing_can_be_built() {
1473 let mut app = hauling_app((IVec2::new(10, 10), IVec2::new(12, 12)));
1474 set_hour(&mut app, 22);
1475 spawn_colonist(&mut app, UVec2::new(2, 5));
1476 run_ticks(&mut app, 60 * 10);
1477 assert!(
1478 structures(&mut app)
1479 .iter()
1480 .all(|(_, kind)| kind.light().is_none())
1481 );
1482 }
1483
1484 #[test]
1485 fn torches_light_stockpile_tiles_beyond_the_campfire() {
1486 let mut app = hauling_app((IVec2::new(2, 10), IVec2::new(17, 10)));
1487 put_wood(&mut app, UVec2::new(9, 10), 20);
1488 put_campfire(&mut app, UVec2::new(9, 12));
1489 set_hour(&mut app, 22);
1490 spawn_colonist(&mut app, UVec2::new(9, 8));
1491 run_ticks(&mut app, 60 * 15);
1492 assert!(
1493 structures(&mut app)
1494 .iter()
1495 .any(|(_, kind)| *kind == StructureKind::Torch)
1496 );
1497 }
1498
1499 // Light is what makes fires worth building: work in darkness goes at half speed.
1500 #[test]
1501 fn work_is_slower_in_the_dark() {
1502 let tree = UVec2::new(8, 5);
1503 let finish_ticks = |daylight: f32| {
1504 let mut app = test_app(map_with_trees(&[tree]));
1505 let size = app.world().resource::<WorldMap>().size;
1506 app.insert_resource(LightMap::compute(size, daylight, []));
1507 spawn_colonist(&mut app, UVec2::new(7, 5));
1508 let mut ticks = 0;
1509 while app
1510 .world()
1511 .resource::<WorldMap>()
1512 .plant(tree.as_ivec2())
1513 .is_some()
1514 {
1515 run_ticks(&mut app, 1);
1516 ticks += 1;
1517 }
1518 ticks
1519 };
1520 let (lit, dark) = (finish_ticks(1.0), finish_ticks(0.0));
1521 assert!(
1522 dark > lit + WorkKind::Chop.work() / 2 - 10,
1523 "lit {lit}, dark {dark}"
1524 );
1525 }
1526
1527 const NAP_TEST_REST: f32 = 0.25;
1528
1529 fn set_rest(app: &mut App, colonist: Entity, rest: f32) {
1530 app.world_mut().get_mut::<Rest>(colonist).unwrap().0 = rest;
1531 }
1532
1533 fn rest(app: &App, colonist: Entity) -> f32 {
1534 app.world().get::<Rest>(colonist).unwrap().0
1535 }
1536
1537 fn task(app: &App, colonist: Entity) -> Option<Task> {
1538 job(app, colonist).map(|j| j.task)
1539 }
1540
1541 #[test]
1542 fn tired_colonists_nap_and_get_up_when_rested() {
1543 let mut app = test_app(map_with_trees(&[]));
1544 set_goals(&mut app, &[]);
1545 set_hour(&mut app, 10);
1546 let colonist = spawn_colonist(&mut app, UVec2::new(5, 5));
1547 set_rest(&mut app, colonist, NAP_TEST_REST);
1548 run_ticks(&mut app, 61);
1549 assert!(matches!(task(&app, colonist), Some(Task::Sleep { .. })));
1550 let mut ticks = 0;
1551 while matches!(task(&app, colonist), Some(Task::Sleep { .. })) && ticks < 60 * 60 * 10 {
1552 run_ticks(&mut app, 60);
1553 ticks += 60;
1554 }
1555 assert!(!matches!(task(&app, colonist), Some(Task::Sleep { .. })));
1556 assert!(rest(&app, colonist) > 0.95);
1557 }
1558
1559 #[test]
1560 fn colonists_go_to_bed_at_night_and_sleep_until_morning() {
1561 let mut app = test_app(map_with_trees(&[]));
1562 set_goals(&mut app, &[]);
1563 set_hour(&mut app, 22);
1564 let colonist = spawn_colonist(&mut app, UVec2::new(5, 5));
1565 set_rest(&mut app, colonist, 0.8);
1566 run_ticks(&mut app, 61);
1567 assert!(matches!(task(&app, colonist), Some(Task::Sleep { .. })));
1568 run_ticks(&mut app, 3 * crate::sim::TICKS_PER_HOUR as u32);
1569 assert_eq!(rest(&app, colonist), 1.0);
1570 assert!(matches!(task(&app, colonist), Some(Task::Sleep { .. })));
1571 }
1572
1573 #[test]
1574 fn rested_colonists_stay_up_during_the_day() {
1575 let mut app = test_app(map_with_trees(&[]));
1576 set_goals(&mut app, &[]);
1577 set_hour(&mut app, 12);
1578 let colonist = spawn_colonist(&mut app, UVec2::new(5, 5));
1579 set_rest(&mut app, colonist, 0.8);
1580 run_ticks(&mut app, 60 * 5);
1581 assert!(!matches!(task(&app, colonist), Some(Task::Sleep { .. })));
1582 }
1583
1584 #[test]
1585 fn exhausted_colonists_drop_their_work_to_sleep() {
1586 let tree = UVec2::new(15, 5);
1587 let mut app = test_app(map_with_trees(&[tree]));
1588 let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
1589 run_ticks(&mut app, 61);
1590 assert!(matches!(task(&app, colonist), Some(Task::Work { .. })));
1591 set_rest(&mut app, colonist, EXHAUSTED_REST / 2.0);
1592 run_ticks(&mut app, 30);
1593 assert!(matches!(task(&app, colonist), Some(Task::Sleep { .. })));
1594 assert!(
1595 app.world()
1596 .resource::<Reservations>()
1597 .is_free(Target::Site(tree))
1598 );
1599 }
1600
1601 #[test]
1602 fn exhaustion_does_not_override_orders() {
1603 let tree = UVec2::new(15, 5);
1604 let mut app = test_app(map_with_trees(&[tree]));
1605 let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
1606 app.world_mut().write_message(Order {
1607 colonist,
1608 tile: tree,
1609 });
1610 run_ticks(&mut app, 2);
1611 set_rest(&mut app, colonist, EXHAUSTED_REST / 2.0);
1612 run_ticks(&mut app, 30);
1613 assert!(matches!(
1614 job(&app, colonist),
1615 Some(Job {
1616 task: Task::Work { .. },
1617 ordered: true
1618 })
1619 ));
1620 }
1621
1622 fn beds(app: &mut App) -> usize {
1623 structures(app)
1624 .iter()
1625 .filter(|(_, kind)| *kind == StructureKind::Bed)
1626 .count()
1627 }
1628
1629 #[test]
1630 fn colonists_build_one_bed_each() {
1631 let mut app = test_app(map_with_trees(&[]));
1632 set_goals(&mut app, &[]);
1633 let map = app.world().resource::<WorldMap>().clone();
1634 app.world_mut().resource_mut::<Zones>().add_stockpile(
1635 &map,
1636 IVec2::new(2, 2),
1637 IVec2::new(5, 5),
1638 );
1639 put_wood(&mut app, UVec2::new(2, 2), 50);
1640 put_wood(&mut app, UVec2::new(3, 2), 50);
1641 spawn_colonist(&mut app, UVec2::new(10, 10));
1642 spawn_colonist(&mut app, UVec2::new(11, 10));
1643 run_ticks(&mut app, 60 * 40);
1644 assert_eq!(beds(&mut app), 2);
1645 assert_eq!(
1646 wood_on_map(&mut app),
1647 100 - 2 * StructureKind::Bed.wood_cost()
1648 );
1649 }
1650
1651 #[test]
1652 fn colonists_sleep_in_their_beds() {
1653 let mut app = test_app(map_with_trees(&[]));
1654 set_goals(&mut app, &[]);
1655 put_beds(&mut app, 1);
1656 set_hour(&mut app, 22);
1657 let colonist = spawn_colonist(&mut app, UVec2::new(5, 5));
1658 set_rest(&mut app, colonist, 0.5);
1659 run_ticks(&mut app, 60 * 10);
1660 assert_eq!(
1661 app.world().get::<TilePos>(colonist).unwrap().0,
1662 UVec2::new(19, 19)
1663 );
1664 assert!(matches!(task(&app, colonist), Some(Task::Sleep { .. })));
1665 }
1666
1667 #[test]
1668 fn colonists_chop_from_a_neighbouring_tile() {
1669 let tree = UVec2::new(8, 5);
1670 let mut app = test_app(map_with_trees(&[tree]));
1671 let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
1672 run_ticks(&mut app, 60 * 5);
1673 let tile = app.world().get::<TilePos>(colonist).unwrap().0;
1674 assert!(is_adjacent(tile.as_ivec2(), tree.as_ivec2()));
1675 assert_eq!(
1676 app.world().get::<SimPos>(colonist).unwrap().0,
1677 WorldMap::tile_center(tile)
1678 );
1679 }
1680 }