Skip to content

Commit 832858e

Browse files
thebracketthebracket
committed
Missing files. Sorry.
1 parent 26c9431 commit 832858e

3 files changed

Lines changed: 282 additions & 0 deletions

File tree

  • chapter-59-caverns2/src/spatial
  • chapter-60-caverns3/src/spatial
  • chapter-61-townportal/spatial

‎chapter-59-caverns2/src/spatial/mod.rs‎

Lines changed: 94 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,94 @@
1+
use std::sync::Mutex;
2+
use specs::prelude::*;
3+
use crate::{ Map, tile_walkable };
4+
5+
struct SpatialMap {
6+
blocked : Vec<(bool, bool)>,
7+
tile_content : Vec<Vec<(Entity, bool)>>
8+
}
9+
10+
impl SpatialMap {
11+
fn new() -> Self {
12+
Self {
13+
blocked: Vec::new(),
14+
tile_content: Vec::new()
15+
}
16+
}
17+
}
18+
19+
lazy_static! {
20+
static ref SPATIAL_MAP : Mutex<SpatialMap> = Mutex::new(SpatialMap::new());
21+
}
22+
23+
pub fn set_size(map_tile_count: usize) {
24+
let mut lock = SPATIAL_MAP.lock().unwrap();
25+
lock.blocked = vec![(false, false); map_tile_count];
26+
lock.tile_content = vec![Vec::new(); map_tile_count];
27+
}
28+
29+
pub fn clear() {
30+
let mut lock = SPATIAL_MAP.lock().unwrap();
31+
lock.blocked.iter_mut().for_each(|b| { b.0 = false; b.1 = false; });
32+
for content in lock.tile_content.iter_mut() {
33+
content.clear();
34+
}
35+
}
36+
37+
pub fn populate_blocked_from_map(map: &Map) {
38+
let mut lock = SPATIAL_MAP.lock().unwrap();
39+
for (i,tile) in map.tiles.iter().enumerate() {
40+
lock.blocked[i].0 = !tile_walkable(*tile);
41+
}
42+
}
43+
44+
pub fn index_entity(entity: Entity, idx: usize, blocks_tile: bool) {
45+
let mut lock = SPATIAL_MAP.lock().unwrap();
46+
lock.tile_content[idx].push((entity, blocks_tile));
47+
if blocks_tile {
48+
lock.blocked[idx].1 = true;
49+
}
50+
}
51+
52+
pub fn is_blocked(idx: usize) -> bool {
53+
let lock = SPATIAL_MAP.lock().unwrap();
54+
lock.blocked[idx].0 || lock.blocked[idx].1
55+
}
56+
57+
pub fn for_each_tile_content<F>(idx: usize, mut f: F)
58+
where F : FnMut(Entity)
59+
{
60+
let lock = SPATIAL_MAP.lock().unwrap();
61+
for entity in lock.tile_content[idx].iter() {
62+
f(entity.0);
63+
}
64+
}
65+
66+
pub fn move_entity(entity: Entity, moving_from: usize, moving_to: usize) {
67+
let mut lock = SPATIAL_MAP.lock().unwrap();
68+
let mut entity_blocks = false;
69+
lock.tile_content[moving_from].retain(|(e, blocks) | {
70+
if *e == entity {
71+
entity_blocks = *blocks;
72+
false
73+
} else {
74+
true
75+
}
76+
});
77+
lock.tile_content[moving_to].push((entity, entity_blocks));
78+
79+
// Recalculate blocks for both tiles
80+
let mut from_blocked = false;
81+
let mut to_blocked = false;
82+
lock.tile_content[moving_from].iter().for_each(|(_,blocks)| if *blocks { from_blocked = true; } );
83+
lock.tile_content[moving_to].iter().for_each(|(_,blocks)| if *blocks { to_blocked = true; } );
84+
lock.blocked[moving_from].1 = from_blocked;
85+
lock.blocked[moving_to].1 = to_blocked;
86+
}
87+
88+
pub fn remove_entity(entity: Entity, idx: usize) {
89+
let mut lock = SPATIAL_MAP.lock().unwrap();
90+
lock.tile_content[idx].retain(|(e, _)| *e != entity );
91+
let mut from_blocked = false;
92+
lock.tile_content[idx].iter().for_each(|(_,blocks)| if *blocks { from_blocked = true; } );
93+
lock.blocked[idx].1 = from_blocked;
94+
}

