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
aea4aca057
veloren/server/src/state_ext.rs
Joshua Yanovski 986d104faa Update Rust toolchain.
2022-09-08 15:43:53 -07:00

1077 lines
42 KiB
Rust
Raw Blame History

use crate::{
automod::AutoMod,
client::Client,
events::{self, update_map_markers},
persistence::PersistedComponents,
pet::restore_pet,
presence::{Presence, RepositionOnChunkLoad},
settings::Settings,
sys::sentinel::DeletedEntities,
wiring, BattleModeBuffer, SpawnPoint,
};
use common::{
calendar::Calendar,
character::CharacterId,
combat,
combat::DamageContributor,
comp::{
self,
item::MaterialStatManifest,
skills::{GeneralSkill, Skill},
ChatType, Group, Inventory, Item, Player, Poise,
},
effect::Effect,
link::{Link, LinkHandle},
mounting::Mounting,
resources::{Time, TimeOfDay},
slowjob::SlowJobPool,
uid::{Uid, UidAllocator},
ViewDistances,
};
use common_net::{
msg::{CharacterInfo, PlayerListUpdate, PresenceKind, ServerGeneral},
sync::WorldSyncExt,
};
use common_state::State;
use rand::prelude::*;
use specs::{
saveload::MarkerAllocator, Builder, Entity as EcsEntity, EntityBuilder as EcsEntityBuilder,
Join, WorldExt,
};
use std::time::{Duration, Instant};
use tracing::{trace, warn};
use vek::*;
pub trait StateExt {
/// Updates a component associated with the entity based on the `Effect`
fn apply_effect(&self, entity: EcsEntity, effect: Effect, source: Option<Uid>);
/// Build a non-player character
fn create_npc(
&mut self,
pos: comp::Pos,
stats: comp::Stats,
skill_set: comp::SkillSet,
health: Option<comp::Health>,
poise: Poise,
inventory: Inventory,
body: comp::Body,
) -> EcsEntityBuilder;
/// Build a static object entity
fn create_object(&mut self, pos: comp::Pos, object: comp::object::Body) -> EcsEntityBuilder;
fn create_item_drop(&mut self, pos: comp::Pos, item: Item) -> EcsEntityBuilder;
fn create_ship<F: FnOnce(comp::ship::Body) -> comp::Collider>(
&mut self,
pos: comp::Pos,
ship: comp::ship::Body,
make_collider: F,
mountable: bool,
) -> EcsEntityBuilder;
/// Build a projectile
fn create_projectile(
&mut self,
pos: comp::Pos,
vel: comp::Vel,
body: comp::Body,
projectile: comp::Projectile,
) -> EcsEntityBuilder;
/// Build a shockwave entity
fn create_shockwave(
&mut self,
properties: comp::shockwave::Properties,
pos: comp::Pos,
ori: comp::Ori,
) -> EcsEntityBuilder;
/// Build a beam entity
fn create_beam(
&mut self,
properties: comp::beam::Properties,
pos: comp::Pos,
ori: comp::Ori,
) -> EcsEntityBuilder;
/// Creates a safezone
fn create_safezone(&mut self, range: Option<f32>, pos: comp::Pos) -> EcsEntityBuilder;
fn create_wiring(
&mut self,
pos: comp::Pos,
object: comp::object::Body,
wiring_element: wiring::WiringElement,
) -> EcsEntityBuilder;
// NOTE: currently only used for testing
/// Queues chunk generation in the view distance of the persister, this
/// entity must be built before those chunks are received (the builder
/// borrows the ecs world so that is kind of impossible in practice)
fn create_persister(
&mut self,
pos: comp::Pos,
view_distance: u32,
world: &std::sync::Arc<world::World>,
index: &world::IndexOwned,
) -> EcsEntityBuilder;
/// Insert common/default components for a new character joining the server
fn initialize_character_data(
&mut self,
entity: EcsEntity,
character_id: CharacterId,
view_distances: ViewDistances,
);
/// Insert common/default components for a new spectator joining the server
fn initialize_spectator_data(&mut self, entity: EcsEntity, view_distances: ViewDistances);
/// Update the components associated with the entity's current character.
/// Performed after loading component data from the database
fn update_character_data(&mut self, entity: EcsEntity, components: PersistedComponents);
/// Iterates over registered clients and send each `ServerMsg`
fn validate_chat_msg(
&self,
player: EcsEntity,
chat_type: &comp::ChatType<comp::Group>,
msg: &str,
) -> bool;
fn send_chat(&self, msg: comp::UnresolvedChatMsg);
fn notify_players(&self, msg: ServerGeneral);
fn notify_in_game_clients(&self, msg: ServerGeneral);
/// Create a new link between entities (see [`common::mounting`] for an
/// example).
fn link<L: Link>(&mut self, link: L) -> Result<(), L::Error>;
/// Maintain active links between entities
fn maintain_links(&mut self);
/// Delete an entity, recording the deletion in [`DeletedEntities`]
fn delete_entity_recorded(
&mut self,
entity: EcsEntity,
) -> Result<(), specs::error::WrongGeneration>;
}
impl StateExt for State {
fn apply_effect(&self, entity: EcsEntity, effects: Effect, source: Option<Uid>) {
let msm = self.ecs().read_resource::<MaterialStatManifest>();
match effects {
Effect::Health(change) => {
self.ecs()
.write_storage::<comp::Health>()
.get_mut(entity)
.map(|mut health| health.change_by(change));
},
Effect::Damage(damage) => {
let inventories = self.ecs().read_storage::<Inventory>();
let stats = self.ecs().read_storage::<comp::Stats>();
let groups = self.ecs().read_storage::<Group>();
let damage_contributor = source.and_then(|uid| {
self.ecs().entity_from_uid(uid.0).map(|attacker_entity| {
DamageContributor::new(uid, groups.get(attacker_entity).cloned())
})
});
let time = self.ecs().read_resource::<Time>();
let change = damage.calculate_health_change(
combat::Damage::compute_damage_reduction(
Some(damage),
inventories.get(entity),
stats.get(entity),
&msm,
),
damage_contributor,
false,
0.0,
1.0,
*time,
random(),
);
self.ecs()
.write_storage::<comp::Health>()
.get_mut(entity)
.map(|mut health| health.change_by(change));
},
Effect::Poise(poise) => {
let inventories = self.ecs().read_storage::<Inventory>();
let change = Poise::apply_poise_reduction(poise, inventories.get(entity), &msm);
// Check to make sure the entity is not already stunned
if let Some(character_state) = self
.ecs()
.read_storage::<comp::CharacterState>()
.get(entity)
{
if !character_state.is_stunned() {
let groups = self.ecs().read_storage::<Group>();
let damage_contributor = source.and_then(|uid| {
self.ecs().entity_from_uid(uid.0).map(|attacker_entity| {
DamageContributor::new(uid, groups.get(attacker_entity).cloned())
})
});
let time = self.ecs().read_resource::<Time>();
let poise_change = comp::PoiseChange {
amount: change,
impulse: Vec3::zero(),
cause: None,
by: damage_contributor,
time: *time,
};
self.ecs()
.write_storage::<Poise>()
.get_mut(entity)
.map(|mut poise| poise.change(poise_change));
}
}
},
Effect::Buff(buff) => {
self.ecs()
.write_storage::<comp::Buffs>()
.get_mut(entity)
.map(|mut buffs| {
buffs.insert(comp::Buff::new(
buff.kind,
buff.data,
buff.cat_ids,
comp::BuffSource::Item,
))
});
},
}
}
fn create_npc(
&mut self,
pos: comp::Pos,
stats: comp::Stats,
skill_set: comp::SkillSet,
health: Option<comp::Health>,
poise: Poise,
inventory: Inventory,
body: comp::Body,
) -> EcsEntityBuilder {
self.ecs_mut()
.create_entity_synced()
.with(pos)
.with(comp::Vel(Vec3::zero()))
.with(
comp::Ori::from_unnormalized_vec(Vec3::new(
thread_rng().gen_range(-1.0..1.0),
thread_rng().gen_range(-1.0..1.0),
0.0,
))
.unwrap_or_default(),
)
.with(body.mass())
.with(body.density())
.with(body.collider())
.with(comp::Controller::default())
.with(body)
.with(comp::Energy::new(
body,
skill_set
.skill_level(Skill::General(GeneralSkill::EnergyIncrease))
.unwrap_or(0),
))
.with(stats)
.with(comp::ActiveAbilities::default())
.with(skill_set)
.maybe_with(health)
.with(poise)
.with(comp::Alignment::Npc)
.with(comp::CharacterState::default())
.with(inventory)
.with(comp::Buffs::default())
.with(comp::Combo::default())
.with(comp::Auras::default())
}
fn create_object(&mut self, pos: comp::Pos, object: comp::object::Body) -> EcsEntityBuilder {
let body = comp::Body::Object(object);
self.ecs_mut()
.create_entity_synced()
.with(pos)
.with(comp::Vel(Vec3::zero()))
.with(comp::Ori::default())
.with(body.mass())
.with(body.density())
.with(body.collider())
.with(body)
}
fn create_item_drop(&mut self, pos: comp::Pos, item: Item) -> EcsEntityBuilder {
let item_drop = comp::item_drop::Body::from(&item);
let body = comp::Body::ItemDrop(item_drop);
self.ecs_mut()
.create_entity_synced()
.with(item)
.with(pos)
.with(comp::Vel(Vec3::zero()))
.with(item_drop.orientation(&mut thread_rng()))
.with(item_drop.mass())
.with(item_drop.density())
.with(body.collider())
.with(body)
}
fn create_ship<F: FnOnce(comp::ship::Body) -> comp::Collider>(
&mut self,
pos: comp::Pos,
ship: comp::ship::Body,
make_collider: F,
mountable: bool,
) -> EcsEntityBuilder {
let body = comp::Body::Ship(ship);
let builder = self
.ecs_mut()
.create_entity_synced()
.with(pos)
.with(comp::Vel(Vec3::zero()))
.with(comp::Ori::default())
.with(body.mass())
.with(body.density())
.with(make_collider(ship))
.with(body)
.with(comp::Scale(comp::ship::AIRSHIP_SCALE))
.with(comp::Controller::default())
.with(Inventory::with_empty())
.with(comp::CharacterState::default())
// TODO: some of these are required in order for the character_behavior system to
// recognize a possesed airship; that system should be refactored to use `.maybe()`
.with(comp::Energy::new(ship.into(), 0))
.with(comp::Stats::new("Airship".to_string()))
.with(comp::SkillSet::default())
.with(comp::ActiveAbilities::default())
.with(comp::Combo::default());
if mountable {
// TODO: Re-add mounting check
}
builder
}
fn create_projectile(
&mut self,
pos: comp::Pos,
vel: comp::Vel,
body: comp::Body,
projectile: comp::Projectile,
) -> EcsEntityBuilder {
let mut projectile_base = self
.ecs_mut()
.create_entity_synced()
.with(pos)
.with(vel)
.with(comp::Ori::from_unnormalized_vec(vel.0).unwrap_or_default())
.with(body.mass())
.with(body.density());
if projectile.is_sticky {
projectile_base = projectile_base.with(comp::Sticky)
}
if projectile.is_point {
projectile_base = projectile_base.with(comp::Collider::Point)
} else {
projectile_base = projectile_base.with(body.collider())
}
projectile_base.with(projectile).with(body)
}
fn create_shockwave(
&mut self,
properties: comp::shockwave::Properties,
pos: comp::Pos,
ori: comp::Ori,
) -> EcsEntityBuilder {
self.ecs_mut()
.create_entity_synced()
.with(pos)
.with(ori)
.with(comp::Shockwave {
properties,
creation: None,
})
.with(comp::ShockwaveHitEntities {
hit_entities: Vec::<Uid>::new(),
})
}
fn create_beam(
&mut self,
properties: comp::beam::Properties,
pos: comp::Pos,
ori: comp::Ori,
) -> EcsEntityBuilder {
self.ecs_mut()
.create_entity_synced()
.with(pos)
.with(ori)
.with(comp::BeamSegment {
properties,
creation: None,
})
}
fn create_safezone(&mut self, range: Option<f32>, pos: comp::Pos) -> EcsEntityBuilder {
use comp::{
aura::{Aura, AuraKind, AuraTarget, Auras},
buff::{BuffCategory, BuffData, BuffKind, BuffSource},
};
self.ecs_mut()
.create_entity_synced()
.with(pos)
.with(Auras::new(vec![Aura::new(
AuraKind::Buff {
kind: BuffKind::Invulnerability,
data: BuffData::new(1.0, Some(Duration::from_secs(1))),
category: BuffCategory::Natural,
source: BuffSource::World,
},
range.unwrap_or(100.0),
None,
AuraTarget::All,
)]))
}
fn create_wiring(
&mut self,
pos: comp::Pos,
object: comp::object::Body,
wiring_element: wiring::WiringElement,
) -> EcsEntityBuilder {
self.ecs_mut()
.create_entity_synced()
.with(pos)
.with(comp::Vel(Vec3::zero()))
.with(comp::Ori::default())
.with({
let body: comp::Body = object.into();
body.collider()
})
.with(comp::Body::Object(object))
.with(comp::Mass(100.0))
// .with(comp::Sticky)
.with(wiring_element)
.with(comp::LightEmitter {
col: Rgb::new(0.0, 0.0, 0.0),
strength: 2.0,
flicker: 1.0,
animated: true,
})
}
// NOTE: currently only used for testing
/// Queues chunk generation in the view distance of the persister, this
/// entity must be built before those chunks are received (the builder
/// borrows the ecs world so that is kind of impossible in practice)
fn create_persister(
&mut self,
pos: comp::Pos,
view_distance: u32,
world: &std::sync::Arc<world::World>,
index: &world::IndexOwned,
) -> EcsEntityBuilder {
use common::{terrain::TerrainChunkSize, vol::RectVolSize};
use std::sync::Arc;
// Request chunks
{
let ecs = self.ecs();
let slow_jobs = ecs.write_resource::<SlowJobPool>();
let mut chunk_generator =
ecs.write_resource::<crate::chunk_generator::ChunkGenerator>();
let chunk_pos = self.terrain().pos_key(pos.0.map(|e| e as i32));
(-(view_distance as i32)..view_distance as i32 + 1)
.flat_map(|x| {
(-(view_distance as i32)..view_distance as i32 + 1).map(move |y| Vec2::new(x, y))
})
.map(|offset| offset + chunk_pos)
// Filter chunks outside the view distance
// Note: calculation from client chunk request filtering
.filter(|chunk_key| {
pos.0.xy().map(|e| e as f64).distance(
chunk_key.map(|e| e as f64 + 0.5) * TerrainChunkSize::RECT_SIZE.map(|e| e as f64),
) < (view_distance as f64 - 1.0 + 2.5 * 2.0_f64.sqrt())
* TerrainChunkSize::RECT_SIZE.x as f64
})
.for_each(|chunk_key| {
#[cfg(feature = "worldgen")]
{
let time = (*ecs.read_resource::<TimeOfDay>(), (*ecs.read_resource::<Calendar>()).clone());
chunk_generator.generate_chunk(None, chunk_key, &slow_jobs, Arc::clone(world), index.clone(), time);
}
});
}
self.ecs_mut()
.create_entity_synced()
.with(pos)
.with(Presence::new(
ViewDistances {
terrain: view_distance,
entity: view_distance,
},
PresenceKind::Spectator,
))
}
fn initialize_character_data(
&mut self,
entity: EcsEntity,
character_id: CharacterId,
view_distances: ViewDistances,
) {
let spawn_point = self.ecs().read_resource::<SpawnPoint>().0;
if let Some(player_uid) = self.read_component_copied::<Uid>(entity) {
// NOTE: By fetching the player_uid, we validated that the entity exists, and we
// call nothing that can delete it in any of the subsequent
// commands, so we can assume that all of these calls succeed,
// justifying ignoring the result of insertion.
self.write_component_ignore_entity_dead(entity, comp::Controller::default());
self.write_component_ignore_entity_dead(entity, comp::Pos(spawn_point));
self.write_component_ignore_entity_dead(entity, comp::Vel(Vec3::zero()));
self.write_component_ignore_entity_dead(entity, comp::Ori::default());
self.write_component_ignore_entity_dead(entity, comp::Collider::CapsulePrism {
p0: Vec2::zero(),
p1: Vec2::zero(),
radius: 0.4,
z_min: 0.0,
z_max: 1.75,
});
self.write_component_ignore_entity_dead(entity, comp::CharacterState::default());
self.write_component_ignore_entity_dead(entity, comp::Alignment::Owned(player_uid));
self.write_component_ignore_entity_dead(entity, comp::Buffs::default());
self.write_component_ignore_entity_dead(entity, comp::Auras::default());
self.write_component_ignore_entity_dead(entity, comp::Combo::default());
// Make sure physics components are updated
self.write_component_ignore_entity_dead(entity, comp::ForceUpdate::forced());
self.write_component_ignore_entity_dead(
entity,
Presence::new(view_distances, PresenceKind::Character(character_id)),
);
// Tell the client its request was successful.
if let Some(client) = self.ecs().read_storage::<Client>().get(entity) {
client.send_fallible(ServerGeneral::CharacterSuccess);
}
}
}
fn initialize_spectator_data(&mut self, entity: EcsEntity, view_distances: ViewDistances) {
let spawn_point = self.ecs().read_resource::<SpawnPoint>().0;
if self.read_component_copied::<Uid>(entity).is_some() {
// NOTE: By fetching the player_uid, we validated that the entity exists, and we
// call nothing that can delete it in any of the subsequent
// commands, so we can assume that all of these calls succeed,
// justifying ignoring the result of insertion.
self.write_component_ignore_entity_dead(entity, comp::Pos(spawn_point));
// Make sure physics components are updated
self.write_component_ignore_entity_dead(entity, comp::ForceUpdate::forced());
self.write_component_ignore_entity_dead(
entity,
Presence::new(view_distances, PresenceKind::Spectator),
);
// Tell the client its request was successful.
if let Some(client) = self.ecs().read_storage::<Client>().get(entity) {
client.send_fallible(ServerGeneral::SpectatorSuccess(spawn_point));
}
}
}
fn update_character_data(&mut self, entity: EcsEntity, components: PersistedComponents) {
let PersistedComponents {
body,
stats,
skill_set,
inventory,
waypoint,
pets,
active_abilities,
map_marker,
} = components;
if let Some(player_uid) = self.read_component_copied::<Uid>(entity) {
// Notify clients of a player list update
self.notify_players(ServerGeneral::PlayerListUpdate(
PlayerListUpdate::SelectedCharacter(player_uid, CharacterInfo {
name: String::from(&stats.name),
}),
));
// NOTE: By fetching the player_uid, we validated that the entity exists,
// and we call nothing that can delete it in any of the subsequent
// commands, so we can assume that all of these calls succeed,
// justifying ignoring the result of insertion.
self.write_component_ignore_entity_dead(entity, body.collider());
self.write_component_ignore_entity_dead(entity, body);
self.write_component_ignore_entity_dead(entity, body.mass());
self.write_component_ignore_entity_dead(entity, body.density());
let (health_level, energy_level) = (
skill_set
.skill_level(Skill::General(GeneralSkill::HealthIncrease))
.unwrap_or(0),
skill_set
.skill_level(Skill::General(GeneralSkill::EnergyIncrease))
.unwrap_or(0),
);
self.write_component_ignore_entity_dead(entity, comp::Health::new(body, health_level));
self.write_component_ignore_entity_dead(entity, comp::Energy::new(body, energy_level));
self.write_component_ignore_entity_dead(entity, Poise::new(body));
self.write_component_ignore_entity_dead(entity, stats);
self.write_component_ignore_entity_dead(entity, active_abilities);
self.write_component_ignore_entity_dead(entity, skill_set);
self.write_component_ignore_entity_dead(entity, inventory);
self.write_component_ignore_entity_dead(
entity,
comp::InventoryUpdate::new(comp::InventoryUpdateEvent::default()),
);
if let Some(waypoint) = waypoint {
self.write_component_ignore_entity_dead(entity, RepositionOnChunkLoad);
self.write_component_ignore_entity_dead(entity, waypoint);
self.write_component_ignore_entity_dead(entity, comp::Pos(waypoint.get_pos()));
self.write_component_ignore_entity_dead(entity, comp::Vel(Vec3::zero()));
self.write_component_ignore_entity_dead(entity, comp::ForceUpdate::forced());
}
if let Some(map_marker) = map_marker {
self.write_component_ignore_entity_dead(entity, map_marker);
}
let player_pos = self.ecs().read_storage::<comp::Pos>().get(entity).copied();
if let Some(player_pos) = player_pos {
trace!(
"Loading {} pets for player at pos {:?}",
pets.len(),
player_pos
);
// This is the same as wild creatures naturally spawned in the world
const DEFAULT_PET_HEALTH_LEVEL: u16 = 0;
for (pet, body, stats) in pets {
let pet_entity = self
.create_npc(
player_pos,
stats,
comp::SkillSet::default(),
Some(comp::Health::new(body, DEFAULT_PET_HEALTH_LEVEL)),
Poise::new(body),
Inventory::with_empty(),
body,
)
.with(comp::Scale(1.0))
.with(comp::Vel(Vec3::new(0.0, 0.0, 0.0)))
.build();
restore_pet(self.ecs(), pet_entity, entity, pet);
}
} else {
warn!("Player has no pos, cannot load {} pets", pets.len());
}
let presences = self.ecs().read_storage::<Presence>();
let presence = presences.get(entity);
if let Some(Presence {
kind: PresenceKind::Character(char_id),
..
}) = presence
{
let battlemode_buffer = self.ecs().fetch::<BattleModeBuffer>();
let mut players = self.ecs().write_storage::<comp::Player>();
if let Some((mode, change)) = battlemode_buffer.get(char_id) {
if let Some(mut player_info) = players.get_mut(entity) {
player_info.battle_mode = *mode;
player_info.last_battlemode_change = Some(*change);
}
} else {
// FIXME:
// ???
//
// This probably shouldn't exist,
// but without this code, character gets battle_mode from
// another character on this account.
let settings = self.ecs().read_resource::<Settings>();
let mode = settings.gameplay.battle_mode.default_mode();
if let Some(mut player_info) = players.get_mut(entity) {
player_info.battle_mode = mode;
player_info.last_battlemode_change = None;
}
}
}
}
}
fn validate_chat_msg(
&self,
entity: EcsEntity,
chat_type: &comp::ChatType<comp::Group>,
msg: &str,
) -> bool {
let mut automod = self.ecs().write_resource::<AutoMod>();
let client = self.ecs().read_storage::<Client>();
let player = self.ecs().read_storage::<Player>();
let Some(client) = client.get(entity) else { return true };
let Some(player) = player.get(entity) else { return true };
match automod.validate_chat_msg(
player.uuid(),
self.ecs()
.read_storage::<comp::Admin>()
.get(entity)
.map(|a| a.0),
Instant::now(),
chat_type,
msg,
) {
Ok(note) => {
if let Some(note) = note {
let _ = client.send(ServerGeneral::server_msg(
ChatType::CommandInfo,
format!("{}", note),
));
}
true
},
Err(err) => {
let _ = client.send(ServerGeneral::server_msg(
ChatType::CommandError,
format!("{}", err),
));
false
},
}
}
/// Send the chat message to the proper players. Say and region are limited
/// by location. Faction and group are limited by component.
fn send_chat(&self, msg: comp::UnresolvedChatMsg) {
let ecs = self.ecs();
let is_within =
|target, a: &comp::Pos, b: &comp::Pos| a.0.distance_squared(b.0) < target * target;
let group_manager = ecs.read_resource::<comp::group::GroupManager>();
let group_info = msg.get_group().and_then(|g| group_manager.group_info(*g));
let resolved_msg = msg
.clone()
.map_group(|_| group_info.map_or_else(|| "???".to_string(), |i| i.name.clone()));
if msg.chat_type.uid().map_or(true, |sender| {
(*ecs.read_resource::<UidAllocator>())
.retrieve_entity_internal(sender.0)
.map_or(false, |e| {
self.validate_chat_msg(e, &msg.chat_type, &msg.message)
})
}) {
match &msg.chat_type {
comp::ChatType::Offline(_)
| comp::ChatType::CommandInfo
| comp::ChatType::CommandError
| comp::ChatType::Meta
| comp::ChatType::World(_) => {
self.notify_players(ServerGeneral::ChatMsg(resolved_msg))
},
comp::ChatType::Online(u) => {
for (client, uid) in
(&ecs.read_storage::<Client>(), &ecs.read_storage::<Uid>()).join()
{
if uid != u {
client.send_fallible(ServerGeneral::ChatMsg(resolved_msg.clone()));
}
}
},
comp::ChatType::Tell(from, to) => {
for (client, uid) in
(&ecs.read_storage::<Client>(), &ecs.read_storage::<Uid>()).join()
{
if uid == from || uid == to {
client.send_fallible(ServerGeneral::ChatMsg(resolved_msg.clone()));
}
}
},
comp::ChatType::Kill(kill_source, uid) => {
let comp::chat::GenericChatMsg { message, .. } = msg;
let clients = ecs.read_storage::<Client>();
let clients_count = clients.count();
// Avoid chat spam, send kill message only to group or nearby players if a
// certain amount of clients are online
if clients_count
> ecs
.fetch::<Settings>()
.max_player_for_kill_broadcast
.unwrap_or_default()
{
// Send kill message to the dead player's group
let killed_entity =
(*ecs.read_resource::<UidAllocator>()).retrieve_entity_internal(uid.0);
let groups = ecs.read_storage::<Group>();
let killed_group = killed_entity.and_then(|e| groups.get(e));
if let Some(g) = &killed_group {
send_to_group(g, ecs, &resolved_msg);
}
// Send kill message to nearby players that aren't part of the deceased's
// group
let positions = ecs.read_storage::<comp::Pos>();
if let Some(died_player_pos) = killed_entity.and_then(|e| positions.get(e))
{
for (ent, client, pos) in
(&*ecs.entities(), &clients, &positions).join()
{
let client_group = groups.get(ent);
let is_different_group =
!(killed_group == client_group && client_group.is_some());
if is_within(comp::ChatMsg::SAY_DISTANCE, pos, died_player_pos)
&& is_different_group
{
client.send_fallible(ServerGeneral::ChatMsg(
resolved_msg.clone(),
));
}
}
}
} else {
self.notify_players(ServerGeneral::server_msg(
comp::ChatType::Kill(kill_source.clone(), *uid),
message,
))
}
},
comp::ChatType::Say(uid) => {
let entity_opt =
(*ecs.read_resource::<UidAllocator>()).retrieve_entity_internal(uid.0);
let positions = ecs.read_storage::<comp::Pos>();
if let Some(speaker_pos) = entity_opt.and_then(|e| positions.get(e)) {
for (client, pos) in (&ecs.read_storage::<Client>(), &positions).join() {
if is_within(comp::ChatMsg::SAY_DISTANCE, pos, speaker_pos) {
client.send_fallible(ServerGeneral::ChatMsg(resolved_msg.clone()));
}
}
}
},
comp::ChatType::Region(uid) => {
let entity_opt =
(*ecs.read_resource::<UidAllocator>()).retrieve_entity_internal(uid.0);
let positions = ecs.read_storage::<comp::Pos>();
if let Some(speaker_pos) = entity_opt.and_then(|e| positions.get(e)) {
for (client, pos) in (&ecs.read_storage::<Client>(), &positions).join() {
if is_within(comp::ChatMsg::REGION_DISTANCE, pos, speaker_pos) {
client.send_fallible(ServerGeneral::ChatMsg(resolved_msg.clone()));
}
}
}
},
comp::ChatType::Npc(uid, _r) => {
let entity_opt =
(*ecs.read_resource::<UidAllocator>()).retrieve_entity_internal(uid.0);
let positions = ecs.read_storage::<comp::Pos>();
if let Some(speaker_pos) = entity_opt.and_then(|e| positions.get(e)) {
for (client, pos) in (&ecs.read_storage::<Client>(), &positions).join() {
if is_within(comp::ChatMsg::NPC_DISTANCE, pos, speaker_pos) {
client.send_fallible(ServerGeneral::ChatMsg(resolved_msg.clone()));
}
}
}
},
comp::ChatType::NpcSay(uid, _r) => {
let entity_opt =
(*ecs.read_resource::<UidAllocator>()).retrieve_entity_internal(uid.0);
let positions = ecs.read_storage::<comp::Pos>();
if let Some(speaker_pos) = entity_opt.and_then(|e| positions.get(e)) {
for (client, pos) in (&ecs.read_storage::<Client>(), &positions).join() {
if is_within(comp::ChatMsg::NPC_SAY_DISTANCE, pos, speaker_pos) {
client.send_fallible(ServerGeneral::ChatMsg(resolved_msg.clone()));
}
}
}
},
comp::ChatType::NpcTell(from, to, _r) => {
for (client, uid) in
(&ecs.read_storage::<Client>(), &ecs.read_storage::<Uid>()).join()
{
if uid == from || uid == to {
client.send_fallible(ServerGeneral::ChatMsg(resolved_msg.clone()));
}
}
},
comp::ChatType::FactionMeta(s) | comp::ChatType::Faction(_, s) => {
for (client, faction) in (
&ecs.read_storage::<Client>(),
&ecs.read_storage::<comp::Faction>(),
)
.join()
{
if s == &faction.0 {
client.send_fallible(ServerGeneral::ChatMsg(resolved_msg.clone()));
}
}
},
comp::ChatType::Group(from, g) => {
if group_info.is_none() {
// group not found, reply with command error
let reply = comp::ChatMsg {
chat_type: comp::ChatType::CommandError,
message: "You are using group chat but do not belong to a group. Use \
/world or /region to change chat."
.into(),
};
if let Some((client, _)) =
(&ecs.read_storage::<Client>(), &ecs.read_storage::<Uid>())
.join()
.find(|(_, uid)| *uid == from)
{
client.send_fallible(ServerGeneral::ChatMsg(reply));
}
return;
}
send_to_group(g, ecs, &resolved_msg);
},
comp::ChatType::GroupMeta(g) => {
send_to_group(g, ecs, &resolved_msg);
},
}
}
}
/// Sends the message to all connected clients
fn notify_players(&self, msg: ServerGeneral) {
let mut msg = Some(msg);
let mut lazy_msg = None;
for (client, _) in (
&self.ecs().read_storage::<Client>(),
&self.ecs().read_storage::<comp::Player>(),
)
.join()
{
if let Some(msg) = msg.take() {
lazy_msg = Some(client.prepare(msg));
}
lazy_msg.as_ref().map(|msg| client.send_prepared(msg));
}
}
/// Sends the message to all clients playing in game
fn notify_in_game_clients(&self, msg: ServerGeneral) {
let mut msg = Some(msg);
let mut lazy_msg = None;
for (client, _) in (
&mut self.ecs().write_storage::<Client>(),
&self.ecs().read_storage::<Presence>(),
)
.join()
{
if let Some(msg) = msg.take() {
lazy_msg = Some(client.prepare(msg));
}
lazy_msg.as_ref().map(|msg| client.send_prepared(msg));
}
}
fn link<L: Link>(&mut self, link: L) -> Result<(), L::Error> {
let linker = LinkHandle::from_link(link);
L::create(&linker, self.ecs().system_data())?;
self.ecs_mut()
.entry::<Vec<LinkHandle<L>>>()
.or_insert_with(Vec::new)
.push(linker);
Ok(())
}
fn maintain_links(&mut self) {
fn maintain_link<L: Link>(state: &State) {
if let Some(mut handles) = state.ecs().try_fetch_mut::<Vec<LinkHandle<L>>>() {
handles.retain(|link| {
if L::persist(link, state.ecs().system_data()) {
true
} else {
L::delete(link, state.ecs().system_data());
false
}
});
}
}
maintain_link::<Mounting>(self);
}
fn delete_entity_recorded(
&mut self,
entity: EcsEntity,
) -> Result<(), specs::error::WrongGeneration> {
// Remove entity from a group if they are in one
{
let clients = self.ecs().read_storage::<Client>();
let uids = self.ecs().read_storage::<Uid>();
let mut group_manager = self.ecs().write_resource::<comp::group::GroupManager>();
let map_markers = self.ecs().read_storage::<comp::MapMarker>();
group_manager.entity_deleted(
entity,
&mut self.ecs().write_storage(),
&self.ecs().read_storage(),
&uids,
&self.ecs().entities(),
&mut |entity, group_change| {
clients
.get(entity)
.and_then(|c| {
group_change
.try_map_ref(|e| uids.get(*e).copied())
.map(|g| (g, c))
})
.map(|(g, c)| {
update_map_markers(&map_markers, &uids, c, &group_change);
c.send_fallible(ServerGeneral::GroupUpdate(g));
});
},
);
}
// Cancel extant trades
events::cancel_trades_for(self, entity);
let (maybe_uid, maybe_pos) = (
self.ecs().read_storage::<Uid>().get(entity).copied(),
self.ecs().read_storage::<comp::Pos>().get(entity).copied(),
);
let res = self.ecs_mut().delete_entity(entity);
if res.is_ok() {
if let (Some(uid), Some(pos)) = (maybe_uid, maybe_pos) {
if let Some(region_key) = self
.ecs()
.read_resource::<common::region::RegionMap>()
.find_region(entity, pos.0)
{
self.ecs()
.write_resource::<DeletedEntities>()
.record_deleted_entity(uid, region_key);
} else {
// Don't panic if the entity wasn't found in a region maybe it was just created
// and then deleted before the region manager had a chance to assign it a
// region
warn!(
?uid,
?pos,
"Failed to find region containing entity during entity deletion, assuming \
it wasn't sent to any clients and so deletion doesn't need to be \
recorded for sync purposes"
);
}
}
}
res
}
}
fn send_to_group(g: &Group, ecs: &specs::World, msg: &comp::ChatMsg) {
for (client, group) in (&ecs.read_storage::<Client>(), &ecs.read_storage::<Group>()).join() {
if g == group {
client.send_fallible(ServerGeneral::ChatMsg(msg.clone()));
}
}
}
Reference in New Issue View Git Blame Copy Permalink