Chunk Rework (#402)

## Description

Iterate on the design of `valence_instance` and `valence_anvil`. This
has been a blocker for #193 and #342.

- Removed the `LOADED` const param from `Chunk` and split it into
separate `LoadedChunk` and `UnloadedChunk` types. Common operations
between the two are part of the new `Chunk` trait.
- Reworked the chunk interface and made it more convenient.
- Removed the confusing `ChunkCell` mechanism and flattened its data
into `LoadedChunk`.
- As a consequence of the previous point, `LoadedChunk` now implements
`WritePacket`.
- Added support for the new biome change packet introduced circa 1.19.4.
- Resolved some confusion around the client's respawn position/compass
position. Fixes #312.
- Improvements to `valence_anvil`. Now handles chunks with unusual
`min_y` correctly.
- Simplified `PacketWriter` interface. No longer takes a mut ref to a
`Vec<u8>`.
- Fixed a bug where block entities were not properly removed when
truncating a chunk.
- Added more unit tests for chunk mutations and chunk loading/unloading.
- Loaded chunks now use viewership information for optimization. Only
chunks in view of clients will record changes. For instance, writing a
packet to a chunk out of view is a no-op.
- Entities are always despawned on the client when the entity is moved
to an unloaded chunk position.
- Reorganized `valence_instance`.
- Fix player list systems not being added to the correct system set.
- New utilities for unit tests.

There was initially some indecision around whether chunks and block
entities should be entities in the ECS. After some consideration, I
decided to abandon that idea.

Author: rj00a

Diff for: Cargo.toml

@@ -92,7 +92,7 @@ license = "MIT"
 
 [workspace.dependencies]
 aes = "0.8.2"
-anyhow = "1.0.70"
+anyhow = { version = "1.0.70", features = ["backtrace"] }
 approx = "0.5.1"
 arrayvec = "0.7.2"
 async-trait = "0.1.60"

Diff for: benches/idle.rs

@@ -29,7 +29,7 @@ fn setup(
 
     for z in -5..5 {
         for x in -5..5 {
-            instance.insert_chunk([x, z], Chunk::default());
+            instance.insert_chunk([x, z], UnloadedChunk::new());
         }
     }
 

Diff for: benches/packet.rs

@@ -7,9 +7,10 @@ use valence::prelude::*;
 use valence::protocol::array::LengthPrefixedArray;
 use valence::protocol::byte_angle::ByteAngle;
 use valence::protocol::decode::PacketDecoder;
-use valence::protocol::encode::{encode_packet, encode_packet_compressed, PacketEncoder};
+use valence::protocol::encode::PacketEncoder;
 use valence::protocol::var_int::VarInt;
 use valence::text::TextFormat;
+use valence_core::protocol::encode::{PacketWriter, WritePacket};
 use valence_entity::packet::EntitySpawnS2c;
 use valence_instance::packet::ChunkDataS2c;
 use valence_player_list::packet::PlayerListHeaderS2c;
@@ -129,7 +130,7 @@ pub fn packet(c: &mut Criterion) {
     let mut decoder = PacketDecoder::new();
     let mut packet_buf = vec![];
 
-    encode_packet(&mut packet_buf, &chunk_data_packet).unwrap();
+    PacketWriter::new(&mut packet_buf, None).write_packet(&chunk_data_packet);
 
     c.bench_function("decode_chunk_data", |b| {
         b.iter(|| {
@@ -148,7 +149,7 @@ pub fn packet(c: &mut Criterion) {
     });
 
     packet_buf.clear();
-    encode_packet(&mut packet_buf, &player_list_header_packet).unwrap();
+    PacketWriter::new(&mut packet_buf, None).write_packet(&player_list_header_packet);
 
     c.bench_function("decode_player_list_header", |b| {
         b.iter(|| {
@@ -167,7 +168,7 @@ pub fn packet(c: &mut Criterion) {
     });
 
     packet_buf.clear();
-    encode_packet(&mut packet_buf, &spawn_entity_packet).unwrap();
+    PacketWriter::new(&mut packet_buf, None).write_packet(&spawn_entity_packet);
 
     c.bench_function("decode_entity_spawn", |b| {
         b.iter(|| {
@@ -187,10 +188,8 @@ pub fn packet(c: &mut Criterion) {
 
     decoder.set_compression(Some(256));
 
-    let mut scratch = vec![];
-
     packet_buf.clear();
-    encode_packet_compressed(&mut packet_buf, &chunk_data_packet, 256, &mut scratch).unwrap();
+    PacketWriter::new(&mut packet_buf, Some(256)).write_packet(&chunk_data_packet);
 
     c.bench_function("decode_chunk_data_compressed", |b| {
         b.iter(|| {
@@ -209,13 +208,7 @@ pub fn packet(c: &mut Criterion) {
     });
 
     packet_buf.clear();
-    encode_packet_compressed(
-        &mut packet_buf,
-        &player_list_header_packet,
-        256,
-        &mut scratch,
-    )
-    .unwrap();
+    PacketWriter::new(&mut packet_buf, Some(256)).write_packet(&player_list_header_packet);
 
     c.bench_function("decode_player_list_header_compressed", |b| {
         b.iter(|| {
@@ -234,7 +227,7 @@ pub fn packet(c: &mut Criterion) {
     });
 
     packet_buf.clear();
-    encode_packet_compressed(&mut packet_buf, &spawn_entity_packet, 256, &mut scratch).unwrap();
+    PacketWriter::new(&mut packet_buf, Some(256)).write_packet(&spawn_entity_packet);
 
     c.bench_function("decode_spawn_entity_compressed", |b| {
         b.iter(|| {

Diff for: crates/valence_anvil/src/lib.rs

@@ -38,7 +38,8 @@ use valence_client::{Client, OldView, UpdateClientsSet, View};
 use valence_core::chunk_pos::ChunkPos;
 use valence_core::ident::Ident;
 use valence_entity::{Location, OldLocation};
-use valence_instance::{Chunk, Instance};
+use valence_instance::chunk::UnloadedChunk;
+use valence_instance::Instance;
 use valence_nbt::Compound;
 
 mod parse_chunk;
@@ -61,7 +62,7 @@ pub struct AnvilLevel {
     receiver: Receiver<(ChunkPos, WorkerResult)>,
 }
 
-type WorkerResult = anyhow::Result<Option<(Chunk, AnvilChunk)>>;
+type WorkerResult = anyhow::Result<Option<(UnloadedChunk, u32)>>;
 
 impl AnvilLevel {
     pub fn new(world_root: impl Into<PathBuf>, biomes: &BiomeRegistry) -> Self {
@@ -82,7 +83,6 @@ impl AnvilLevel {
                     .iter()
                     .map(|(id, name, _)| (name.to_string_ident(), id))
                     .collect(),
-                section_count: 0, // Assigned later.
             }),
             ignored_chunks: HashSet::new(),
             pending: HashMap::new(),
@@ -137,8 +137,6 @@ struct ChunkWorkerState {
     decompress_buf: Vec<u8>,
     /// Mapping of biome names to their biome ID.
     biome_to_id: BTreeMap<Ident<String>, BiomeId>,
-    /// Number of chunk sections in the instance.
-    section_count: usize,
 }
 
 impl ChunkWorkerState {
@@ -287,10 +285,9 @@ impl Plugin for AnvilPlugin {
     }
 }
 
-fn init_anvil(mut query: Query<(&mut AnvilLevel, &Instance), Added<AnvilLevel>>) {
-    for (mut level, inst) in &mut query {
-        if let Some(mut state) = level.worker_state.take() {
-            state.section_count = inst.section_count();
+fn init_anvil(mut query: Query<&mut AnvilLevel, (Added<AnvilLevel>, With<Instance>)>) {
+    for mut level in &mut query {
+        if let Some(state) = level.worker_state.take() {
             thread::spawn(move || anvil_worker(state));
         }
     }
@@ -374,9 +371,9 @@ fn send_recv_chunks(
             anvil.pending.remove(&pos);
 
             let status = match res {
-                Ok(Some((chunk, AnvilChunk { data, timestamp }))) => {
+                Ok(Some((chunk, timestamp))) => {
                     inst.insert_chunk(pos, chunk);
-                    ChunkLoadStatus::Success { data, timestamp }
+                    ChunkLoadStatus::Success { timestamp }
                 }
                 Ok(None) => ChunkLoadStatus::Empty,
                 Err(e) => ChunkLoadStatus::Failed(e),
@@ -418,17 +415,9 @@ fn anvil_worker(mut state: ChunkWorkerState) {
             return Ok(None);
         };
 
-        let mut chunk = Chunk::new(state.section_count);
-        // TODO: account for min_y correctly.
-        parse_chunk::parse_chunk(&anvil_chunk.data, &mut chunk, 4, |biome| {
-            state
-                .biome_to_id
-                .get(biome.as_str())
-                .copied()
-                .unwrap_or_default()
-        })?;
-
-        Ok(Some((chunk, anvil_chunk)))
+        let chunk = parse_chunk::parse_chunk(anvil_chunk.data, &state.biome_to_id)?;
+
+        Ok(Some((chunk, anvil_chunk.timestamp)))
     }
 }
 
@@ -446,8 +435,6 @@ pub struct ChunkLoadEvent {
 pub enum ChunkLoadStatus {
     /// A new chunk was successfully loaded and inserted into the instance.
     Success {
-        /// The raw chunk data of the new chunk.
-        data: Compound,
         /// The time this chunk was last modified, measured in seconds since the
         /// epoch.
         timestamp: u32,