‎chapter-60-caverns3/src/spatial/mod.rs‎

Lines changed: 94 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,94 @@
1+
use std::sync::Mutex;
2+
use specs::prelude::*;
3+
use crate::{ Map, tile_walkable };
4+
5+
struct SpatialMap {
6+
blocked : Vec<(bool, bool)>,
7+
tile_content : Vec<Vec<(Entity, bool)>>
8+
}
9+
10+
impl SpatialMap {
11+
fn new() -> Self {
12+
Self {
13+
blocked: Vec::new(),
14+
tile_content: Vec::new()
15+
}
16+
}
17+
}
18+
19+
lazy_static! {
20+
static ref SPATIAL_MAP : Mutex<SpatialMap> = Mutex::new(SpatialMap::new());
21+
}
22+
23+
pub fn set_size(map_tile_count: usize) {
24+
let mut lock = SPATIAL_MAP.lock().unwrap();
25+
lock.blocked = vec![(false, false); map_tile_count];
26+
lock.tile_content = vec![Vec::new(); map_tile_count];
27+
}
28+
29+
pub fn clear() {
30+
let mut lock = SPATIAL_MAP.lock().unwrap();
31+
lock.blocked.iter_mut().for_each(|b| { b.0 = false; b.1 = false; });
32+
for content in lock.tile_content.iter_mut() {
33+
content.clear();
34+
}
35+
}
36+
37+
pub fn populate_blocked_from_map(map: &Map) {
38+
let mut lock = SPATIAL_MAP.lock().unwrap();
39+
for (i,tile) in map.tiles.iter().enumerate() {
40+
lock.blocked[i].0 = !tile_walkable(*tile);
41+
}
42+
}
43+
44+
pub fn index_entity(entity: Entity, idx: usize, blocks_tile: bool) {
45+
let mut lock = SPATIAL_MAP.lock().unwrap();
46+
lock.tile_content[idx].push((entity, blocks_tile));
47+
if blocks_tile {
48+
lock.blocked[idx].1 = true;
49+
}
50+
}
51+
52+
pub fn is_blocked(idx: usize) -> bool {
53+
let lock = SPATIAL_MAP.lock().unwrap();
54+
lock.blocked[idx].0 || lock.blocked[idx].1
55+
}
56+
57+
pub fn for_each_tile_content<F>(idx: usize, mut f: F)
58+
where F : FnMut(Entity)
59+
{
60+
let lock = SPATIAL_MAP.lock().unwrap();
61+
for entity in lock.tile_content[idx].iter() {
62+
f(entity.0);
63+
}
64+
}
65+
66+
pub fn move_entity(entity: Entity, moving_from: usize, moving_to: usize) {
67+
let mut lock = SPATIAL_MAP.lock().unwrap();
68+
let mut entity_blocks = false;
69+
lock.tile_content[moving_from].retain(|(e, blocks) | {
70+
if *e == entity {
71+
entity_blocks = *blocks;
72+
false
73+
} else {
74+
true
75+
}
76+
});
77+
lock.tile_content[moving_to].push((entity, entity_blocks));
78+
79+
// Recalculate blocks for both tiles
80+
let mut from_blocked = false;
81+
let mut to_blocked = false;
82+
lock.tile_content[moving_from].iter().for_each(|(_,blocks)| if *blocks { from_blocked = true; } );
83+
lock.tile_content[moving_to].iter().for_each(|(_,blocks)| if *blocks { to_blocked = true; } );
84+
lock.blocked[moving_from].1 = from_blocked;
85+
lock.blocked[moving_to].1 = to_blocked;
86+
}
87+
88+
pub fn remove_entity(entity: Entity, idx: usize) {
89+
let mut lock = SPATIAL_MAP.lock().unwrap();
90+
lock.tile_content[idx].retain(|(e, _)| *e != entity );
91+
let mut from_blocked = false;
92+
lock.tile_content[idx].iter().for_each(|(_,blocks)| if *blocks { from_blocked = true; } );
93+
lock.blocked[idx].1 = from_blocked;
94+
}

