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
|
use azalea::{
Vec3,
pathfinder::simulation::{SimulatedPlayerBundle, SimulationSet},
};
use azalea_core::position::{ChunkBlockPos, ChunkPos};
use azalea_world::{Chunk, ChunkStorage, PartialChunkStorage};
use criterion::{Bencher, Criterion, criterion_group, criterion_main};
#[allow(dead_code)]
fn generate_world(partial_chunks: &mut PartialChunkStorage, size: u32) -> ChunkStorage {
let size = size as i32;
let mut chunks = ChunkStorage::default();
for chunk_x in -size..size {
for chunk_z in -size..size {
let chunk_pos = ChunkPos::new(chunk_x, chunk_z);
partial_chunks.set(&chunk_pos, Some(Chunk::default()), &mut chunks);
}
}
for chunk_x in -size..size {
for chunk_z in -size..size {
let chunk_pos = ChunkPos::new(chunk_x, chunk_z);
let chunk = chunks.get(&chunk_pos).unwrap();
let mut chunk = chunk.write();
for x in 0..16_u8 {
for z in 0..16_u8 {
chunk.set_block_state(
&ChunkBlockPos::new(x, 1, z),
azalea_registry::Block::OakFence.into(),
chunks.min_y,
);
}
}
}
}
// let mut start = BlockPos::new(-64, 4, -64);
// // move start down until it's on a solid block
// while chunks.get_block_state(&start).unwrap().is_air() {
// start = start.down(1);
// }
// start = start.up(1);
// let mut end = BlockPos::new(63, 4, 63);
// // move end down until it's on a solid block
// while chunks.get_block_state(&end).unwrap().is_air() {
// end = end.down(1);
// }
// end = end.up(1);
chunks
}
fn run_physics_benchmark(b: &mut Bencher<'_>) {
let mut partial_chunks = PartialChunkStorage::new(32);
let world = generate_world(&mut partial_chunks, 4);
let mut simulation_set = SimulationSet::new(world);
// let entity = simulation_set.spawn(SimulatedPlayerBundle::new(Vec3::new(0.0,
// 4.0, 0.0))); for _ in 0..20 {
// simulation_set.tick();
// println!("tick over");
// }
// simulation_set.despawn(entity);
// std::process::exit(0);
b.iter(|| {
let entity = simulation_set.spawn(SimulatedPlayerBundle::new(Vec3::new(0.5, 2.0, 0.5)));
for _ in 0..20 {
simulation_set.tick();
}
simulation_set.despawn(entity);
})
}
fn bench_pathfinder(c: &mut Criterion) {
c.bench_function("physics", |b| {
run_physics_benchmark(b);
});
}
criterion_group!(benches, bench_pathfinder);
criterion_main!(benches);
|
