Mirrored_Repos/veloren
1
0
Fork 0
mirror of https://gitlab.com/veloren/veloren.git synced 2024-08-30 18:12:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reworked explosions. Tweaked staff fireball.

Browse Source
This commit is contained in:
Sam 2020-10-05 21:19:41 -05:00
parent 04dcd012da
commit cbb72363af
15 changed files with 196 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
assets/voxygen/shaders/particle-vert.glsl
View File

@ -173,9 +173,9 @@ void main() {
attr = Attr(
linear_motion(
vec3(0),
vec3(rand4, rand5, rand6) * 40.0 + grav_vel(earth_gravity)
vec3(rand4, rand5, rand6) * 30.0 + grav_vel(earth_gravity)
),
vec3(3.0 + rand0),
vec3(2.0 + rand0),
vec4(vec3(0.6 + rand7 * 0.4), 1),
spin_in_axis(vec3(1,0,0),0)
);

59
common/src/comp/inventory/item/tool.rs
View File

@ -2,7 +2,10 @@
// version in voxygen\src\meta.rs in order to reset save files to being empty
use crate::{
comp::{body::object, projectile, Body, CharacterAbility, Gravity, LightEmitter, Projectile},
comp::{
body::object, projectile, Body, CharacterAbility, Explosion, Gravity, LightEmitter,
Projectile,
},
states::combo_melee,
};
use serde::{Deserialize, Serialize};
@ -382,17 +385,25 @@ impl Tool {
recover_duration: Duration::from_millis(50),
projectile: Projectile {
hit_solid: vec![
projectile::Effect::Explode {
power: 1.4 * self.base_power(),
percent_damage: 0.2,
},
projectile::Effect::Explode(Explosion {
radius: 3.0 + 2.5 * self.base_power(),
max_damage: (50.0 * self.base_power()) as u32,
min_damage: (20.0 * self.base_power()) as u32,
max_heal: (140.0 * self.base_power()) as u32,
min_heal: (50.0 * self.base_power()) as u32,
terrain_destruction_power: 0.0,
}),
projectile::Effect::Vanish,
],
hit_entity: vec![
projectile::Effect::Explode {
power: 1.4 * self.base_power(),
percent_damage: 0.2,
},
projectile::Effect::Explode(Explosion {
radius: 3.0 + 2.5 * self.base_power(),
max_damage: (50.0 * self.base_power()) as u32,
min_damage: (20.0 * self.base_power()) as u32,
max_heal: (140.0 * self.base_power()) as u32,
min_heal: (50.0 * self.base_power()) as u32,
terrain_destruction_power: 0.0,
}),
projectile::Effect::Vanish,
],
time_left: Duration::from_secs(20),
@ -416,30 +427,38 @@ impl Tool {
recover_duration: Duration::from_millis(50),
projectile: Projectile {
hit_solid: vec![
projectile::Effect::Explode {
power: 1.4 * self.base_power(),
percent_damage: 1.0,
},
projectile::Effect::Explode(Explosion {
radius: 4.0,
max_damage: (100.0 * self.base_power()) as u32,
min_damage: (40.0 * self.base_power()) as u32,
max_heal: 0,
min_heal: 0,
terrain_destruction_power: 0.0,
}),
projectile::Effect::Vanish,
],
hit_entity: vec![
projectile::Effect::Explode {
power: 1.4 * self.base_power(),
percent_damage: 1.0,
},
projectile::Effect::Explode(Explosion {
radius: 4.0,
max_damage: (100.0 * self.base_power()) as u32,
min_damage: (40.0 * self.base_power()) as u32,
max_heal: 0,
min_heal: 0,
terrain_destruction_power: 0.0,
}),
projectile::Effect::Vanish,
],
time_left: Duration::from_secs(20),
owner: None,
ignore_group: true,
},
projectile_body: Body::Object(object::Body::BoltFireBig),
projectile_body: Body::Object(object::Body::BoltFire),
projectile_light: Some(LightEmitter {
col: (1.0, 0.75, 0.11).into(),
..Default::default()
}),
projectile_gravity: Some(Gravity(0.5)),
projectile_speed: 40.0,
projectile_gravity: Some(Gravity(0.3)),
projectile_speed: 60.0,
},
BasicBeam {
energy_cost: 0,

2
common/src/comp/mod.rs
View File

@ -53,7 +53,7 @@ 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, MAX_MOUNT_RANGE_SQR};
pub use projectile::Projectile;
pub use projectile::{Explosion, Projectile};
pub use shockwave::Shockwave;
pub use skills::{Skill, SkillGroup, SkillGroupType, SkillSet};
pub use stats::{Exp, HealthChange, HealthSource, Level, Stats};

12
common/src/comp/projectile.rs
View File

@ -9,12 +9,22 @@ pub enum Effect {
Damage(i32),
Knockback(f32),
RewardEnergy(u32),
Explode { power: f32, percent_damage: f32 },
Explode(Explosion),
Vanish,
Stick,
Possess,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Explosion {
pub radius: f32,
pub max_damage: u32,
pub min_damage: u32,
pub max_heal: u32,
pub min_heal: u32,
pub terrain_destruction_power: f32,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Projectile {
// TODO: use SmallVec for these effects

3
common/src/event.rs
View File

@ -29,11 +29,10 @@ pub enum LocalEvent {
pub enum ServerEvent {
Explosion {
pos: Vec3<f32>,
power: f32,
explosion: comp::Explosion,
owner: Option<Uid>,
friendly_damage: bool,
reagent: Option<Reagent>,
percent_damage: f32,
},
Damage {
uid: Uid,

2
common/src/outcome.rs
View File

@ -13,8 +13,8 @@ pub enum Outcome {
Explosion {
pos: Vec3<f32>,
power: f32,
radius: f32,
reagent: Option<Reagent>, // How can we better define this?
percent_damage: f32,
},
ProjectileShot {
pos: Vec3<f32>,

2
common/src/states/mod.rs
View File

@ -12,11 +12,11 @@ pub mod dash_melee;
pub mod equipping;
pub mod glide;
pub mod glide_wield;
pub mod shockwave;
pub mod idle;
pub mod leap_melee;
pub mod repeater_ranged;
pub mod roll;
pub mod shockwave;
pub mod sit;
pub mod sneak;
pub mod spin_melee;

40
common/src/sys/projectile.rs
View File

@ -153,17 +153,15 @@ impl<'a> System<'a> for Sys {
energy_mut.change_by(energy as i32, EnergySource::HitEnemy);
}
},
projectile::Effect::Explode {
power,
percent_damage,
} => server_emitter.emit(ServerEvent::Explosion {
pos: pos.0,
power,
owner: projectile.owner,
friendly_damage: false,
reagent: None,
percent_damage,
}),
projectile::Effect::Explode(e) => {
server_emitter.emit(ServerEvent::Explosion {
pos: pos.0,
explosion: e,
owner: projectile.owner,
friendly_damage: false,
reagent: None,
})
},
projectile::Effect::Vanish => server_emitter.emit(ServerEvent::Destroy {
entity,
cause: HealthSource::World,
@ -184,17 +182,15 @@ impl<'a> System<'a> for Sys {
if physics.on_wall.is_some() || physics.on_ground || physics.on_ceiling {
for effect in projectile.hit_solid.drain(..) {
match effect {
projectile::Effect::Explode {
power,
percent_damage,
} => server_emitter.emit(ServerEvent::Explosion {
pos: pos.0,
power,
owner: projectile.owner,
friendly_damage: false,
reagent: None,
percent_damage,
}),
projectile::Effect::Explode(e) => {
server_emitter.emit(ServerEvent::Explosion {
pos: pos.0,
explosion: e,
owner: projectile.owner,
friendly_damage: false,
reagent: None,
})
},
projectile::Effect::Vanish => server_emitter.emit(ServerEvent::Destroy {
entity,
cause: HealthSource::World,

10
server/src/cmd.rs
View File

@ -1129,11 +1129,17 @@ fn handle_explosion(
ecs.read_resource::<EventBus<ServerEvent>>()
.emit_now(ServerEvent::Explosion {
pos: pos.0,
power,
explosion: comp::Explosion {
radius: 3.0 * power,
max_damage: (100.0 * power) as u32,
min_damage: 0,
max_heal: 0,
min_heal: 0,
terrain_destruction_power: power,
},
owner: ecs.read_storage::<Uid>().get(target).copied(),
friendly_damage: true,
reagent: None,
percent_damage: 1.0,
})
},
None => server.notify_client(

137
server/src/events/entity_manipulation.rs
View File

@ -487,23 +487,30 @@ pub fn handle_respawn(server: &Server, entity: EcsEntity) {
pub fn handle_explosion(
server: &Server,
pos: Vec3<f32>,
power: f32,
explosion: comp::Explosion,
owner: Option<Uid>,
friendly_damage: bool,
reagent: Option<Reagent>,
percent_damage: f32,
) {
// Go through all other entities
let hit_range = 3.0 * power;
let ecs = &server.state.ecs();
let outcome_power = if explosion.max_heal > explosion.max_damage {
-explosion
.terrain_destruction_power
.min(explosion.max_heal as f32 / -100.0)
} else {
explosion
.terrain_destruction_power
.max(explosion.max_damage as f32 / 100.0)
};
// Add an outcome
ecs.write_resource::<Vec<Outcome>>()
.push(Outcome::Explosion {
pos,
power,
power: outcome_power,
radius: explosion.radius,
reagent,
percent_damage,
});
let owner_entity = owner.and_then(|uid| {
ecs.read_resource::<UidAllocator>()
@ -525,7 +532,7 @@ pub fn handle_explosion(
// Check if it is a hit
if !stats_b.is_dead
// RADIUS
&& distance_squared < hit_range.powi(2)
&& distance_squared < explosion.radius.powi(2)
{
// See if entities are in the same group
let mut same_group = owner_entity
@ -538,8 +545,8 @@ pub fn handle_explosion(
}
// Don't heal if outside group
// Don't damage in the same group
let is_damage = (friendly_damage || !same_group) && (percent_damage > 0.0);
let is_heal = same_group && (percent_damage < 1.0);
let is_damage = (friendly_damage || !same_group) && (explosion.max_damage > 0);
let is_heal = same_group && (explosion.max_heal > 0);
if !is_heal && !is_damage {
continue;
}
@ -550,11 +557,13 @@ pub fn handle_explosion(
} else {
DamageSource::Explosion
};
let strength = (1.0 - distance_squared / hit_range.powi(2)) * power * 130.0;
let strength = 1.0 - distance_squared / explosion.radius.powi(2);
let healthchange = if is_heal {
strength * (1.0 - percent_damage)
explosion.min_heal as f32
+ (explosion.max_heal - explosion.min_heal) as f32 * strength
} else {
-strength * percent_damage
-(explosion.min_damage as f32
+ (explosion.max_damage - explosion.min_damage) as f32 * strength)
};
let mut damage = Damage {
@ -585,66 +594,64 @@ pub fn handle_explosion(
const RAYS: usize = 500;
if percent_damage > 0.9 {
// Color terrain
let mut touched_blocks = Vec::new();
let color_range = power * 2.7;
for _ in 0..RAYS {
let dir = Vec3::new(
rand::random::<f32>() - 0.5,
rand::random::<f32>() - 0.5,
rand::random::<f32>() - 0.5,
)
.normalized();
// Color terrain
let mut touched_blocks = Vec::new();
let color_range = explosion.terrain_destruction_power * 2.7;
for _ in 0..RAYS {
let dir = Vec3::new(
rand::random::<f32>() - 0.5,
rand::random::<f32>() - 0.5,
rand::random::<f32>() - 0.5,
)
.normalized();
let _ = ecs
.read_resource::<TerrainGrid>()
.ray(pos, pos + dir * color_range)
// TODO: Faster RNG
.until(|_| rand::random::<f32>() < 0.05)
.for_each(|_: &Block, pos| touched_blocks.push(pos))
.cast();
}
let _ = ecs
.read_resource::<TerrainGrid>()
.ray(pos, pos + dir * color_range)
// TODO: Faster RNG
.until(|_| rand::random::<f32>() < 0.05)
.for_each(|_: &Block, pos| touched_blocks.push(pos))
.cast();
}
let terrain = ecs.read_resource::<TerrainGrid>();
let mut block_change = ecs.write_resource::<BlockChange>();
for block_pos in touched_blocks {
if let Ok(block) = terrain.get(block_pos) {
let diff2 = block_pos.map(|b| b as f32).distance_squared(pos);
let fade = (1.0 - diff2 / color_range.powi(2)).max(0.0);
if let Some(mut color) = block.get_color() {
let r = color[0] as f32 + (fade * (color[0] as f32 * 0.5 - color[0] as f32));
let g = color[1] as f32 + (fade * (color[1] as f32 * 0.3 - color[1] as f32));
let b = color[2] as f32 + (fade * (color[2] as f32 * 0.3 - color[2] as f32));
color[0] = r as u8;
color[1] = g as u8;
color[2] = b as u8;
block_change.set(block_pos, Block::new(block.kind(), color));
}
let terrain = ecs.read_resource::<TerrainGrid>();
let mut block_change = ecs.write_resource::<BlockChange>();
for block_pos in touched_blocks {
if let Ok(block) = terrain.get(block_pos) {
let diff2 = block_pos.map(|b| b as f32).distance_squared(pos);
let fade = (1.0 - diff2 / color_range.powi(2)).max(0.0);
if let Some(mut color) = block.get_color() {
let r = color[0] as f32 + (fade * (color[0] as f32 * 0.5 - color[0] as f32));
let g = color[1] as f32 + (fade * (color[1] as f32 * 0.3 - color[1] as f32));
let b = color[2] as f32 + (fade * (color[2] as f32 * 0.3 - color[2] as f32));
color[0] = r as u8;
color[1] = g as u8;
color[2] = b as u8;
block_change.set(block_pos, Block::new(block.kind(), color));
}
}
}
// Destroy terrain
for _ in 0..RAYS {
let dir = Vec3::new(
rand::random::<f32>() - 0.5,
rand::random::<f32>() - 0.5,
rand::random::<f32>() - 0.15,
)
.normalized();
// Destroy terrain
for _ in 0..RAYS {
let dir = Vec3::new(
rand::random::<f32>() - 0.5,
rand::random::<f32>() - 0.5,
rand::random::<f32>() - 0.15,
)
.normalized();
let terrain = ecs.read_resource::<TerrainGrid>();
let _ = terrain
.ray(pos, pos + dir * power)
// TODO: Faster RNG
.until(|block| block.is_liquid() || rand::random::<f32>() < 0.05)
.for_each(|block: &Block, pos| {
if block.is_explodable() {
block_change.set(pos, block.into_vacant());
}
})
.cast();
}
let terrain = ecs.read_resource::<TerrainGrid>();
let _ = terrain
.ray(pos, pos + dir * explosion.terrain_destruction_power)
// TODO: Faster RNG
.until(|block| block.is_liquid() || rand::random::<f32>() < 0.05)
.for_each(|block: &Block, pos| {
if block.is_explodable() {
block_change.set(pos, block.into_vacant());
}
})
.cast();
}
}

13
server/src/events/mod.rs
View File

@ -56,20 +56,11 @@ impl Server {
match event {
ServerEvent::Explosion {
pos,
power,
explosion,
owner,
friendly_damage,
reagent,
percent_damage,
} => handle_explosion(
&self,
pos,
power,
owner,
friendly_damage,
reagent,
percent_damage,
),
} => handle_explosion(&self, pos, explosion, owner, friendly_damage, reagent),
ServerEvent::Shoot {
entity,
dir,

22
server/src/sys/object.rs
View File

@ -1,5 +1,5 @@
use common::{
comp::{HealthSource, Object, PhysicsState, Pos, Vel},
comp::{self, HealthSource, Object, PhysicsState, Pos, Vel},
event::{EventBus, ServerEvent},
span,
state::DeltaTime,
@ -46,11 +46,17 @@ impl<'a> System<'a> for Sys {
});
server_emitter.emit(ServerEvent::Explosion {
pos: pos.0,
power: 4.0,
explosion: comp::Explosion {
radius: 12.0,
max_damage: 500,
min_damage: 100,
max_heal: 0,
min_heal: 0,
terrain_destruction_power: 4.0,
},
owner: *owner,
friendly_damage: true,
reagent: None,
percent_damage: 1.0,
});
}
},
@ -62,11 +68,17 @@ impl<'a> System<'a> for Sys {
});
server_emitter.emit(ServerEvent::Explosion {
pos: pos.0,
power: 4.0,
explosion: comp::Explosion {
radius: 12.0,
max_damage: 50,
min_damage: 10,
max_heal: 0,
min_heal: 0,
terrain_destruction_power: 4.0,
},
owner: *owner,
friendly_damage: true,
reagent: Some(*reagent),
percent_damage: 1.0,
});
}
},

2
voxygen/src/audio/sfx/mod.rs
View File

@ -286,7 +286,7 @@ impl SfxMgr {
// TODO: from sfx config?
"voxygen.audio.sfx.explosion",
*pos,
Some((*power / 2.5).min(1.5)),
Some((power.abs() / 2.5).min(1.5)),
);
},
Outcome::ProjectileShot { pos, body, .. } => {

6
voxygen/src/scene/mod.rs
View File

@ -389,8 +389,8 @@ impl Scene {
Outcome::Explosion {
pos,
power,
radius: _,
reagent,
percent_damage,
} => self.event_lights.push(EventLight {
light: Light::new(
*pos,
@ -401,14 +401,14 @@ impl Scene {
Some(Reagent::Red) => Rgb::new(1.0, 0.0, 0.0),
Some(Reagent::Yellow) => Rgb::new(1.0, 1.0, 0.0),
None => {
if *percent_damage < 0.5 {
if *power < 0.0 {
Rgb::new(0.0, 1.0, 0.0)
} else {
Rgb::new(1.0, 0.5, 0.0)
}
},
},
*power
power.abs()
* match reagent {
Some(_) => 5.0,
None => 2.5,

33
voxygen/src/scene/particle.rs
View File

@ -58,19 +58,18 @@ impl ParticleMgr {
Outcome::Explosion {
pos,
power,
radius,
reagent,
percent_damage,
} => {
if *percent_damage < 0.5 {
if *power < 0.0 {
self.particles.resize_with(
self.particles.len() + (200.0 * power) as usize,
self.particles.len() + (200.0 * power.abs()) as usize,
|| {
Particle::new(
Duration::from_secs(1),
time,
ParticleMode::EnergyNature,
*pos + Vec3::<f32>::zero()
.map(|_| rng.gen_range(-3.0, 3.0) * power),
*pos + Vec3::<f32>::zero().map(|_| rng.gen_range(-radius, radius)),
)
},
);
@ -101,8 +100,7 @@ impl ParticleMgr {
Duration::from_secs(4),
time,
ParticleMode::CampfireSmoke,
*pos + Vec2::<f32>::zero()
.map(|_| rng.gen_range(-1.0, 1.0) * power),
*pos + Vec2::<f32>::zero().map(|_| rng.gen_range(-radius, radius)),
)
},
);
@ -371,11 +369,19 @@ impl ParticleMgr {
let (from, to) = (Vec3::<f32>::unit_z(), particle_ori);
let m = Mat3::<f32>::rotation_from_to_3d(from, to);
self.particles.resize_with(
self.particles.len() + 2 * usize::from(self.scheduler.heartbeats(Duration::from_millis(1))),
self.particles.len()
+ 2 * usize::from(
self.scheduler.heartbeats(Duration::from_millis(1)),
),
|| {
let phi: f32 = rng.gen_range(0.0, b.static_data.max_angle.to_radians());
let phi: f32 =
rng.gen_range(0.0, b.static_data.max_angle.to_radians());
let theta: f32 = rng.gen_range(0.0, 2.0 * PI);
let offset_z = Vec3::new(phi.sin() * theta.cos(), phi.sin() * theta.sin(), phi.cos());
let offset_z = Vec3::new(
phi.sin() * theta.cos(),
phi.sin() * theta.sin(),
phi.cos(),
);
let random_ori = offset_z * m * Vec3::new(-1.0, -1.0, 1.0);
Particle::new_beam(
b.static_data.beam_duration,
@ -559,8 +565,8 @@ impl ParticleMgr {
for d in 0..((distance / scale) as i32) {
let arc_position = theta - radians / 2.0 + dtheta * d as f32 * scale;
let position =
pos.0 + distance * Vec3::new(arc_position.cos(), arc_position.sin(), 0.0);
let position = pos.0
+ distance * Vec3::new(arc_position.cos(), arc_position.sin(), 0.0);
let position_snapped = ((position / scale).floor() + 0.5) * scale;
@ -573,7 +579,6 @@ impl ParticleMgr {
}
}
} else {
}
}
}
@ -757,4 +762,4 @@ impl Particle {
instance: ParticleInstance::new_beam(time, lifespan.as_secs_f32(), mode, pos1, pos2),
}
}
}
}