Added bombs, throwable items, more block kinds, weaker explosions

CHANGELOG.md

@@ -38,6 +38,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - New quadruped_low body for reptile-likes
 - Added new animals
 - Better pathfinding
+- Bombs
 
 ### Changed
 
@@ -57,6 +58,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Switch to a new network backend that will allow several improvements in the future
 - Connection screen fails after 4 minutes if it can't connect to the server instead of 80 minutes
 - Rebuilt quadruped_medium animation and assets
+- Disabled destruction of most blocks by explosions
 
 ### Removed
 

assets/common/items/bomb.ron

@@ -0,0 +1,7 @@
+Item(
+    name: "Bomb",
+    description: "Boom!\n\n<Right-Click to use>",
+    kind: Throwable(
+        kind: Bomb,
+    ),
+)

assets/voxygen/item_image_manifest.ron

@@ -777,6 +777,11 @@
     Consumable(VeloriteFrag): VoxTrans(
         "voxel.sprite.velorite.velorite_1",
         (0.0, -1.0, 0.0), (-50.0, 40.0, 20.0), 0.8,
+    ),
+	// Throwables
+    Throwable(Bomb): VoxTrans(
+        "voxel.object.bomb",
+        (0.0, -1.0, 0.0), (-50.0, 40.0, 20.0), 0.8,
     ),
     // Ingredients
     Ingredient(Flower): VoxTrans(

common/src/comp/inventory/item/mod.rs

@@ -28,6 +28,11 @@ pub enum Consumable {
     PotionExp,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum Throwable {
+    Bomb,
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum Utility {
     Collar,
@@ -86,6 +91,11 @@ pub enum ItemKind {
         #[serde(default = "default_amount")]
         amount: u32,
     },
+    Throwable {
+        kind: Throwable,
+        #[serde(default = "default_amount")]
+        amount: u32,
+    },
     Utility {
         kind: Utility,
         #[serde(default = "default_amount")]
@@ -129,15 +139,10 @@ impl Item {
     pub fn set_amount(&mut self, give_amount: u32) -> Result<(), assets::Error> {
         use ItemKind::*;
         match self.kind {
-            Consumable { ref mut amount, .. } => {
+            Consumable { ref mut amount, .. }
-                *amount = give_amount;
+            | Throwable { ref mut amount, .. }
-                Ok(())
+            | Utility { ref mut amount, .. }
-            },
+            | Ingredient { ref mut amount, .. } => {
-            Utility { ref mut amount, .. } => {
-                *amount = give_amount;
-                Ok(())
-            },
-            Ingredient { ref mut amount, .. } => {
                 *amount = give_amount;
                 Ok(())
             },

common/src/comp/inventory/mod.rs

@@ -102,6 +102,37 @@ impl Inventory {
                 // It didn't work
                 self.add_to_first_empty(item)
             },
+            ItemKind::Throwable {
+                kind: item_kind,
+                amount: new_amount,
+                ..
+            } => {
+                for slot in &mut self.slots {
+                    if slot
+                        .as_ref()
+                        .map(|s| s.name() == item.name())
+                        .unwrap_or(false)
+                        && slot
+                            .as_ref()
+                            .map(|s| s.description() == item.description())
+                            .unwrap_or(false)
+                    {
+                        if let Some(Item {
+                            kind: ItemKind::Throwable { kind, amount, .. },
+                            ..
+                        }) = slot
+                        {
+                            if item_kind == *kind {
+                                *amount += new_amount;
+                                self.recount_items();
+                                return None;
+                            }
+                        }
+                    }
+                }
+                // It didn't work
+                self.add_to_first_empty(item)
+            },
             ItemKind::Ingredient {
                 kind: item_kind,
                 amount: new_amount,
@@ -277,6 +308,19 @@ impl Inventory {
                         Some(return_item)
                     }
                 },
+                ItemKind::Throwable { kind, amount } => {
+                    if *amount <= 1 {
+                        self.remove(cell)
+                    } else {
+                        *amount -= 1;
+                        return_item.kind = ItemKind::Throwable {
+                            kind: *kind,
+                            amount: 1,
+                        };
+                        self.recount_items();
+                        Some(return_item)
+                    }
+                },
                 ItemKind::Ingredient { kind, amount } => {
                     if *amount <= 1 {
                         self.remove(cell)

common/src/comp/misc.rs

@@ -0,0 +1,16 @@
+use crate::sync::Uid;
+use specs::Component;
+use specs_idvs::IDVStorage;
+use std::time::Duration;
+
+#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum Object {
+    Bomb {
+        timeout: Duration,
+        owner: Option<Uid>,
+    },
+}
+
+impl Component for Object {
+    type Storage = IDVStorage<Self>;
+}

common/src/comp/mod.rs

@@ -10,6 +10,7 @@ mod inputs;
 mod inventory;
 mod last;
 mod location;
+mod misc;
 mod phys;
 mod player;
 pub mod projectile;
@@ -40,6 +41,7 @@ pub use inventory::{
 };
 pub use last::Last;
 pub use location::{Waypoint, WaypointArea};
+pub use misc::Object;
 pub use phys::{Collider, ForceUpdate, Gravity, Mass, Ori, PhysicsState, Pos, Scale, Sticky, Vel};
 pub use player::Player;
 pub use projectile::Projectile;

common/src/state.rs

@@ -122,6 +122,7 @@ impl State {
         ecs.register::<comp::Sticky>();
         ecs.register::<comp::Gravity>();
         ecs.register::<comp::CharacterState>();
+        ecs.register::<comp::Object>();
 
         // Register components send from clients -> server
         ecs.register::<comp::Controller>();

common/src/terrain/block.rs

@@ -9,6 +9,9 @@ pub enum BlockKind {
     Air,
     Normal,
     Dense,
+    Rock,
+    Grass,
+    Leaves,
     Water,
     LargeCactus,
     BarrelCactus,
@@ -32,7 +35,6 @@ pub enum BlockKind {
     Velorite,
     VeloriteFrag,
     Chest,
-    Leaves,
     Pumpkin,
     Welwitch,
     LingonBerry,
@@ -325,6 +327,13 @@ impl BlockKind {
         }
     }
 
+    pub fn is_explodable(&self) -> bool {
+        match self {
+            BlockKind::Leaves | BlockKind::Grass | BlockKind::Rock => true,
+            _ => false,
+        }
+    }
+
     // TODO: Integrate this into `is_solid` by returning an `Option<f32>`
     pub fn get_height(&self) -> f32 {
         // Beware: the height *must* be <= `MAX_HEIGHT` or the collision system will not

server/src/events/entity_manipulation.rs

@@ -292,11 +292,19 @@ pub fn handle_explosion(server: &Server, pos: Vec3<f32>, power: f32, owner: Opti
         )
         .normalized();
 
-        let _ = ecs
+        let terrain = ecs.read_resource::<TerrainGrid>();
-            .read_resource::<TerrainGrid>()
+        let _ = terrain
             .ray(pos, pos + dir * power)
             .until(|_| rand::random::<f32>() < 0.05)
-            .for_each(|pos| block_change.set(pos, Block::empty()))
+            .for_each(|pos| {
+                if terrain
+                    .get(pos)
+                    .map(|block| block.is_explodable())
+                    .unwrap_or(false)
+                {
+                    block_change.set(pos, Block::empty());
+                }
+            })
             .cast();
     }
 }

server/src/events/inventory_manip.rs

@@ -5,12 +5,13 @@ use common::{
         slot::{self, Slot},
         Pos, MAX_PICKUP_RANGE_SQR,
     },
-    sync::WorldSyncExt,
+    sync::{Uid, WorldSyncExt},
     terrain::block::Block,
     vol::{ReadVol, Vox},
 };
 use rand::Rng;
 use specs::{join::Join, world::WorldExt, Builder, Entity as EcsEntity, WriteStorage};
+use std::time::Duration;
 use tracing::{debug, error};
 use vek::Vec3;
 
@@ -33,6 +34,7 @@ pub fn snuff_lantern(storage: &mut WriteStorage<comp::LightEmitter>, entity: Ecs
 pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::InventoryManip) {
     let state = server.state_mut();
     let mut dropped_items = Vec::new();
+    let mut thrown_items = Vec::new();
 
     match manip {
         comp::InventoryManip::Pickup(uid) => {
@@ -157,6 +159,29 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
                                 maybe_effect = Some(*effect);
                                 Some(comp::InventoryUpdateEvent::Consumed(*kind))
                             },
+                            ItemKind::Throwable { .. } => {
+                                if let Some(pos) =
+                                    state.ecs().read_storage::<comp::Pos>().get(entity)
+                                {
+                                    thrown_items.push((
+                                        *pos,
+                                        state
+                                            .ecs()
+                                            .read_storage::<comp::Vel>()
+                                            .get(entity)
+                                            .copied()
+                                            .unwrap_or_default(),
+                                        state
+                                            .ecs()
+                                            .read_storage::<comp::Ori>()
+                                            .get(entity)
+                                            .copied()
+                                            .unwrap_or_default(),
+                                        item,
+                                    ));
+                                }
+                                Some(comp::InventoryUpdateEvent::Used)
+                            },
                             ItemKind::Utility {
                                 kind: comp::item::Utility::Collar,
                                 ..
@@ -318,6 +343,37 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
             .with(comp::Vel(vel))
             .build();
     }
+
+    // Drop items
+    for (pos, vel, ori, item) in thrown_items {
+        let vel = vel.0
+            + *ori.0 * 20.0
+            + Vec3::unit_z() * 15.0
+            + Vec3::<f32>::zero().map(|_| rand::thread_rng().gen::<f32>() - 0.5) * 4.0;
+
+        let uid = state.read_component_cloned::<Uid>(entity);
+
+        let mut entity = state
+            .create_object(Default::default(), comp::object::Body::Bomb)
+            .with(comp::Pos(pos.0 + Vec3::unit_z() * 0.25))
+            .with(comp::Vel(vel));
+
+        #[allow(clippy::single-match)]
+        match item.kind {
+            item::ItemKind::Throwable {
+                kind: item::Throwable::Bomb,
+                ..
+            } => {
+                entity = entity.with(comp::Object::Bomb {
+                    timeout: Duration::from_secs_f32(1.0),
+                    owner: uid,
+                })
+            },
+            _ => {},
+        }
+
+        entity.build();
+    }
 }
 
 fn within_pickup_range(player_position: Option<&Pos>, item_position: Option<&Pos>) -> bool {

server/src/sys/mod.rs

@@ -1,5 +1,6 @@
 pub mod entity_sync;
 pub mod message;
+pub mod object;
 pub mod persistence;
 pub mod sentinel;
 pub mod subscription;
@@ -32,11 +33,13 @@ pub type PersistenceScheduler = SysScheduler<persistence::Sys>;
 const TERRAIN_SYS: &str = "server_terrain_sys";
 const WAYPOINT_SYS: &str = "waypoint_sys";
 const PERSISTENCE_SYS: &str = "persistence_sys";
+const OBJECT_SYS: &str = "object_sys";
 
 pub fn add_server_systems(dispatch_builder: &mut DispatcherBuilder) {
     dispatch_builder.add(terrain::Sys, TERRAIN_SYS, &[]);
     dispatch_builder.add(waypoint::Sys, WAYPOINT_SYS, &[]);
     dispatch_builder.add(persistence::Sys, PERSISTENCE_SYS, &[]);
+    dispatch_builder.add(object::Sys, OBJECT_SYS, &[]);
 }
 
 pub fn run_sync_systems(ecs: &mut specs::World) {

server/src/sys/object.rs

@@ -0,0 +1,51 @@
+use common::{
+    comp::{HealthSource, Object, PhysicsState, Pos},
+    event::{EventBus, ServerEvent},
+    state::DeltaTime,
+};
+use specs::{Entities, Join, Read, ReadStorage, System, WriteStorage};
+use std::time::Duration;
+
+/// This system is responsible for handling projectile effect triggers
+pub struct Sys;
+impl<'a> System<'a> for Sys {
+    #[allow(clippy::type_complexity)]
+    type SystemData = (
+        Entities<'a>,
+        Read<'a, DeltaTime>,
+        Read<'a, EventBus<ServerEvent>>,
+        ReadStorage<'a, Pos>,
+        ReadStorage<'a, PhysicsState>,
+        WriteStorage<'a, Object>,
+    );
+
+    fn run(
+        &mut self,
+        (entities, dt, server_bus, positions, physics_states, mut objects): Self::SystemData,
+    ) {
+        let mut server_emitter = server_bus.emitter();
+
+        // Objects
+        for (entity, pos, _physics, object) in
+            (&entities, &positions, &physics_states, &mut objects).join()
+        {
+            match object {
+                Object::Bomb { owner, timeout } => {
+                    if let Some(t) = timeout.checked_sub(Duration::from_secs_f32(dt.0)) {
+                        *timeout = t;
+                    } else {
+                        server_emitter.emit(ServerEvent::Destroy {
+                            entity,
+                            cause: HealthSource::Suicide,
+                        });
+                        server_emitter.emit(ServerEvent::Explosion {
+                            pos: pos.0,
+                            power: 4.0,
+                            owner: *owner,
+                        });
+                    }
+                },
+            }
+        }
+    }
+}

voxygen/src/hud/item_imgs.rs

@@ -4,7 +4,7 @@ use common::{
     comp::item::{
         armor::Armor,
         tool::{Tool, ToolKind},
-        Consumable, Ingredient, Item, ItemKind, Lantern, LanternKind, Utility,
+        Consumable, Ingredient, Item, ItemKind, Lantern, LanternKind, Throwable, Utility,
     },
     figure::Segment,
 };
@@ -24,6 +24,7 @@ pub enum ItemKey {
     Armor(Armor),
     Utility(Utility),
     Consumable(Consumable),
+    Throwable(Throwable),
     Ingredient(Ingredient),
     Empty,
 }
@@ -35,6 +36,7 @@ impl From<&Item> for ItemKey {
             ItemKind::Armor { kind, .. } => ItemKey::Armor(*kind),
             ItemKind::Utility { kind, .. } => ItemKey::Utility(*kind),
             ItemKind::Consumable { kind, .. } => ItemKey::Consumable(*kind),
+            ItemKind::Throwable { kind, .. } => ItemKey::Throwable(*kind),
             ItemKind::Ingredient { kind, .. } => ItemKey::Ingredient(*kind),
         }
     }

voxygen/src/hud/slots.rs

@@ -42,6 +42,7 @@ impl SlotKey<Inventory, ItemImgs> for InventorySlot {
                 ItemKind::Tool { .. } | ItemKind::Lantern(_) | ItemKind::Armor { .. } => None,
                 ItemKind::Utility { amount, .. }
                 | ItemKind::Consumable { amount, .. }
+                | ItemKind::Throwable { amount, .. }
                 | ItemKind::Ingredient { amount, .. } => Some(amount),
             })
             .filter(|amount| *amount > 1)
@@ -139,6 +140,7 @@ impl<'a> SlotKey<HotbarSource<'a>, HotbarImageSource<'a>> for HotbarSlot {
                 ItemKind::Tool { .. } | ItemKind::Lantern(_) | ItemKind::Armor { .. } => None,
                 ItemKind::Utility { amount, .. }
                 | ItemKind::Consumable { amount, .. }
+                | ItemKind::Throwable { amount, .. }
                 | ItemKind::Ingredient { amount, .. } => Some(amount),
             })
             .filter(|amount| *amount > 1)

world/src/block/mod.rs

@@ -254,22 +254,19 @@ impl<'a> BlockGen<'a> {
                 .map(|e| (e * 255.0) as u8);
 
                 // Underground
-                if (wposf.z as f32) > alt - 32.0 * chaos {
+                Some(Block::new(BlockKind::Normal, col))
-                    Some(Block::new(BlockKind::Normal, col))
-                } else {
-                    Some(Block::new(BlockKind::Dense, col))
-                }
             } else if (wposf.z as f32) < height {
-                let col = Lerp::lerp(
+                let grass_factor = (wposf.z as f32 - (height - grass_depth))
-                    sub_surface_color,
+                    .div(grass_depth)
-                    surface_color,
+                    .powf(0.5);
-                    (wposf.z as f32 - (height - grass_depth))
+                let col = Lerp::lerp(sub_surface_color, surface_color, grass_factor);
-                        .div(grass_depth)
-                        .powf(0.5),
-                );
                 // Surface
                 Some(Block::new(
-                    BlockKind::Normal,
+                    if grass_factor > 0.7 {
+                        BlockKind::Grass
+                    } else {
+                        BlockKind::Normal
+                    },
                     col.map(|e| (e * 255.0) as u8),
                 ))
             } else if (wposf.z as f32) < height + 0.9
@@ -349,7 +346,7 @@ impl<'a> BlockGen<'a> {
                     let field2 = RandomField::new(world.seed + 2);
 
                     Some(Block::new(
-                        BlockKind::Normal,
+                        BlockKind::Rock,
                         stone_col
                             - Rgb::new(
                                 field0.get(wpos) as u8 % 16,
@@ -596,7 +593,7 @@ pub fn block_from_structure(
         StructureBlock::Water => Some(Block::new(BlockKind::Water, Rgb::new(100, 150, 255))),
         StructureBlock::GreenSludge => Some(Block::new(BlockKind::Water, Rgb::new(30, 126, 23))),
         StructureBlock::Acacia => Some(Block::new(
-            BlockKind::Normal,
+            BlockKind::Leaves,
             Lerp::lerp(
                 Rgb::new(15.0, 126.0, 50.0),
                 Rgb::new(30.0, 180.0, 10.0),
@@ -629,7 +626,7 @@ pub fn block_from_structure(
             .map(|e| e as u8),
         )),
         StructureBlock::Mangrove => Some(Block::new(
-            BlockKind::Normal,
+            BlockKind::Leaves,
             Lerp::lerp(Rgb::new(32.0, 56.0, 22.0), Rgb::new(57.0, 69.0, 27.0), lerp)
                 .map(|e| e as u8),
         )),