‎chapter-61-townportal/spatial/mod.rs‎

Lines changed: 94 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,94 @@
1+
use std::sync::Mutex;
2+
use specs::prelude::*;
3+
use crate::{ Map, tile_walkable };
4+
5+
struct SpatialMap {
6+
blocked : Vec<(bool, bool)>,
7+
tile_content : Vec<Vec<(Entity, bool)>>
8+
}
9+
10+
impl SpatialMap {
11+
fn new() -> Self {
12+
Self {
13+
blocked: Vec::new(),
14+
tile_content: Vec::new()
15+
}
16+
}
17+
}
18+
19+
lazy_static! {
20+
static ref SPATIAL_MAP : Mutex<SpatialMap> = Mutex::new(SpatialMap::new());
21+
}
22+
23+
pub fn set_size(map_tile_count: usize) {
24+
let mut lock = SPATIAL_MAP.lock().unwrap();
25+
lock.blocked = vec![(false, false); map_tile_count];
26+
lock.tile_content = vec![Vec::new(); map_tile_count];
27+
}
28+
29+
pub fn clear() {
30+
let mut lock = SPATIAL_MAP.lock().unwrap();
31+
lock.blocked.iter_mut().for_each(|b| { b.0 = false; b.1 = false; });
32+
for content in lock.tile_content.iter_mut() {
33+
content.clear();
34+
}
35+
}
36+
37+
pub fn populate_blocked_from_map(map: &Map) {
38+
let mut lock = SPATIAL_MAP.lock().unwrap();
39+
for (i,tile) in map.tiles.iter().enumerate() {
40+
lock.blocked[i].0 = !tile_walkable(*tile);
41+
}
42+
}
43+
44+
pub fn index_entity(entity: Entity, idx: usize, blocks_tile: bool) {
45+
let mut lock = SPATIAL_MAP.lock().unwrap();
46+
lock.tile_content[idx].push((entity, blocks_tile));
47+
if blocks_tile {
48+
lock.blocked[idx].1 = true;
49+
}
50+
}
51+
52+
pub fn is_blocked(idx: usize) -> bool {
53+
let lock = SPATIAL_MAP.lock().unwrap();
54+
lock.blocked[idx].0 || lock.blocked[idx].1
55+
}
56+
57+
pub fn for_each_tile_content<F>(idx: usize, mut f: F)
58+
where F : FnMut(Entity)
59+
{
60+
let lock = SPATIAL_MAP.lock().unwrap();
61+
for entity in lock.tile_content[idx].iter() {
62+
f(entity.0);
63+
}
64+
}
65+
66+
pub fn move_entity(entity: Entity, moving_from: usize, moving_to: usize) {
67+
let mut lock = SPATIAL_MAP.lock().unwrap();
68+
let mut entity_blocks = false;
69+
lock.tile_content[moving_from].retain(|(e, blocks) | {
70+
if *e == entity {
71+
entity_blocks = *blocks;
72+
false
73+
} else {
74+
true
75+
}
76+
});
77+
lock.tile_content[moving_to].push((entity, entity_blocks));
78+
79+
// Recalculate blocks for both tiles
80+
let mut from_blocked = false;
81+
let mut to_blocked = false;
82+
lock.tile_content[moving_from].iter().for_each(|(_,blocks)| if *blocks { from_blocked = true; } );
83+
lock.tile_content[moving_to].iter().for_each(|(_,blocks)| if *blocks { to_blocked = true; } );
84+
lock.blocked[moving_from].1 = from_blocked;
85+
lock.blocked[moving_to].1 = to_blocked;
86+
}
87+
88+
pub fn remove_entity(entity: Entity, idx: usize) {
89+
let mut lock = SPATIAL_MAP.lock().unwrap();
90+
lock.tile_content[idx].retain(|(e, _)| *e != entity );
91+
let mut from_blocked = false;
92+
lock.tile_content[idx].iter().for_each(|(_,blocks)| if *blocks { from_blocked = true; } );
93+
lock.blocked[idx].1 = from_blocked;
94+
}

0 commit comments

Comments
 (0)