Rename Ecs to World and World to Level.

We previously uses World to store blocks and Ecs to store entities. Now, Level contains
blocks and World contains entities.

This change is motivated by most Rust ECS crates using World as their entity store. Also
, Level is the terminoligy used internally in Minecraft from what I know.

Author: caelunshun

.gitignore

@@ -6,7 +6,7 @@
 # Cargo build configuration
 .cargo
 
-world/
+/world
 /config.toml
 
 # Python cache files (libcraft)

feather/base/src/lib.rs

@@ -13,7 +13,6 @@ pub mod anvil;
 pub mod chunk;
 pub mod inventory;
 pub mod metadata;
-mod world;
 
 pub use blocks::*;
 pub use chunk::{Chunk, ChunkSection, CHUNK_HEIGHT, CHUNK_WIDTH};

feather/base/src/world.rs

@@ -53,7 +53,7 @@ fn update_chunk_entities(game: &mut Game) -> SysResult {
     // Entities that have crossed chunks
     let mut events = Vec::new();
     for (entity, (old_chunk, &position)) in
-        game.ecs.query::<(&mut ChunkPosition, &Position)>().iter()
+        game.world.query::<(&mut ChunkPosition, &Position)>().iter()
     {
         let new_chunk = position.chunk();
         if position.chunk() != *old_chunk {
@@ -71,25 +71,26 @@ fn update_chunk_entities(game: &mut Game) -> SysResult {
         }
     }
     for (entity, event) in events {
-        game.ecs.insert_entity_event(entity, event)?;
+        game.world.insert_entity_event(entity, event)?;
     }
 
     // Entities that have been created
     let mut insertions = Vec::new();
-    for (entity, (_event, &position)) in game.ecs.query::<(&EntityCreateEvent, &Position)>().iter()
+    for (entity, (_event, &position)) in
+        game.world.query::<(&EntityCreateEvent, &Position)>().iter()
     {
         let chunk = position.chunk();
         game.chunk_entities.update(entity, None, chunk);
         insertions.push((entity, chunk));
     }
     // Add ChunkPosition component to new entities
     for (entity, chunk) in insertions {
-        game.ecs.insert(entity, chunk)?;
+        game.world.insert(entity, chunk)?;
     }
 
     // Entities that have been destroyed
     for (entity, (_event, &chunk)) in game
-        .ecs
+        .world
         .query::<(&EntityRemoveEvent, &ChunkPosition)>()
         .iter()
     {

feather/common/src/chunk_entities.rs

@@ -117,7 +117,7 @@ struct Ticket(Entity);
 
 /// System to populate chunk tickets based on players' views.
 fn update_tickets_for_players(game: &mut Game, state: &mut ChunkLoadState) -> SysResult {
-    for (player, event) in game.ecs.query::<&ViewUpdateEvent>().iter() {
+    for (player, event) in game.world.query::<&ViewUpdateEvent>().iter() {
         let player_ticket = Ticket(player);
 
         // Remove old tickets
@@ -130,8 +130,8 @@ fn update_tickets_for_players(game: &mut Game, state: &mut ChunkLoadState) -> Sy
             state.chunk_tickets.insert_ticket(new_chunk, player_ticket);
 
             // Load if needed
-            if !game.world.is_chunk_loaded(new_chunk) && !game.world.is_chunk_loading(new_chunk) {
-                game.world.queue_chunk_load(new_chunk);
+            if !game.level.is_chunk_loaded(new_chunk) && !game.level.is_chunk_loading(new_chunk) {
+                game.level.queue_chunk_load(new_chunk);
             }
         }
     }
@@ -155,13 +155,13 @@ fn unload_chunks(game: &mut Game, state: &mut ChunkLoadState) -> SysResult {
             continue;
         }
 
-        game.world.unload_chunk(unload.pos);
+        game.level.unload_chunk(unload.pos);
     }
     Ok(())
 }
 
 fn remove_dead_entities(game: &mut Game, state: &mut ChunkLoadState) -> SysResult {
-    for (entity, _event) in game.ecs.query::<&EntityRemoveEvent>().iter() {
+    for (entity, _event) in game.world.query::<&EntityRemoveEvent>().iter() {
         let entity_ticket = Ticket(entity);
         for chunk in state.chunk_tickets.take_entity_tickets(entity_ticket) {
             state.remove_ticket(chunk, entity_ticket);
@@ -172,6 +172,6 @@ fn remove_dead_entities(game: &mut Game, state: &mut ChunkLoadState) -> SysResul
 
 /// System to call `World::load_chunks` each tick
 fn load_chunks(game: &mut Game, _state: &mut ChunkLoadState) -> SysResult {
-    game.world.load_chunks(&mut game.ecs);
+    game.level.load_chunks(&mut game.world);
     Ok(())
 }

feather/common/src/chunk_loading.rs

@@ -11,16 +11,16 @@ use crate::{
     chat::{ChatKind, ChatMessage},
     chunk_entities::ChunkEntities,
     events::{BlockChangeEvent, EntityCreateEvent, EntityRemoveEvent, PlayerJoinEvent},
-    ChatBox, World,
+    ChatBox, Level,
 };
 
 type EntitySpawnCallback = Box<dyn FnMut(&mut EntityBuilder, &EntityInit)>;
 
 /// Stores the entire state of a Minecraft game.
 ///
 /// This contains:
-/// * A [`World`](base::World) containing chunks and blocks.
-/// * An [`Ecs`](ecs::Ecs) containing entities.
+/// * A [`World`](vane::Ecs) containing entities.
+/// * A [`Level`] containing blocks.
 /// * A [`Resources`](ecs::Resources) containing additional, user-defined data.
 /// * A [`SystemExecutor`] to run systems.
 ///
@@ -29,14 +29,9 @@ type EntitySpawnCallback = Box<dyn FnMut(&mut EntityBuilder, &EntityInit)>;
 /// should be preferred over raw interaction with the ECS.
 pub struct Game {
     /// Contains chunks and blocks.
-    ///
-    /// NB: use methods on `Game` to update
-    /// blocks, not direct methods on `World`.
-    /// The `Game` methods will automatically
-    /// trigger the necessary `BlockChangeEvent`s.
-    pub world: World,
+    pub level: Level,
     /// Contains entities, including players.
-    pub ecs: Ecs,
+    pub world: Ecs,
     /// Contains systems.
     pub system_executor: Rc<RefCell<SystemExecutor<Game>>>,
 
@@ -66,8 +61,8 @@ impl Game {
     /// Creates a new, empty `Game`.
     pub fn new() -> Self {
         Self {
-            world: World::new(),
-            ecs: Ecs::new(),
+            level: Level::new(),
+            world: Ecs::new(),
             system_executor: Rc::new(RefCell::new(SystemExecutor::new())),
             resources: Arc::new(Resources::new()),
             chunk_entities: ChunkEntities::default(),
@@ -123,7 +118,7 @@ impl Game {
     ///
     /// Also triggers necessary events, like `EntitySpawnEvent` and `PlayerJoinEvent`.
     pub fn spawn_entity(&mut self, mut builder: EntityBuilder) -> Entity {
-        let entity = self.ecs.spawn(builder.build());
+        let entity = self.world.spawn(builder.build());
         self.entity_builder = builder;
 
         self.trigger_entity_spawn_events(entity);
@@ -140,11 +135,11 @@ impl Game {
     }
 
     fn trigger_entity_spawn_events(&mut self, entity: Entity) {
-        self.ecs
+        self.world
             .insert_entity_event(entity, EntityCreateEvent)
             .unwrap();
-        if self.ecs.get::<Player>(entity).is_ok() {
-            self.ecs
+        if self.world.get::<Player>(entity).is_ok() {
+            self.world
                 .insert_entity_event(entity, PlayerJoinEvent)
                 .unwrap();
         }
@@ -153,38 +148,38 @@ impl Game {
     /// Causes the given entity to be removed on the next tick.
     /// In the meantime, triggers `EntityRemoveEvent`.
     pub fn remove_entity(&mut self, entity: Entity) -> Result<(), NoSuchEntity> {
-        self.ecs.defer_despawn(entity);
-        self.ecs.insert_entity_event(entity, EntityRemoveEvent)
+        self.world.defer_despawn(entity);
+        self.world.insert_entity_event(entity, EntityRemoveEvent)
     }
 
     /// Broadcasts a chat message to all entities with
     /// a `ChatBox` component (usually just players).
     pub fn broadcast_chat(&self, kind: ChatKind, message: impl Into<Text>) {
         let message = message.into();
-        for (_, mailbox) in self.ecs.query::<&mut ChatBox>().iter() {
+        for (_, mailbox) in self.world.query::<&mut ChatBox>().iter() {
             mailbox.send(ChatMessage::new(kind, message.clone()));
         }
     }
 
     /// Utility method to send a message to an entity.
     pub fn send_message(&mut self, entity: Entity, message: ChatMessage) -> SysResult {
-        let mut mailbox = self.ecs.get_mut::<ChatBox>(entity)?;
+        let mut mailbox = self.world.get_mut::<ChatBox>(entity)?;
         mailbox.send(message);
         Ok(())
     }
 
     /// Gets the block at the given position.
     pub fn block(&self, pos: BlockPosition) -> Option<BlockId> {
-        self.world.block_at(pos)
+        self.level.block_at(pos)
     }
 
     /// Sets the block at the given position.
     ///
     /// Triggers necessary `BlockChangeEvent`s.
     pub fn set_block(&mut self, pos: BlockPosition, block: BlockId) -> bool {
-        let was_successful = self.world.set_block_at(pos, block);
+        let was_successful = self.level.set_block_at(pos, block);
         if was_successful {
-            self.ecs.insert_event(BlockChangeEvent::single(pos));
+            self.world.insert_event(BlockChangeEvent::single(pos));
         }
         was_successful
     }
@@ -198,7 +193,7 @@ impl Game {
         section_y: usize,
         block: BlockId,
     ) -> bool {
-        let mut chunk = match self.world.chunk_map().chunk_at_mut(chunk_pos) {
+        let mut chunk = match self.level.chunk_map().chunk_at_mut(chunk_pos) {
             Some(chunk) => chunk,
             None => return false,
         };
@@ -209,10 +204,11 @@ impl Game {
             return false;
         }
 
-        self.ecs.insert_event(BlockChangeEvent::fill_chunk_section(
-            chunk_pos,
-            section_y as u32,
-        ));
+        self.world
+            .insert_event(BlockChangeEvent::fill_chunk_section(
+                chunk_pos,
+                section_y as u32,
+            ));
 
         true
     }
@@ -232,10 +228,10 @@ impl HasResources for Game {
 
 impl HasEcs for Game {
     fn ecs(&self) -> &Ecs {
-        &self.ecs
+        &self.world
     }
 
     fn ecs_mut(&mut self) -> &mut Ecs {
-        &mut self.ecs
+        &mut self.world
     }
 }

feather/common/src/game.rs

@@ -7,40 +7,37 @@ use std::sync::Arc;
 
 use crate::{
     events::ChunkLoadEvent,
-    world_source::{null::NullWorldSource, ChunkLoadResult, WorldSource},
+    level_source::{null::NullLevelSource, ChunkLoadResult, LevelSource},
 };
 
 /// Stores all blocks and chunks in a world,
 /// along with global world data like weather, time,
-/// and the [`WorldSource`](crate::world_source::WorldSource).
-///
-/// NB: _not_ what most Rust ECSs call "world."
-/// This does not store entities; it only contains blocks.
-pub struct World {
+/// and the [`LevelSource`](crate::level_source::LevelSource).
+pub struct Level {
     chunk_map: ChunkMap,
-    world_source: Box<dyn WorldSource>,
+    world_source: Box<dyn LevelSource>,
     loading_chunks: AHashSet<ChunkPosition>,
     canceled_chunk_loads: AHashSet<ChunkPosition>,
 }
 
-impl Default for World {
+impl Default for Level {
     fn default() -> Self {
         Self {
             chunk_map: ChunkMap::new(),
-            world_source: Box::new(NullWorldSource::default()),
+            world_source: Box::new(NullLevelSource::default()),
             loading_chunks: AHashSet::new(),
             canceled_chunk_loads: AHashSet::new(),
         }
     }
 }
 
-impl World {
+impl Level {
     pub fn new() -> Self {
         Self::default()
     }
 
     /// Creates a `World` from a `WorldSource` for loading chunks.
-    pub fn with_source(world_source: impl WorldSource + 'static) -> Self {
+    pub fn with_source(world_source: impl LevelSource + 'static) -> Self {
         Self {
             world_source: Box::new(world_source),
             ..Default::default()
@@ -228,7 +225,7 @@ mod tests {
 
     #[test]
     fn world_out_of_bounds() {
-        let mut world = World::new();
+        let mut world = Level::new();
         world
             .chunk_map_mut()
             .insert_chunk(Chunk::new(ChunkPosition::new(0, 0)));

feather/common/src/world.rs renamed to feather/common/src/level.rs

@@ -22,7 +22,7 @@ pub enum ChunkLoadResult {
 }
 
 /// Provides methods to load chunks, entities, and global world data.
-pub trait WorldSource: 'static {
+pub trait LevelSource: 'static {
     /// Enqueues the chunk at `pos` to be loaded.
     /// A future call to `poll_loaded_chunk` should
     /// return this chunk.
@@ -37,7 +37,7 @@ pub trait WorldSource: 'static {
 
     /// Creates a `WorldSource` that falls back to `fallback`
     /// if chunks in `self` are missing or corrupt.
-    fn with_fallback(self, fallback: impl WorldSource) -> FallbackWorldSource
+    fn with_fallback(self, fallback: impl LevelSource) -> FallbackWorldSource
     where
         Self: Sized,
     {
@@ -51,11 +51,11 @@ pub trait WorldSource: 'static {
 /// `WorldSource` wrapping two world sources. Falls back
 /// to the second source if the first one is missing a chunk.
 pub struct FallbackWorldSource {
-    first: Box<dyn WorldSource>,
-    fallback: Box<dyn WorldSource>,
+    first: Box<dyn LevelSource>,
+    fallback: Box<dyn LevelSource>,
 }
 
-impl WorldSource for FallbackWorldSource {
+impl LevelSource for FallbackWorldSource {
     fn queue_load(&mut self, pos: ChunkPosition) {
         self.first.queue_load(pos);
     }

feather/common/src/world_source.rs renamed to feather/common/src/level_source.rs

@@ -1,21 +1,21 @@
 use base::{BlockId, Chunk, ChunkPosition, CHUNK_WIDTH};
 
-use super::{ChunkLoadResult, LoadedChunk, WorldSource};
+use super::{ChunkLoadResult, LevelSource, LoadedChunk};
 
 /// A world source used for debugging that emits
 /// only flat chunks and does no IO.
-pub struct FlatWorldSource {
+pub struct FlatLevelSource {
     archetype: Chunk,
     loaded: Vec<LoadedChunk>,
 }
 
-impl Default for FlatWorldSource {
+impl Default for FlatLevelSource {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl FlatWorldSource {
+impl FlatLevelSource {
     pub fn new() -> Self {
         let mut archetype = Chunk::new(ChunkPosition::new(0, 0));
         for y in 0..64 {
@@ -38,7 +38,7 @@ impl FlatWorldSource {
     }
 }
 
-impl WorldSource for FlatWorldSource {
+impl LevelSource for FlatLevelSource {
     fn queue_load(&mut self, pos: base::ChunkPosition) {
         let mut chunk = self.archetype.clone();
         chunk.set_position(pos);