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

Merge branch 'tygyh/CleanUp' into 'master'

Browse Source 
Tygyh/clean up

See merge request veloren/veloren!3480
This commit is contained in:
Forest Anderson 2022-07-17 14:04:45 +00:00
commit 67534488b3
227 changed files with 855 additions and 943 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
client/src/addr.rs
View File

@ -55,7 +55,7 @@ pub(crate) async fn try_connect<F>(
f: F,
) -> Result<network::Participant, crate::error::Error>
where
F: Fn(std::net::SocketAddr) -> network::ConnectAddr,
F: Fn(SocketAddr) -> network::ConnectAddr,
{
use crate::error::Error;
let mut participant = None;
@ -77,7 +77,7 @@ where
fn sort_ipv6(s: impl Iterator<Item = SocketAddr>, prefer_ipv6: bool) -> Vec<SocketAddr> {
let (mut first_addrs, mut second_addrs) =
s.partition::<Vec<_>, _>(|a| a.is_ipv6() == prefer_ipv6);
std::iter::Iterator::chain(first_addrs.drain(..), second_addrs.drain(..)).collect::<Vec<_>>()
Iterator::chain(first_addrs.drain(..), second_addrs.drain(..)).collect::<Vec<_>>()
}
#[cfg(test)]

6
client/src/bin/bot/main.rs
View File

@ -183,7 +183,7 @@ impl BotClient {
}
fn create_default_body() -> Body {
comp::body::humanoid::Body {
Body {
species: comp::body::humanoid::Species::Human,
body_type: comp::body::humanoid::BodyType::Male,
hair_style: 0,
@ -208,14 +208,14 @@ impl BotClient {
let client = match self.bot_clients.get_mut(&cred.username) {
Some(c) => c,
None => {
tracing::trace!(?cred.username, "skip not logged in client");
trace!(?cred.username, "skip not logged in client");
continue;
},
};
let list = client.character_list();
if list.loading || list.characters.is_empty() {
tracing::trace!(?cred.username, "skip client as it has no character");
trace!(?cred.username, "skip client as it has no character");
continue;
}

2
client/src/bin/bot/settings.rs
View File

@ -36,7 +36,7 @@ impl Settings {
let mut new_path = path.to_owned();
new_path.pop();
new_path.push("settings.invalid.ron");
if let Err(e) = std::fs::rename(&path, &new_path) {
if let Err(e) = fs::rename(&path, &new_path) {
warn!(?e, ?path, ?new_path, "Failed to rename settings file.");
}
},

4
client/src/bin/swarm/main.rs
View File

@ -217,8 +217,8 @@ fn run_client(
let entity = client.entity();
// Move or stay still depending on specified options
// TODO: make sure server cheat protections aren't triggering
let pos = common::comp::Pos(position(index, opt) + world_center);
let vel = common::comp::Vel(Default::default());
let pos = comp::Pos(position(index, opt) + world_center);
let vel = comp::Vel(Default::default());
client
.state_mut()
.write_component_ignore_entity_dead(entity, pos);

30
client/src/lib.rs
View File

@ -162,7 +162,7 @@ impl WeatherLerp {
self.old = mem::replace(&mut self.new, (weather, Instant::now()));
}
// TODO: Make impprovements to this interpolation, it's main issue is assuming
// TODO: Make improvements to this interpolation, it's main issue is assuming
// that updates come at regular intervals.
fn update(&mut self, to_update: &mut WeatherGrid) {
prof_span!("WeatherLerp::update");
@ -321,7 +321,7 @@ impl Client {
ping_stream.send(PingMsg::Ping)?;
// Wait for initial sync
let mut ping_interval = tokio::time::interval(core::time::Duration::from_secs(1));
let mut ping_interval = tokio::time::interval(Duration::from_secs(1));
let (
state,
lod_base,
@ -601,7 +601,7 @@ impl Client {
let mut raw = vec![0u8; 4 * world_map_rgba.len()];
LittleEndian::write_u32_into(rgb, &mut raw);
Ok(Arc::new(
image::DynamicImage::ImageRgba8({
DynamicImage::ImageRgba8({
// Should not fail if the dimensions are correct.
let map =
image::ImageBuffer::from_raw(u32::from(map_size.x), u32::from(map_size.y), raw);
@ -991,7 +991,7 @@ impl Client {
.map_or(false, |cs| matches!(cs, CharacterState::Glide(_)))
}
pub fn split_swap_slots(&mut self, a: comp::slot::Slot, b: comp::slot::Slot) {
pub fn split_swap_slots(&mut self, a: Slot, b: Slot) {
match (a, b) {
(Slot::Equip(equip), slot) | (slot, Slot::Equip(equip)) => self.control_action(
ControlAction::InventoryAction(InventoryAction::Swap(equip, slot)),
@ -1004,7 +1004,7 @@ impl Client {
}
}
pub fn split_drop_slot(&mut self, slot: comp::slot::Slot) {
pub fn split_drop_slot(&mut self, slot: Slot) {
match slot {
Slot::Equip(equip) => {
self.control_action(ControlAction::InventoryAction(InventoryAction::Drop(equip)))
@ -1238,9 +1238,7 @@ impl Client {
pub fn max_group_size(&self) -> u32 { self.max_group_size }
pub fn invite(&self) -> Option<(Uid, std::time::Instant, std::time::Duration, InviteKind)> {
self.invite
}
pub fn invite(&self) -> Option<(Uid, Instant, Duration, InviteKind)> { self.invite }
pub fn group_info(&self) -> Option<(String, Uid)> {
self.group_leader.map(|l| ("Group".into(), l)) // TODO
@ -1529,7 +1527,7 @@ impl Client {
pub fn send_chat(&mut self, message: String) {
match validate_chat_msg(&message) {
Ok(()) => self.send_msg(ClientGeneral::ChatMsg(message)),
Err(ChatMsgValidationError::TooLong) => tracing::warn!(
Err(ChatMsgValidationError::TooLong) => warn!(
"Attempted to send a message that's too long (Over {} bytes)",
MAX_BYTES_CHAT_MSG
),
@ -1568,7 +1566,7 @@ impl Client {
.map_or((None, None), |inv| {
let tool_kind = |slot| {
inv.equipped(slot).and_then(|item| match &*item.kind() {
comp::item::ItemKind::Tool(tool) => Some(tool.kind),
ItemKind::Tool(tool) => Some(tool.kind),
_ => None,
})
};
@ -2013,7 +2011,7 @@ impl Client {
},
ServerGeneral::SetPlayerEntity(uid) => {
if let Some(entity) = self.state.ecs().entity_from_uid(uid.0) {
let old_player_entity = core::mem::replace(
let old_player_entity = mem::replace(
&mut *self.state.ecs_mut().write_resource(),
PlayerEntity(Some(entity)),
);
@ -2161,7 +2159,7 @@ impl Client {
timeout,
kind,
} => {
self.invite = Some((inviter, std::time::Instant::now(), timeout, kind));
self.invite = Some((inviter, Instant::now(), timeout, kind));
},
ServerGeneral::InvitePending(uid) => {
if !self.pending_invites.insert(uid) {
@ -2236,7 +2234,7 @@ impl Client {
});
},
ServerGeneral::UpdatePendingTrade(id, trade, pricing) => {
tracing::trace!("UpdatePendingTrade {:?} {:?}", id, trade);
trace!("UpdatePendingTrade {:?} {:?}", id, trade);
self.pending_trade = Some((id, trade, pricing));
},
ServerGeneral::FinishedTrade(result) => {
@ -2871,7 +2869,7 @@ mod tests {
//tick
let events_result: Result<Vec<Event>, Error> =
client.tick(comp::ControllerInputs::default(), clock.dt(), |_| {});
client.tick(ControllerInputs::default(), clock.dt(), |_| {});
//chat functionality
client.send_chat("foobar".to_string());
@ -2886,11 +2884,11 @@ mod tests {
},
Event::Disconnect => {},
Event::DisconnectionNotification(_) => {
tracing::debug!("Will be disconnected soon! :/")
debug!("Will be disconnected soon! :/")
},
Event::Notification(notification) => {
let notification: Notification = notification;
tracing::debug!("Notification: {:?}", notification);
debug!("Notification: {:?}", notification);
},
_ => {},
}

12
common/assets/src/lib.rs
View File

@ -179,7 +179,7 @@ pub struct DotVoxAsset(pub DotVoxData);
pub struct DotVoxLoader;
impl Loader<DotVoxAsset> for DotVoxLoader {
fn load(content: std::borrow::Cow<[u8]>, _: &str) -> Result<DotVoxAsset, BoxedError> {
fn load(content: Cow<[u8]>, _: &str) -> Result<DotVoxAsset, BoxedError> {
let data = dot_vox::load_bytes(&content).map_err(|err| err.to_owned())?;
Ok(DotVoxAsset(data))
}
@ -201,7 +201,7 @@ impl Asset for ObjAsset {
pub struct ObjAssetLoader;
impl Loader<ObjAsset> for ObjAssetLoader {
fn load(content: std::borrow::Cow<[u8]>, _: &str) -> Result<ObjAsset, BoxedError> {
fn load(content: Cow<[u8]>, _: &str) -> Result<ObjAsset, BoxedError> {
let data = wavefront::Obj::from_reader(&*content)?;
Ok(ObjAsset(data))
}
@ -214,7 +214,7 @@ pub fn find_root() -> Option<PathBuf> {
if path.join(".git").exists() {
return Some(path);
}
// Search .git directory in parent directries
// Search .git directory in parent directories
for ancestor in path.ancestors().take(10) {
if ancestor.join(".git").exists() {
return Some(ancestor.to_path_buf());
@ -407,7 +407,7 @@ pub mod asset_tweak {
/// assert_eq!(y1, 10);
///
/// // you may want to remove this file later
/// std::fs::remove_file(tweak_path);
/// fs::remove_file(tweak_path);
/// ```
pub fn tweak_expect<T>(specifier: Specifier) -> T
where
@ -505,7 +505,7 @@ pub mod asset_tweak {
}
}
/// Convinient macro to quickly tweak value.
/// Convenient macro to quickly tweak value.
///
/// Will use [Specifier]`::Tweak` specifier and call
/// [tweak_expect] if passed only name
@ -556,7 +556,7 @@ pub mod asset_tweak {
}};
}
/// Convinient macro to quickly tweak value from some existing path.
/// Convenient macro to quickly tweak value from some existing path.
///
/// Will use [Specifier]`::Asset` specifier and call
/// [tweak_expect] if passed only name

2
common/build.rs
View File

@ -54,7 +54,7 @@ fn main() {
}
// Check if git-lfs is working
if std::env::var("DISABLE_GIT_LFS_CHECK").is_err() && cfg!(not(feature = "no-assets")) {
if env::var("DISABLE_GIT_LFS_CHECK").is_err() && cfg!(not(feature = "no-assets")) {
let asset_path: PathBuf = ["..", "assets", "voxygen", "background", "bg_main.jpg"]
.iter()
.collect();

2
common/frontend/src/lib.rs
View File

@ -23,7 +23,7 @@ const RUST_LOG_ENV: &str = "RUST_LOG";
/// following in your environment.
/// `RUST_LOG="veloren_voxygen=trace"`
///
/// more complex tracing can be done by concatenating with a `,` as seperator:
/// more complex tracing can be done by concatenating with a `,` as separator:
/// - warn for `prometheus_hyper`, `dot_vox`, `gfx_device_gl::factory,
/// `gfx_device_gl::shade` trace for `veloren_voxygen`, info for everything
/// else

2
common/net/src/msg/client.rs
View File

@ -31,7 +31,7 @@ pub enum ClientMsg {
pub enum ClientType {
/// Regular Client like Voxygen who plays the game
Game,
/// A Chatonly client, which doesn't want to connect via its character
/// A Chat-only client, which doesn't want to connect via its character
ChatOnly,
/// A unprivileged bot, e.g. to request world information
/// Or a privileged bot, e.g. to run admin commands used by server-cli

2
common/net/src/msg/compression.rs
View File

@ -76,7 +76,7 @@ pub trait PackingFormula: Copy {
/// A wide, short image. Shares the advantage of not wasting space with
/// TallPacking (which is strictly worse, and was moved to benchmark code in
/// `world`), but faster to compress and smaller since PNG compresses each
/// row indepedently, so a wide image has fewer calls to the compressor. FLIP_X
/// row independently, so a wide image has fewer calls to the compressor. FLIP_X
/// has the same spatial locality preserving behavior as with TallPacking.
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct WidePacking<const FLIP_X: bool>();

10
common/net/src/msg/server.rs
View File

@ -141,23 +141,23 @@ pub enum ServerGeneral {
CharacterEdited(character::CharacterId),
CharacterSuccess,
//Ingame related
GroupUpdate(comp::group::ChangeNotification<sync::Uid>),
GroupUpdate(comp::group::ChangeNotification<Uid>),
/// Indicate to the client that they are invited to join a group
Invite {
inviter: sync::Uid,
timeout: std::time::Duration,
inviter: Uid,
timeout: Duration,
kind: InviteKind,
},
/// Indicate to the client that their sent invite was not invalid and is
/// currently pending
InvitePending(sync::Uid),
InvitePending(Uid),
/// Note: this could potentially include all the failure cases such as
/// inviting yourself in which case the `InvitePending` message could be
/// removed and the client could consider their invite pending until
/// they receive this message Indicate to the client the result of their
/// invite
InviteComplete {
target: sync::Uid,
target: Uid,
answer: InviteAnswer,
kind: InviteKind,
},

2
common/net/src/sync/sync_ext.rs
View File

@ -56,7 +56,7 @@ impl WorldSyncExt for specs::World {
}
fn create_entity_synced(&mut self) -> specs::EntityBuilder {
self.create_entity().marked::<super::Uid>()
self.create_entity().marked::<Uid>()
}
fn delete_entity_and_clear_from_uid_allocator(&mut self, uid: u64) {

8
common/net/src/sync/track.rs
View File

@ -33,7 +33,7 @@ where
pub fn removed(&self) -> &BitSet { &self.removed }
pub fn record_changes<'a>(&mut self, storage: &specs::ReadStorage<'a, C>) {
pub fn record_changes<'a>(&mut self, storage: &ReadStorage<'a, C>) {
self.inserted.clear();
self.modified.clear();
self.removed.clear();
@ -86,8 +86,8 @@ impl<C: Component + Clone + Send + Sync> UpdateTracker<C> {
pub fn get_updates_for<'a, P>(
&self,
uids: &specs::ReadStorage<'a, Uid>,
storage: &specs::ReadStorage<'a, C>,
uids: &ReadStorage<'a, Uid>,
storage: &ReadStorage<'a, C>,
entity_filter: impl Join + Copy,
buf: &mut Vec<(u64, CompUpdateKind<P>)>,
) where
@ -127,7 +127,7 @@ impl<C: Component + Clone + Send + Sync> UpdateTracker<C> {
/// entity.
pub fn get_update<'a, P>(
&self,
storage: &specs::ReadStorage<'a, C>,
storage: &ReadStorage<'a, C>,
entity: Entity,
) -> Option<CompUpdateKind<P>>
where

4
common/src/bin/asset_migrate.rs
View File

@ -7,7 +7,7 @@ use std::{
// If you want to migrate assets.
// 1) Copy-paste old asset type to own module
// 2) Copy-pase new asset type to own module
// 2) Copy-paste new asset type to own module
// (don't forget to add serde derive-s, import if needed)
// 3) impl From<old asset> for new asset.
// 4) Reference old and new assets in old and new modules
@ -50,7 +50,7 @@ fn walk_tree(dir: &Path, root: &Path) -> io::Result<Vec<Walk>> {
Ok(buff)
}
fn walk_with_migrate<OldV, NewV>(tree: Walk, from: &Path, to: &Path) -> std::io::Result<()>
fn walk_with_migrate<OldV, NewV>(tree: Walk, from: &Path, to: &Path) -> io::Result<()>
where
NewV: From<OldV>,
OldV: DeserializeOwned,

12
common/src/bin/csv_export/main.rs
View File

@ -46,7 +46,7 @@ fn armor_stats() -> Result<(), Box<dyn Error>> {
"Description",
])?;
for item in comp::item::Item::new_from_asset_glob("common.items.armor.*")
for item in Item::new_from_asset_glob("common.items.armor.*")
.expect("Failed to iterate over item folders!")
{
match &*item.kind() {
@ -118,8 +118,8 @@ fn weapon_stats() -> Result<(), Box<dyn Error>> {
// Does all items even outside weapon folder since we check if itemkind was a
// tool anyways
let items: Vec<comp::Item> = comp::Item::new_from_asset_glob("common.items.*")
.expect("Failed to iterate over item folders!");
let items: Vec<Item> =
Item::new_from_asset_glob("common.items.*").expect("Failed to iterate over item folders!");
for item in items.iter() {
if let comp::item::ItemKind::Tool(tool) = &*item.kind() {
@ -207,8 +207,8 @@ fn all_items() -> Result<(), Box<dyn Error>> {
let mut wtr = csv::Writer::from_path("items.csv")?;
wtr.write_record(&["Path", "Name"])?;
for item in comp::item::Item::new_from_asset_glob("common.items.*")
.expect("Failed to iterate over item folders!")
for item in
Item::new_from_asset_glob("common.items.*").expect("Failed to iterate over item folders!")
{
wtr.write_record(&[
item.item_definition_id()
@ -305,7 +305,7 @@ fn entity_drops(entity_config: &str) -> Result<(), Box<dyn Error>> {
"Quantity",
])?;
fn write_entity_loot<W: std::io::Write>(
fn write_entity_loot<W: Write>(
wtr: &mut csv::Writer<W>,
asset_path: &str,
) -> Result<(), Box<dyn Error>> {

52
common/src/bin/csv_import/main.rs
View File

@ -72,7 +72,7 @@ fn armor_stats() -> Result<(), Box<dyn Error>> {
.expect("Failed to iterate over item folders!")
{
match &*item.kind() {
comp::item::ItemKind::Armor(armor) => {
ItemKind::Armor(armor) => {
if let ArmorKind::Bag = armor.kind {
continue;
}
@ -190,20 +190,20 @@ fn armor_stats() -> Result<(), Box<dyn Error>> {
let quality = if let Some(quality_raw) = record.get(headers["Quality"])
{
match quality_raw {
"Low" => comp::item::Quality::Low,
"Common" => comp::item::Quality::Common,
"Moderate" => comp::item::Quality::Moderate,
"High" => comp::item::Quality::High,
"Epic" => comp::item::Quality::Epic,
"Legendary" => comp::item::Quality::Legendary,
"Artifact" => comp::item::Quality::Artifact,
"Debug" => comp::item::Quality::Debug,
"Low" => Quality::Low,
"Common" => Quality::Common,
"Moderate" => Quality::Moderate,
"High" => Quality::High,
"Epic" => Quality::Epic,
"Legendary" => Quality::Legendary,
"Artifact" => Quality::Artifact,
"Debug" => Quality::Debug,
_ => {
eprintln!(
"Unknown quality variant for {:?}",
item.item_definition_id()
);
comp::item::Quality::Debug
Quality::Debug
},
}
} else {
@ -211,7 +211,7 @@ fn armor_stats() -> Result<(), Box<dyn Error>> {
"Could not unwrap quality for {:?}",
item.item_definition_id()
);
comp::item::Quality::Debug
Quality::Debug
};
let description = record
@ -284,7 +284,7 @@ fn weapon_stats() -> Result<(), Box<dyn Error>> {
.expect("Failed to iterate over item folders!");
for item in items.iter() {
if let comp::item::ItemKind::Tool(tool) = &*item.kind() {
if let ItemKind::Tool(tool) = &*item.kind() {
if let Ok(ref record) = record {
if item.item_definition_id()
== ItemDefinitionId::Simple(
@ -328,19 +328,19 @@ fn weapon_stats() -> Result<(), Box<dyn Error>> {
let hands = if let Some(hands_raw) = record.get(headers["Hands"]) {
match hands_raw {
"One" | "1" | "1h" => comp::item::tool::Hands::One,
"Two" | "2" | "2h" => comp::item::tool::Hands::Two,
"One" | "1" | "1h" => Hands::One,
"Two" | "2" | "2h" => Hands::Two,
_ => {
eprintln!(
"Unknown hand variant for {:?}",
item.item_definition_id()
);
comp::item::tool::Hands::Two
Hands::Two
},
}
} else {
eprintln!("Could not unwrap hand for {:?}", item.item_definition_id());
comp::item::tool::Hands::Two
Hands::Two
};
let crit_chance: f32 = record
@ -392,20 +392,20 @@ fn weapon_stats() -> Result<(), Box<dyn Error>> {
let quality = if let Some(quality_raw) = record.get(headers["Quality"]) {
match quality_raw {
"Low" => comp::item::Quality::Low,
"Common" => comp::item::Quality::Common,
"Moderate" => comp::item::Quality::Moderate,
"High" => comp::item::Quality::High,
"Epic" => comp::item::Quality::Epic,
"Legendary" => comp::item::Quality::Legendary,
"Artifact" => comp::item::Quality::Artifact,
"Debug" => comp::item::Quality::Debug,
"Low" => Quality::Low,
"Common" => Quality::Common,
"Moderate" => Quality::Moderate,
"High" => Quality::High,
"Epic" => Quality::Epic,
"Legendary" => Quality::Legendary,
"Artifact" => Quality::Artifact,
"Debug" => Quality::Debug,
_ => {
eprintln!(
"Unknown quality variant for {:?}",
item.item_definition_id()
);
comp::item::Quality::Debug
Quality::Debug
},
}
} else {
@ -413,7 +413,7 @@ fn weapon_stats() -> Result<(), Box<dyn Error>> {
"Could not unwrap quality for {:?}",
item.item_definition_id()
);
comp::item::Quality::Debug
Quality::Debug
};
let description = record.get(headers["Description"]).expect(&format!(

4
common/src/cmd.rs
View File

@ -135,7 +135,7 @@ lazy_static! {
pub static ref BUFF_PARSER: HashMap<String, BuffKind> = {
let string_from_buff = |kind| match kind {
BuffKind::Burning => "burning",
BuffKind::Regeneration => "regeration",
BuffKind::Regeneration => "regeneration",
BuffKind::Saturation => "saturation",
BuffKind::Bleeding => "bleeding",
BuffKind::Cursed => "cursed",
@ -804,7 +804,7 @@ impl ServerChatCommand {
}
/// Produce an iterator over all the available commands
pub fn iter() -> impl Iterator<Item = Self> { <Self as strum::IntoEnumIterator>::iter() }
pub fn iter() -> impl Iterator<Item = Self> { <Self as IntoEnumIterator>::iter() }
/// A message that explains what the command does
pub fn help_string(&self) -> String {

6
common/src/combat.rs
View File

@ -352,7 +352,7 @@ impl Attack {
}
},
CombatEffect::Lifesteal(l) => {
// Not modified by strength_modifer as damage already is
// Not modified by strength_modifier as damage already is
if let Some(attacker_entity) = attacker.map(|a| a.entity) {
let change = HealthChange {
amount: applied_damage * l,
@ -499,7 +499,7 @@ impl Attack {
}
},
CombatEffect::Lifesteal(l) => {
// Not modified by strength_modifer as damage already is
// Not modified by strength_modifier as damage already is
if let Some(attacker_entity) = attacker.map(|a| a.entity) {
let change = HealthChange {
amount: accumulated_damage * l,
@ -1162,7 +1162,7 @@ pub fn compute_crit_mult(inventory: Option<&Inventory>, msm: &MaterialStatManife
})
}
/// Computes the energy reward modifer from worn armor
/// Computes the energy reward modifier from worn armor
#[cfg(not(target_arch = "wasm32"))]
pub fn compute_energy_reward_mod(inventory: Option<&Inventory>, msm: &MaterialStatManifest) -> f32 {
// Starts with a value of 1.0 when summing the stats from each armor piece, and

4
common/src/comp/agent.rs
View File

@ -217,7 +217,7 @@ impl<'a> From<&'a Body> for Psyche {
quadruped_small::Species::Goat => 0.5,
quadruped_small::Species::Porcupine => 0.7,
quadruped_small::Species::Turtle => 0.7,
// FIXME: This is to balance for enemy rats in dunegeons
// FIXME: This is to balance for enemy rats in dungeons
// Normal rats should probably always flee.
quadruped_small::Species::Rat => 0.0,
quadruped_small::Species::Beaver => 0.7,
@ -546,7 +546,7 @@ impl Agent {
self
}
/// Makes agent aggresive without warning
/// Makes agent aggressive without warning
#[must_use]
pub fn with_aggro_no_warn(mut self) -> Self {
self.psyche.aggro_dist = None;

6
common/src/comp/body.rs
View File

@ -289,7 +289,7 @@ impl Body {
Body::FishSmall(_) => 1.0,
Body::Golem(_) => 10_000.0,
Body::Humanoid(humanoid) => {
// Understand that chaning the mass values can have effects
// Understand that changing the mass values can have effects
// on multiple systems.
//
// If you want to change that value, consult with
@ -568,8 +568,8 @@ impl Body {
}
}
// How far away other entities should try to be. Will be added uppon the other
// entitys spacing_radius. So an entity with 2.0 and an entity with 3.0 will
// How far away other entities should try to be. Will be added upon the other
// entity's spacing_radius. So an entity with 2.0 and an entity with 3.0 will
// lead to that both entities will try to keep 5.0 units away from each
// other.
pub fn spacing_radius(&self) -> f32 {

16
common/src/comp/character_state.rs
View File

@ -300,18 +300,14 @@ impl CharacterState {
pub fn behavior(&self, j: &JoinData, output_events: &mut OutputEvents) -> StateUpdate {
match &self {
CharacterState::Idle(data) => data.behavior(j, output_events),
CharacterState::Talk => states::talk::Data.behavior(j, output_events),
CharacterState::Talk => talk::Data.behavior(j, output_events),
CharacterState::Climb(data) => data.behavior(j, output_events),
CharacterState::Wallrun(data) => data.behavior(j, output_events),
CharacterState::Glide(data) => data.behavior(j, output_events),
CharacterState::GlideWield(data) => data.behavior(j, output_events),
CharacterState::Stunned(data) => data.behavior(j, output_events),
CharacterState::Sit => {
states::sit::Data::behavior(&states::sit::Data, j, output_events)
},
CharacterState::Dance => {
states::dance::Data::behavior(&states::dance::Data, j, output_events)
},
CharacterState::Sit => sit::Data::behavior(&sit::Data, j, output_events),
CharacterState::Dance => dance::Data::behavior(&dance::Data, j, output_events),
CharacterState::BasicBlock(data) => data.behavior(j, output_events),
CharacterState::Roll(data) => data.behavior(j, output_events),
CharacterState::Wielding(data) => data.behavior(j, output_events),
@ -347,17 +343,17 @@ impl CharacterState {
) -> StateUpdate {
match &self {
CharacterState::Idle(data) => data.handle_event(j, output_events, action),
CharacterState::Talk => states::talk::Data.handle_event(j, output_events, action),
CharacterState::Talk => talk::Data.handle_event(j, output_events, action),
CharacterState::Climb(data) => data.handle_event(j, output_events, action),
CharacterState::Wallrun(data) => data.handle_event(j, output_events, action),
CharacterState::Glide(data) => data.handle_event(j, output_events, action),
CharacterState::GlideWield(data) => data.handle_event(j, output_events, action),
CharacterState::Stunned(data) => data.handle_event(j, output_events, action),
CharacterState::Sit => {
states::sit::Data::handle_event(&states::sit::Data, j, output_events, action)
states::sit::Data::handle_event(&sit::Data, j, output_events, action)
},
CharacterState::Dance => {
states::dance::Data::handle_event(&states::dance::Data, j, output_events, action)
states::dance::Data::handle_event(&dance::Data, j, output_events, action)
},
CharacterState::BasicBlock(data) => data.handle_event(j, output_events, action),
CharacterState::Roll(data) => data.handle_event(j, output_events, action),

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

@ -131,7 +131,7 @@ pub enum UtteranceKind {
Greeting,
Scream,
/* Death,
* TODO: Wait for more post-death features (i.e. animiations) before implementing death
* TODO: Wait for more post-death features (i.e. animations) before implementing death
* sounds */
}

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

@ -138,7 +138,7 @@ impl Body {
) -> Vec3<f32> {
let v_sq = rel_flow.0.magnitude_squared();
if v_sq < 0.25 {
// don't bother with miniscule forces
// don't bother with minuscule forces
Vec3::zero()
} else {
let rel_flow_dir = Dir::new(rel_flow.0 / v_sq.sqrt());

12
common/src/comp/inventory/item/mod.rs
View File

@ -263,8 +263,8 @@ impl TagExampleInfo for ItemTag {
#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum ItemKind {
/// Something wieldable
Tool(tool::Tool),
ModularComponent(modular::ModularComponent),
Tool(Tool),
ModularComponent(ModularComponent),
Lantern(Lantern),
Armor(armor::Armor),
Glider,
@ -373,7 +373,7 @@ pub enum ItemName {
#[derive(Clone, Debug)]
pub enum ItemBase {
Simple(Arc<ItemDef>),
Modular(modular::ModularBase),
Modular(ModularBase),
}
impl Serialize for ItemBase {
@ -1234,11 +1234,11 @@ impl<'a, T: ItemDesc + ?Sized> ItemDesc for &'a T {
fn item_definition_id(&self) -> ItemDefinitionId<'_> { (*self).item_definition_id() }
fn components(&self) -> &[Item] { (*self).components() }
fn tags(&self) -> Vec<ItemTag> { (*self).tags() }
fn is_modular(&self) -> bool { (*self).is_modular() }
fn components(&self) -> &[Item] { (*self).components() }
}
/// Returns all item asset specifiers
@ -1262,7 +1262,7 @@ mod tests {
fn test_assets_items() {
let ids = all_item_defs_expect();
for item in ids.iter().map(|id| Item::new_from_asset_expect(id)) {
std::mem::drop(item)
drop(item)
}
}
}

4
common/src/comp/inventory/item/modular.rs
View File

@ -41,8 +41,8 @@ impl MaterialStatManifest {
/// needed for tests to load it without actual assets
pub fn with_empty() -> Self {
Self {
tool_stats: hashbrown::HashMap::default(),
armor_stats: hashbrown::HashMap::default(),
tool_stats: HashMap::default(),
armor_stats: HashMap::default(),
}
}
}

14
common/src/comp/inventory/loadout_builder.rs
View File

@ -84,10 +84,10 @@ impl ItemSpec {
let mut rng = rand::thread_rng();
match self {
ItemSpec::Item(item_asset) => Item::new_from_asset(item_asset)
.map(std::mem::drop)
.map(drop)
.map_err(ValidationError::ItemAssetError),
ItemSpec::Choice(choices) => {
// TODO: check for sanity of weigts?
// TODO: check for sanity of weights?
for (_weight, choice) in choices {
if let Some(item) = choice {
item.validate()?;
@ -100,7 +100,7 @@ impl ItemSpec {
material,
hands,
} => item::modular::random_weapon(*tool, *material, *hands, &mut rng)
.map(std::mem::drop)
.map(drop)
.map_err(ValidationError::ModularWeaponCreationError),
}
}
@ -212,7 +212,7 @@ impl Base {
/// If you want programing API of loadout creation,
/// use `LoadoutBuilder` instead.
///
/// For examples of assets, see `assets/test/ladout/ok` folder.
/// For examples of assets, see `assets/test/loadout/ok` folder.
#[derive(Debug, Deserialize, Clone, Default)]
#[serde(deny_unknown_fields)]
pub struct LoadoutSpec {
@ -1161,8 +1161,8 @@ mod tests {
// Testing different species
//
// Things that will be catched - invalid assets paths for
// creating default main hand tool or equipement without config
// Things that will be caught - invalid assets paths for
// creating default main hand tool or equipment without config
#[test]
fn test_loadout_species() {
macro_rules! test_species {
@ -1219,7 +1219,7 @@ mod tests {
#[test]
fn test_loadout_presets() {
for preset in Preset::iter() {
std::mem::drop(LoadoutBuilder::empty().with_preset(preset));
drop(LoadoutBuilder::empty().with_preset(preset));
}
}

8
common/src/comp/inventory/mod.rs
View File

@ -269,7 +269,7 @@ impl Inventory {
/// item or the same item again if that slot was not found.
pub fn insert_at(&mut self, inv_slot_id: InvSlotId, item: Item) -> Result<Option<Item>, Item> {
match self.slot_mut(inv_slot_id) {
Some(slot) => Ok(core::mem::replace(slot, Some(item))),
Some(slot) => Ok(mem::replace(slot, Some(item))),
None => Err(item),
}
}
@ -319,7 +319,7 @@ impl Inventory {
.err()
.and(Some(item))
} else {
let old_item = core::mem::replace(slot_item, item);
let old_item = mem::replace(slot_item, item);
// No need to recount--we know the count is the same.
Some(old_item)
})
@ -808,8 +808,8 @@ impl Inventory {
/// Used only when loading in persistence code.
pub fn persistence_update_all_item_states(
&mut self,
ability_map: &item::tool::AbilityMap,
msm: &item::MaterialStatManifest,
ability_map: &AbilityMap,
msm: &MaterialStatManifest,
) {
self.slots_mut().for_each(|slot| {
if let Some(item) = slot {

15
common/src/comp/inventory/slot.rs
View File

@ -1,12 +1,9 @@
use serde::{Deserialize, Serialize};
use std::{cmp::Ordering, convert::TryFrom};
use crate::comp::{
inventory::{
item::{armor, armor::ArmorKind, tool, ItemKind},
loadout::LoadoutSlotId,
},
item,
use crate::comp::inventory::{
item::{armor, armor::ArmorKind, tool, ItemKind},
loadout::LoadoutSlotId,
};
#[derive(Debug, PartialEq)]
@ -110,7 +107,7 @@ pub enum ArmorSlot {
}
impl Slot {
pub fn can_hold(self, item_kind: &item::ItemKind) -> bool {
pub fn can_hold(self, item_kind: &ItemKind) -> bool {
match (self, item_kind) {
(Self::Inventory(_), _) => true,
(Self::Equip(slot), item_kind) => slot.can_hold(item_kind),
@ -119,7 +116,7 @@ impl Slot {
}
impl EquipSlot {
pub fn can_hold(self, item_kind: &item::ItemKind) -> bool {
pub fn can_hold(self, item_kind: &ItemKind) -> bool {
match (self, item_kind) {
(Self::Armor(slot), ItemKind::Armor(armor::Armor { kind, .. })) => slot.can_hold(kind),
(Self::ActiveMainhand, ItemKind::Tool(_)) => true,
@ -134,7 +131,7 @@ impl EquipSlot {
}
impl ArmorSlot {
fn can_hold(self, armor: &item::armor::ArmorKind) -> bool {
fn can_hold(self, armor: &ArmorKind) -> bool {
matches!(
(self, armor),
(Self::Head, ArmorKind::Head)

6
common/src/comp/inventory/trade_pricing.rs
View File

@ -519,12 +519,12 @@ fn get_scaling(contents: &AssetGuard<TradingPriceFile>, good: Good) -> f32 {
}
#[cfg(test)]
impl std::cmp::PartialOrd for ItemDefinitionIdOwned {
impl PartialOrd for ItemDefinitionIdOwned {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) }
}
#[cfg(test)]
impl std::cmp::Ord for ItemDefinitionIdOwned {
impl Ord for ItemDefinitionIdOwned {
fn cmp(&self, other: &Self) -> Ordering {
match self {
ItemDefinitionIdOwned::Simple(na) => match other {
@ -781,7 +781,7 @@ impl TradePricing {
for (_, recipe) in book.iter() {
let (ref asset_path, amount) = recipe.output;
if let ItemKind::ModularComponent(
crate::comp::inventory::item::modular::ModularComponent::ToolSecondaryComponent {
inventory::item::modular::ModularComponent::ToolSecondaryComponent {
toolkind,
stats: _,
hand_restriction: _,

6
common/src/comp/melee.rs
View File

@ -1,6 +1,6 @@
use crate::{
combat::{
self, Attack, AttackDamage, AttackEffect, CombatBuff, CombatBuffStrength, CombatEffect,
Attack, AttackDamage, AttackEffect, CombatBuff, CombatBuffStrength, CombatEffect,
CombatRequirement, Damage, DamageKind, DamageSource, GroupTarget, Knockback, KnockbackDir,
},
comp::{
@ -405,9 +405,7 @@ impl MeleeConstructor {
if let Some(ref mut scaled) = &mut self.scaled {
*scaled = scaled.adjusted_by_stats(stats, regen);
}
if let Some(CombatEffect::Buff(combat::CombatBuff { strength, .. })) =
&mut self.damage_effect
{
if let Some(CombatEffect::Buff(CombatBuff { strength, .. })) = &mut self.damage_effect {
*strength *= stats.buff_strength;
}
self

4
common/src/event.rs
View File

@ -126,7 +126,7 @@ pub enum ServerEvent {
},
// TODO: to avoid breakage when adding new fields, perhaps have an `NpcBuilder` type?
CreateNpc {
pos: comp::Pos,
pos: Pos,
stats: comp::Stats,
skill_set: comp::SkillSet,
health: Option<comp::Health>,
@ -142,7 +142,7 @@ pub enum ServerEvent {
projectile: Option<comp::Projectile>,
},
CreateShip {
pos: comp::Pos,
pos: Pos,
ship: comp::ship::Body,
mountable: bool,
agent: Option<comp::Agent>,

13
common/src/generation.rs
View File

@ -7,7 +7,6 @@ use crate::{
},
lottery::LootSpec,
npc::{self, NPC_NAMES},
trade,
trade::SiteInformation,
};
use serde::Deserialize;
@ -62,7 +61,7 @@ pub enum Meta {
// that this field should be either Default or Unchanged
// depending on how it is used.
//
// When we will use exension manifests more, it would be nicer to
// When we will use extension manifests more, it would be nicer to
// split EntityBase and EntityExtension to different structs.
//
// Fields which have Uninit enum kind
@ -70,7 +69,7 @@ pub enum Meta {
// and required (or renamed to Default) in EntityBase
/// Struct for EntityInfo manifest.
///
/// Intended to use with .ron files as base definion or
/// Intended to use with .ron files as base definition or
/// in rare cases as extension manifest.
/// Pure data struct, doesn't do anything until evaluated with EntityInfo.
///
@ -167,7 +166,7 @@ pub struct EntityInfo {
// Loadout
pub inventory: Vec<(u32, Item)>,
pub loadout: LoadoutBuilder,
pub make_loadout: Option<fn(LoadoutBuilder, Option<&trade::SiteInformation>) -> LoadoutBuilder>,
pub make_loadout: Option<fn(LoadoutBuilder, Option<&SiteInformation>) -> LoadoutBuilder>,
// Skills
pub skillset_asset: Option<String>,
@ -176,7 +175,7 @@ pub struct EntityInfo {
// Economy
// we can't use DHashMap, do we want to move that into common?
pub trading_information: Option<trade::SiteInformation>,
pub trading_information: Option<SiteInformation>,
//Option<hashbrown::HashMap<crate::trade::Good, (f32, f32)>>, /* price and available amount */
}
@ -394,7 +393,7 @@ impl EntityInfo {
#[must_use]
pub fn with_lazy_loadout(
mut self,
creator: fn(LoadoutBuilder, Option<&trade::SiteInformation>) -> LoadoutBuilder,
creator: fn(LoadoutBuilder, Option<&SiteInformation>) -> LoadoutBuilder,
) -> Self {
self.make_loadout = Some(creator);
self
@ -576,7 +575,7 @@ mod tests {
match field {
Meta::SkillSetAsset(asset) => {
std::mem::drop(SkillSetBuilder::from_asset_expect(&asset));
drop(SkillSetBuilder::from_asset_expect(&asset));
},
}
}

4
common/src/link.rs
View File

@ -28,9 +28,7 @@ pub struct Is<R: Role> {
}
impl<R: Role> Is<R> {
pub fn delete(&self, data: <R::Link as Link>::DeleteData<'_>) {
R::Link::delete(&self.link, data)
}
pub fn delete(&self, data: <R::Link as Link>::DeleteData<'_>) { Link::delete(&self.link, data) }
}
impl<R: Role> Clone for Is<R> {

4
common/src/lottery.rs
View File

@ -108,7 +108,7 @@ impl<T: AsRef<str>> LootSpec<T> {
warn!(?e, "error while loading item: {}", item.as_ref());
None
},
Option::Some,
Some,
),
Self::ItemQuantity(item, lower, upper) => {
let range = *lower..=*upper;
@ -148,7 +148,7 @@ impl<T: AsRef<str>> LootSpec<T> {
);
None
},
Option::Some,
Some,
),
Self::ModularWeaponPrimaryComponent {
tool,

2
common/src/outcome.rs
View File

@ -54,7 +54,7 @@ pub enum Outcome {
},
SkillPointGain {
uid: Uid,
skill_tree: comp::skillset::SkillGroupKind,
skill_tree: SkillGroupKind,
total_points: u16,
},
ComboChange {

4
common/src/recipe.rs
View File

@ -645,9 +645,9 @@ impl ComponentRecipe {
/// a component recipe. If it does, return a vec of inventory slots that
/// contain the ingredients needed, whose positions correspond to particular
/// recipe are missing.
pub fn inventory_contains_additional_ingredients<'a>(
pub fn inventory_contains_additional_ingredients(
&self,
inv: &'a Inventory,
inv: &Inventory,
) -> Result<Vec<(u32, InvSlotId)>, Vec<(&RecipeInput, u32)>> {
inventory_contains_ingredients(
self.additional_inputs

2
common/src/skillset_builder.rs
View File

@ -167,7 +167,7 @@ mod tests {
fn test_all_skillset_assets() {
let skillsets = assets::read_expect_dir::<SkillSetTree>("common.skillset", true);
for skillset in skillsets {
std::mem::drop({
drop({
let mut skillset_builder = SkillSetBuilder::default();
let nodes = &*skillset.0;
let tree = skills_from_nodes(nodes);

4
common/src/states/basic_summon.rs
View File

@ -33,7 +33,7 @@ pub struct StaticData {
pub recover_duration: Duration,
/// How many creatures the state should summon
pub summon_amount: u32,
/// Range of the summons relative to the summonner
/// Range of the summons relative to the summoner
pub summon_distance: (f32, f32),
/// Information about the summoned creature
pub summon_info: SummonInfo,
@ -161,7 +161,7 @@ impl CharacterBehavior for Data {
.cast()
.0;
// If a duration is specified, create a projectile componenent for the npc
// If a duration is specified, create a projectile component for the npc
let projectile = self.static_data.duration.map(|duration| Projectile {
hit_solid: Vec::new(),
hit_entity: Vec::new(),

8
common/src/states/combo_melee.rs
View File

@ -173,7 +173,7 @@ impl CharacterBehavior for Data {
.get(self.stage as usize - 1)
.map_or(0, |_| self.stage as usize - 1);
let speed_modifer = 1.0
let speed_modifier = 1.0
+ self.static_data.max_speed_increase
* (1.0 - self.static_data.speed_increase.powi(combo_counter as i32));
@ -190,7 +190,7 @@ impl CharacterBehavior for Data {
// Build up
update.character = CharacterState::ComboMelee(Data {
static_data: self.static_data.clone(),
timer: tick_attack_or_default(data, self.timer, Some(speed_modifer)),
timer: tick_attack_or_default(data, self.timer, Some(speed_modifier)),
..*self
});
} else {
@ -315,7 +315,7 @@ impl CharacterBehavior for Data {
// Swings
update.character = CharacterState::ComboMelee(Data {
static_data: self.static_data.clone(),
timer: tick_attack_or_default(data, self.timer, Some(speed_modifer)),
timer: tick_attack_or_default(data, self.timer, Some(speed_modifier)),
..*self
});
} else {
@ -339,7 +339,7 @@ impl CharacterBehavior for Data {
// Recovers
update.character = CharacterState::ComboMelee(Data {
static_data: self.static_data.clone(),
timer: tick_attack_or_default(data, self.timer, Some(speed_modifer)),
timer: tick_attack_or_default(data, self.timer, Some(speed_modifier)),
..*self
});
} else {

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

@ -22,7 +22,7 @@ pub struct StaticData {
pub buildup_duration: Duration,
/// How long the state charges for until it reaches max damage
pub charge_duration: Duration,
/// Suration of state spent in swing
/// Duration of state spent in swing
pub swing_duration: Duration,
/// How long the state has until exiting
pub recover_duration: Duration,

14
common/src/states/utils.rs
View File

@ -303,7 +303,7 @@ impl Body {
/// set footwear in idle data and potential state change to Skate
pub fn handle_skating(data: &JoinData, update: &mut StateUpdate) {
if let Idle(crate::states::idle::Data {
if let Idle(idle::Data {
is_sneaking,
mut footwear,
}) = data.character
@ -313,19 +313,17 @@ pub fn handle_skating(data: &JoinData, update: &mut StateUpdate) {
inv.equipped(EquipSlot::Armor(ArmorSlot::Feet))
.map(|armor| match armor.kind().as_ref() {
ItemKind::Armor(a) => a.stats(data.msm).ground_contact,
_ => crate::comp::inventory::item::armor::Friction::Normal,
_ => Friction::Normal,
})
});
update.character = Idle(crate::states::idle::Data {
update.character = Idle(idle::Data {
is_sneaking: *is_sneaking,
footwear,
});
}
if data.physics.skating_active {
update.character = CharacterState::Skate(crate::states::skate::Data::new(
data,
footwear.unwrap_or(Friction::Normal),
));
update.character =
CharacterState::Skate(skate::Data::new(data, footwear.unwrap_or(Friction::Normal)));
}
}
}
@ -687,7 +685,7 @@ pub fn attempt_talk(data: &JoinData<'_>, update: &mut StateUpdate) {
pub fn attempt_sneak(data: &JoinData<'_>, update: &mut StateUpdate) {
if data.physics.on_ground.is_some() && data.body.is_humanoid() {
update.character = CharacterState::Idle(idle::Data {
update.character = Idle(idle::Data {
is_sneaking: true,
footwear: data.character.footwear(),
});

2
common/src/terrain/block.rs
View File

@ -86,7 +86,7 @@ impl BlockKind {
#[inline]
pub const fn is_filled(&self) -> bool { !self.is_fluid() }
/// Determine whether the block has an RGB color storaged in the attribute
/// Determine whether the block has an RGB color stored in the attribute
/// fields.
#[inline]
pub const fn has_color(&self) -> bool { self.is_filled() }

2
common/src/trade.rs
View File

@ -341,7 +341,7 @@ pub enum Good {
impl Default for Good {
fn default() -> Self {
Good::Terrain(crate::terrain::BiomeKind::Void) // Arbitrary
Good::Terrain(BiomeKind::Void) // Arbitrary
}
}

2
common/src/util/dir.rs
View File

@ -165,7 +165,7 @@ impl std::ops::Neg for Dir {
/// Additionally, it avoids unnecessary calculations if they are near identical
/// Assumes `from` and `to` are normalized and returns a normalized vector
#[inline(always)]
fn slerp_normalized(from: vek::Vec3<f32>, to: vek::Vec3<f32>, factor: f32) -> vek::Vec3<f32> {
fn slerp_normalized(from: Vec3<f32>, to: Vec3<f32>, factor: f32) -> Vec3<f32> {
debug_assert!(!to.map(f32::is_nan).reduce_or());
debug_assert!(!from.map(f32::is_nan).reduce_or());
// Ensure from is normalized

4
common/src/volumes/chunk.rs
View File

@ -277,9 +277,9 @@ impl<V, S: VolSize, M> Chunk<V, S, M> {
{
if vox != self.default {
let idx = self.force_idx_unchecked(pos);
core::mem::replace(&mut self.vox[idx], vox)
mem::replace(&mut self.vox[idx], vox)
} else if let Some(idx) = self.idx_unchecked(pos) {
core::mem::replace(&mut self.vox[idx], vox)
mem::replace(&mut self.vox[idx], vox)
} else {
self.default.clone()
}

2
common/state/src/build_areas.rs
View File

@ -22,7 +22,7 @@ pub enum BuildAreaError {
const RESERVED_BUILD_AREA_NAMES: &[&str] = &["world"];
impl BuildAreas {
pub fn areas(&self) -> &Depot<geom::Aabb<i32>> { &self.areas }
pub fn areas(&self) -> &Depot<Aabb<i32>> { &self.areas }
pub fn area_names(&self) -> &HashMap<String, Id<Aabb<i32>>> { &self.area_names }

2
common/systems/src/beam.rs
View File

@ -116,7 +116,7 @@ impl<'a> System<'a> for Sys {
if frame_time <= 0.0 {
return (server_events, add_hit_entities, outcomes);
}
// Note: min() probably uneeded
// Note: min() probably unneeded
let time_since_creation = (time - creation_time) as f32;
let frame_start_dist =
(beam_segment.speed * (time_since_creation - frame_time)).max(0.0);

2
common/systems/tests/character_state.rs
View File

@ -27,7 +27,7 @@ mod tests {
state
}
fn create_entity(state: &mut State, ori: Ori) -> specs::Entity {
fn create_entity(state: &mut State, ori: Ori) -> Entity {
let body = common::comp::Body::Humanoid(common::comp::humanoid::Body::random_with(
&mut thread_rng(),
&common::comp::humanoid::Species::Human,

12
common/systems/tests/phys/basic.rs
View File

@ -36,14 +36,14 @@ fn dont_fall_outside_world() -> Result<(), Box<dyn Error>> {
assert_relative_eq!(pos.0.x, 1000.0);
assert_relative_eq!(pos.0.y, 1000.0);
assert_relative_eq!(pos.0.z, 265.0);
assert_eq!(vel.0, vek::Vec3::zero());
assert_eq!(vel.0, Vec3::zero());
utils::tick(&mut state, DT);
let (pos, vel, _) = utils::get_transform(&state, p1)?;
assert_relative_eq!(pos.0.x, 1000.0);
assert_relative_eq!(pos.0.y, 1000.0);
assert_relative_eq!(pos.0.z, 265.0);
assert_eq!(vel.0, vek::Vec3::zero());
assert_eq!(vel.0, Vec3::zero());
Ok(())
}
@ -56,7 +56,7 @@ fn fall_simple() -> Result<(), Box<dyn Error>> {
assert_relative_eq!(pos.0.x, 16.0);
assert_relative_eq!(pos.0.y, 16.0);
assert_relative_eq!(pos.0.z, 265.0);
assert_eq!(vel.0, vek::Vec3::zero());
assert_eq!(vel.0, Vec3::zero());
utils::tick(&mut state, DT);
let (pos, vel, _) = utils::get_transform(&state, p1)?;
@ -86,7 +86,7 @@ fn fall_simple() -> Result<(), Box<dyn Error>> {
#[test]
/// will fall in 20 x DT and 2 x 10*DT steps. compare the end result and make
/// log the "error" between both caluclation
/// log the "error" between both calculations
fn fall_dt_speed_diff() -> Result<(), Box<dyn Error>> {
let mut sstate = utils::setup();
let mut fstate = utils::setup();
@ -145,7 +145,7 @@ fn walk_simple() -> Result<(), Box<dyn Error>> {
}
let (pos, vel, _) = utils::get_transform(&state, p1)?;
assert_relative_eq!(pos.0.z, 257.0); // make sure it landed on ground
assert_eq!(vel.0, vek::Vec3::zero());
assert_eq!(vel.0, Vec3::zero());
let mut actions = Controller::default();
actions.inputs.move_dir = Vec2::new(1.0, 0.0);
@ -213,7 +213,7 @@ fn walk_max() -> Result<(), Box<dyn Error>> {
#[test]
/// will run in 20 x DT and 2 x 10*DT steps. compare the end result and make
/// log the "error" between both caluclation
/// log the "error" between both calculations
fn walk_dt_speed_diff() -> Result<(), Box<dyn Error>> {
let mut sstate = utils::setup();
let mut fstate = utils::setup();

2
network/examples/fileshare/main.rs
View File

@ -62,7 +62,7 @@ fn main() {
}
fn file_exists(file: &str) -> Result<(), String> {
let file: std::path::PathBuf = shellexpand::tilde(file).parse().unwrap();
let file: PathBuf = shellexpand::tilde(file).parse().unwrap();
if file.exists() {
Ok(())
} else {

8
network/examples/network-speed/main.rs
View File

@ -192,16 +192,16 @@ fn client(address: ConnectAddr, runtime: Arc<Runtime>) {
}
if id > 2000000 {
println!("Stop");
std::thread::sleep(std::time::Duration::from_millis(2000));
thread::sleep(Duration::from_millis(2000));
break;
}
}
drop(s1);
std::thread::sleep(std::time::Duration::from_millis(2000));
thread::sleep(Duration::from_millis(2000));
info!("Closing participant");
runtime.block_on(p1.disconnect()).unwrap();
std::thread::sleep(std::time::Duration::from_millis(2000));
thread::sleep(Duration::from_millis(2000));
info!("DROPPING! client");
drop(client);
std::thread::sleep(std::time::Duration::from_millis(2000));
thread::sleep(Duration::from_millis(2000));
}

12
network/protocol/benches/protocols.rs
View File

@ -192,8 +192,8 @@ mod utils {
cap: usize,
metrics: Option<ProtocolMetricCache>,
) -> [(MpscSendProtocol<ACDrain>, MpscRecvProtocol<ACSink>); 2] {
let (s1, r1) = async_channel::bounded(cap);
let (s2, r2) = async_channel::bounded(cap);
let (s1, r1) = bounded(cap);
let (s2, r2) = bounded(cap);
let m = metrics.unwrap_or_else(|| {
ProtocolMetricCache::new("mpsc", Arc::new(ProtocolMetrics::new().unwrap()))
});
@ -222,8 +222,8 @@ mod utils {
cap: usize,
metrics: Option<ProtocolMetricCache>,
) -> [(TcpSendProtocol<TcpDrain>, TcpRecvProtocol<TcpSink>); 2] {
let (s1, r1) = async_channel::bounded(cap);
let (s2, r2) = async_channel::bounded(cap);
let (s1, r1) = bounded(cap);
let (s2, r2) = bounded(cap);
let m = metrics.unwrap_or_else(|| {
ProtocolMetricCache::new("tcp", Arc::new(ProtocolMetrics::new().unwrap()))
});
@ -252,8 +252,8 @@ mod utils {
cap: usize,
metrics: Option<ProtocolMetricCache>,
) -> [(QuicSendProtocol<QuicDrain>, QuicRecvProtocol<QuicSink>); 2] {
let (s1, r1) = async_channel::bounded(cap);
let (s2, r2) = async_channel::bounded(cap);
let (s1, r1) = bounded(cap);
let (s2, r2) = bounded(cap);
let m = metrics.unwrap_or_else(|| {
ProtocolMetricCache::new("quic", Arc::new(ProtocolMetrics::new().unwrap()))
});

2
network/protocol/src/frame.rs
View File

@ -461,7 +461,7 @@ mod tests {
}
#[test]
fn initframe_rubish() {
fn initframe_rubbish() {
let mut buffer = BytesMut::from(&b"dtrgwcser"[..]);
assert_eq!(
InitFrame::read_frame(&mut buffer),

4
network/protocol/src/mpsc.rs
View File

@ -202,8 +202,8 @@ pub mod test_utils {
cap: usize,
metrics: Option<ProtocolMetricCache>,
) -> [(MpscSendProtocol<ACDrain>, MpscRecvProtocol<ACSink>); 2] {
let (s1, r1) = async_channel::bounded(cap);
let (s2, r2) = async_channel::bounded(cap);
let (s1, r1) = bounded(cap);
let (s2, r2) = bounded(cap);
let m = metrics.unwrap_or_else(|| {
ProtocolMetricCache::new("mpsc", Arc::new(ProtocolMetrics::new().unwrap()))
});

10
network/protocol/src/quic.rs
View File

@ -543,8 +543,8 @@ mod test_utils {
drop_ratio: f32,
metrics: Option<ProtocolMetricCache>,
) -> [(QuicSendProtocol<QuicDrain>, QuicRecvProtocol<QuicSink>); 2] {
let (s1, r1) = async_channel::bounded(cap);
let (s2, r2) = async_channel::bounded(cap);
let (s1, r1) = bounded(cap);
let (s2, r2) = bounded(cap);
let m = metrics.unwrap_or_else(|| {
ProtocolMetricCache::new("quic", Arc::new(ProtocolMetrics::new().unwrap()))
});
@ -804,8 +804,7 @@ mod tests {
let sid = Sid::new(1);
let (s, r) = async_channel::bounded(10);
let m = ProtocolMetricCache::new("quic", Arc::new(ProtocolMetrics::new().unwrap()));
let mut r =
super::QuicRecvProtocol::new(super::test_utils::QuicSink { receiver: r }, m.clone());
let mut r = super::QuicRecvProtocol::new(QuicSink { receiver: r }, m.clone());
const DATA1: &[u8; 69] =
b"We need to make sure that its okay to send OPEN_STREAM and DATA_HEAD ";
@ -861,8 +860,7 @@ mod tests {
let sid = Sid::new(1);
let (s, r) = async_channel::bounded(10);
let m = ProtocolMetricCache::new("quic", Arc::new(ProtocolMetrics::new().unwrap()));
let mut r =
super::QuicRecvProtocol::new(super::test_utils::QuicSink { receiver: r }, m.clone());
let mut r = super::QuicRecvProtocol::new(QuicSink { receiver: r }, m.clone());
let mut bytes = BytesMut::with_capacity(1500);
OTFrame::OpenStream {

10
network/protocol/src/tcp.rs
View File

@ -360,8 +360,8 @@ mod test_utils {
cap: usize,
metrics: Option<ProtocolMetricCache>,
) -> [(TcpSendProtocol<TcpDrain>, TcpRecvProtocol<TcpSink>); 2] {
let (s1, r1) = async_channel::bounded(cap);
let (s2, r2) = async_channel::bounded(cap);
let (s1, r1) = bounded(cap);
let (s2, r2) = bounded(cap);
let m = metrics.unwrap_or_else(|| {
ProtocolMetricCache::new("tcp", Arc::new(ProtocolMetrics::new().unwrap()))
});
@ -603,8 +603,7 @@ mod tests {
let sid = Sid::new(1);
let (s, r) = async_channel::bounded(10);
let m = ProtocolMetricCache::new("tcp", Arc::new(ProtocolMetrics::new().unwrap()));
let mut r =
super::TcpRecvProtocol::new(super::test_utils::TcpSink { receiver: r }, m.clone());
let mut r = super::TcpRecvProtocol::new(TcpSink { receiver: r }, m.clone());
const DATA1: &[u8; 69] =
b"We need to make sure that its okay to send OPEN_STREAM and DATA_HEAD ";
@ -653,8 +652,7 @@ mod tests {
let sid = Sid::new(1);
let (s, r) = async_channel::bounded(10);
let m = ProtocolMetricCache::new("tcp", Arc::new(ProtocolMetrics::new().unwrap()));
let mut r =
super::TcpRecvProtocol::new(super::test_utils::TcpSink { receiver: r }, m.clone());
let mut r = super::TcpRecvProtocol::new(TcpSink { receiver: r }, m.clone());
let mut bytes = BytesMut::with_capacity(1500);
OTFrame::OpenStream {

50
network/src/api.rs
View File

@ -107,7 +107,7 @@ pub struct Stream {
#[derive(Debug)]
pub enum NetworkError {
NetworkClosed,
ListenFailed(std::io::Error),
ListenFailed(io::Error),
ConnectFailed(NetworkConnectError),
}
@ -117,7 +117,7 @@ pub enum NetworkConnectError {
/// Either a Pid UUID clash or you are trying to hijack a connection
InvalidSecret,
Handshake(InitProtocolError<ProtocolsError>),
Io(std::io::Error),
Io(io::Error),
}
/// Error type thrown by [`Participants`](Participant) methods
@ -160,7 +160,7 @@ pub struct StreamParams {
/// via their [`ConnectAddr`], or [`listen`] passively for [`connected`]
/// [`Participants`] via [`ListenAddr`].
///
/// Too guarantee a clean shutdown, the [`Runtime`] MUST NOT be droped before
/// Too guarantee a clean shutdown, the [`Runtime`] MUST NOT be dropped before
/// the Network.
///
/// # Examples
@ -168,7 +168,7 @@ pub struct StreamParams {
/// use tokio::runtime::Runtime;
/// use veloren_network::{Network, ConnectAddr, ListenAddr, Pid};
///
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// // Create a Network, listen on port `2999` to accept connections and connect to port `8080` to connect to a (pseudo) database Application
/// let runtime = Runtime::new().unwrap();
/// let network = Network::new(Pid::new(), &runtime);
@ -272,7 +272,7 @@ impl Network {
#[cfg(feature = "metrics")] registry: Option<&Registry>,
) -> Self {
let p = participant_id;
let span = tracing::info_span!("network", ?p);
let span = info_span!("network", ?p);
span.in_scope(|| trace!("Starting Network"));
let (scheduler, listen_sender, connect_sender, connected_receiver, shutdown_sender) =
Scheduler::new(
@ -295,7 +295,7 @@ impl Network {
scheduler.run().await;
trace!("Stopping scheduler and his own thread");
}
.instrument(tracing::info_span!("network", ?p)),
.instrument(info_span!("network", ?p)),
);
Self {
local_pid: participant_id,
@ -340,7 +340,7 @@ impl Network {
/// [`ListenAddr`]: crate::api::ListenAddr
#[instrument(name="network", skip(self, address), fields(p = %self.local_pid))]
pub async fn listen(&self, address: ListenAddr) -> Result<(), NetworkError> {
let (s2a_result_s, s2a_result_r) = oneshot::channel::<tokio::io::Result<()>>();
let (s2a_result_s, s2a_result_r) = oneshot::channel::<io::Result<()>>();
debug!(?address, "listening on address");
self.listen_sender
.lock()
@ -428,7 +428,7 @@ impl Network {
/// use tokio::runtime::Runtime;
/// use veloren_network::{ConnectAddr, ListenAddr, Network, Pid};
///
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// // Create a Network, listen on port `2020` TCP and opens returns their Pid
/// let runtime = Runtime::new().unwrap();
/// let network = Network::new(Pid::new(), &runtime);
@ -516,7 +516,7 @@ impl Network {
};
if let Ok(return_s) = return_s {
if return_s.send(()).is_err() {
warn!("Network::drop stoped after a timeout and didn't wait for our shutdown");
warn!("Network::drop stopped after a timeout and didn't wait for our shutdown");
};
}
debug!("Network has shut down");
@ -550,7 +550,7 @@ impl Participant {
/// # Arguments
/// * `prio` - defines which stream is processed first when limited on
/// bandwidth. See [`Prio`] for documentation.
/// * `promises` - use a combination of you prefered [`Promises`], see the
/// * `promises` - use a combination of you preferred [`Promises`], see the
/// link for further documentation. You can combine them, e.g.
/// `Promises::ORDERED | Promises::CONSISTENCY` The Stream will then
/// guarantee that those promises are met.
@ -567,7 +567,7 @@ impl Participant {
/// use tokio::runtime::Runtime;
/// use veloren_network::{ConnectAddr, ListenAddr, Network, Pid, Promises};
///
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// // Create a Network, connect on port 2100 and open a stream
/// let runtime = Runtime::new().unwrap();
/// let network = Network::new(Pid::new(), &runtime);
@ -634,7 +634,7 @@ impl Participant {
/// use tokio::runtime::Runtime;
/// use veloren_network::{Network, Pid, ListenAddr, ConnectAddr, Promises};
///
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// // Create a Network, connect on port 2110 and wait for the other side to open a stream
/// // Note: It's quite unusual to actively connect, but then wait on a stream to be connected, usually the Application taking initiative want's to also create the first Stream.
/// let runtime = Runtime::new().unwrap();
@ -691,7 +691,7 @@ impl Participant {
/// use tokio::runtime::Runtime;
/// use veloren_network::{Network, Pid, ListenAddr, ConnectAddr};
///
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// // Create a Network, listen on port `2030` TCP and opens returns their Pid and close connection.
/// let runtime = Runtime::new().unwrap();
/// let network = Network::new(Pid::new(), &runtime);
@ -775,7 +775,7 @@ impl Participant {
/// use tokio::runtime::Runtime;
/// use veloren_network::{Network, Pid, ListenAddr, ConnectAddr, Promises, ParticipantEvent};
///
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// // Create a Network, connect on port 2040 and wait for the other side to open a stream
/// // Note: It's quite unusual to actively connect, but then wait on a stream to be connected, usually the Application taking initiative want's to also create the first Stream.
/// let runtime = Runtime::new().unwrap();
@ -889,7 +889,7 @@ impl Stream {
/// use tokio::runtime::Runtime;
/// use veloren_network::{Network, ListenAddr, ConnectAddr, Pid};
///
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// // Create a Network, listen on Port `2200` and wait for a Stream to be opened, then answer `Hello World`
/// let runtime = Runtime::new().unwrap();
/// let network = Network::new(Pid::new(), &runtime);
@ -931,7 +931,7 @@ impl Stream {
/// use bincode;
/// use veloren_network::{Network, ListenAddr, ConnectAddr, Pid, Message};
///
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// let runtime = Runtime::new().unwrap();
/// let network = Network::new(Pid::new(), &runtime);
/// # let remote1 = Network::new(Pid::new(), &runtime);
@ -999,7 +999,7 @@ impl Stream {
/// use tokio::runtime::Runtime;
/// use veloren_network::{Network, ListenAddr, ConnectAddr, Pid};
///
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// // Create a Network, listen on Port `2220` and wait for a Stream to be opened, then listen on it
/// let runtime = Runtime::new().unwrap();
/// let network = Network::new(Pid::new(), &runtime);
@ -1033,7 +1033,7 @@ impl Stream {
/// use tokio::runtime::Runtime;
/// use veloren_network::{Network, ListenAddr, ConnectAddr, Pid};
///
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// // Create a Network, listen on Port `2230` and wait for a Stream to be opened, then listen on it
/// let runtime = Runtime::new().unwrap();
/// let network = Network::new(Pid::new(), &runtime);
@ -1089,7 +1089,7 @@ impl Stream {
/// use tokio::runtime::Runtime;
/// use veloren_network::{Network, ListenAddr, ConnectAddr, Pid};
///
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// // Create a Network, listen on Port `2240` and wait for a Stream to be opened, then listen on it
/// let runtime = Runtime::new().unwrap();
/// let network = Network::new(Pid::new(), &runtime);
@ -1141,7 +1141,7 @@ impl Stream {
}
}
impl core::cmp::PartialEq for Participant {
impl PartialEq for Participant {
fn eq(&self, other: &Self) -> bool {
//don't check local_pid, 2 Participant from different network should match if
// they are the "same"
@ -1177,7 +1177,7 @@ where
},
Err(TryRecvError::Closed) => panic!("{}{}", name, CHANNEL_ERR),
Err(TryRecvError::Empty) => {
trace!("activly sleeping");
trace!("actively sleeping");
cnt += 1;
if cnt > 10 {
error!("Timeout waiting for shutdown, dropping");
@ -1222,7 +1222,7 @@ impl Drop for Participant {
debug!("Shutting down Participant");
match self.a2s_disconnect_s.try_lock() {
Err(e) => debug!(?e, "Participant is beeing dropped by Network right now"),
Err(e) => debug!(?e, "Participant is being dropped by Network right now"),
Ok(mut s) => match s.take() {
None => info!("Participant already has been shutdown gracefully"),
Some(a2s_disconnect_s) => {
@ -1293,8 +1293,8 @@ impl From<oneshot::error::RecvError> for NetworkError {
fn from(_err: oneshot::error::RecvError) -> Self { NetworkError::NetworkClosed }
}
impl From<std::io::Error> for NetworkError {
fn from(_err: std::io::Error) -> Self { NetworkError::NetworkClosed }
impl From<io::Error> for NetworkError {
fn from(_err: io::Error) -> Self { NetworkError::NetworkClosed }
}
impl From<Box<bincode::ErrorKind>> for StreamError {
@ -1346,7 +1346,7 @@ impl core::fmt::Display for NetworkConnectError {
}
/// implementing PartialEq as it's super convenient in tests
impl core::cmp::PartialEq for StreamError {
impl PartialEq for StreamError {
fn eq(&self, other: &Self) -> bool {
match self {
StreamError::StreamClosed => match other {

22
network/src/channel.rs
View File

@ -94,7 +94,7 @@ impl Protocols {
metrics: Arc<ProtocolMetrics>,
s2s_stop_listening_r: oneshot::Receiver<()>,
c2s_protocol_s: mpsc::UnboundedSender<C2sProtocol>,
) -> std::io::Result<()> {
) -> io::Result<()> {
use socket2::{Domain, Socket, Type};
let domain = Domain::for_address(addr);
let socket2_socket = Socket::new(domain, Type::STREAM, None)?;
@ -109,7 +109,7 @@ impl Protocols {
socket2_socket.bind(&socket2_addr)?;
socket2_socket.listen(1024)?;
let std_listener: std::net::TcpListener = socket2_socket.into();
let listener = tokio::net::TcpListener::from_std(std_listener)?;
let listener = net::TcpListener::from_std(std_listener)?;
trace!(?addr, "Tcp Listener bound");
let mut end_receiver = s2s_stop_listening_r.fuse();
tokio::spawn(async move {
@ -143,7 +143,7 @@ impl Protocols {
Ok(())
}
pub(crate) fn new_tcp(stream: tokio::net::TcpStream, metrics: ProtocolMetricCache) -> Self {
pub(crate) fn new_tcp(stream: net::TcpStream, metrics: ProtocolMetricCache) -> Self {
let (r, w) = stream.into_split();
let sp = TcpSendProtocol::new(TcpDrain { half: w }, metrics.clone());
let rp = TcpRecvProtocol::new(
@ -453,14 +453,14 @@ impl network_protocol::RecvProtocol for RecvProtocols {
#[derive(Debug)]
pub enum MpscError {
Send(tokio::sync::mpsc::error::SendError<network_protocol::MpscMsg>),
Send(mpsc::error::SendError<MpscMsg>),
Recv,
}
#[cfg(feature = "quic")]
#[derive(Debug)]
pub enum QuicError {
Send(std::io::Error),
Send(io::Error),
Connection(quinn::ConnectionError),
Write(quinn::WriteError),
Read(quinn::ReadError),
@ -470,8 +470,8 @@ pub enum QuicError {
/// Error types for Protocols
#[derive(Debug)]
pub enum ProtocolsError {
Tcp(std::io::Error),
Udp(std::io::Error),
Tcp(io::Error),
Udp(io::Error),
#[cfg(feature = "quic")]
Quic(QuicError),
Mpsc(MpscError),
@ -527,12 +527,12 @@ impl UnreliableSink for TcpSink {
//// MPSC
#[derive(Debug)]
pub struct MpscDrain {
sender: tokio::sync::mpsc::Sender<MpscMsg>,
sender: mpsc::Sender<MpscMsg>,
}
#[derive(Debug)]
pub struct MpscSink {
receiver: tokio::sync::mpsc::Receiver<MpscMsg>,
receiver: mpsc::Receiver<MpscMsg>,
}
#[async_trait]
@ -623,7 +623,7 @@ impl UnreliableDrain for QuicDrain {
match self.reliables.entry(sid) {
Entry::Occupied(mut occupied) => occupied.get_mut().write_all(&data.data).await,
Entry::Vacant(vacant) => {
// IF the buffer is empty this was created localy and WE are allowed to
// IF the buffer is empty this was created locally and WE are allowed to
// open_bi(), if not, we NEED to block on sendstreams_r
if data.data.is_empty() {
let (mut sendstream, recvstream) =
@ -666,7 +666,7 @@ impl UnreliableSink for QuicSink {
let (mut buffer, result, mut recvstream, id) = loop {
use futures_util::FutureExt;
// first handle all bi streams!
let (a, b) = tokio::select! {
let (a, b) = select! {
biased;
Some(n) = self.bi.next().fuse() => (Some(n), None),
Some(n) = self.recvstreams_r.recv().fuse() => (None, Some(n)),

6
network/src/lib.rs
View File

@ -44,7 +44,7 @@
//! use veloren_network::{ConnectAddr, ListenAddr, Network, Pid, Promises};
//!
//! // Client
//! async fn client(runtime: &Runtime) -> std::result::Result<(), Box<dyn std::error::Error>> {
//! async fn client(runtime: &Runtime) -> Result<(), Box<dyn std::error::Error>> {
//! sleep(std::time::Duration::from_secs(1)).await; // `connect` MUST be after `listen`
//! let client_network = Network::new(Pid::new(), runtime);
//! let server = client_network
@ -58,7 +58,7 @@
//! }
//!
//! // Server
//! async fn server(runtime: &Runtime) -> std::result::Result<(), Box<dyn std::error::Error>> {
//! async fn server(runtime: &Runtime) -> Result<(), Box<dyn std::error::Error>> {
//! let server_network = Network::new(Pid::new(), runtime);
//! server_network
//! .listen(ListenAddr::Tcp("127.0.0.1:12345".parse().unwrap()))
@ -71,7 +71,7 @@
//! Ok(())
//! }
//!
//! fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
//! fn main() -> Result<(), Box<dyn std::error::Error>> {
//! let runtime = Runtime::new().unwrap();
//! runtime.block_on(async {
//! let (result_c, result_s) = join!(client(&runtime), server(&runtime),);

2
network/src/message.rs
View File

@ -75,7 +75,7 @@ impl Message {
/// # use tokio::runtime::Runtime;
/// # use std::sync::Arc;
///
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// // Create a Network, listen on Port `2300` and wait for a Stream to be opened, then listen on it
/// # let runtime = Runtime::new().unwrap();
/// # let network = Network::new(Pid::new(), &runtime);

2
network/src/metrics.rs
View File

@ -175,7 +175,7 @@ impl NetworkMetrics {
Ok(())
}
pub(crate) fn connect_requests_cache(&self, protocol: &ListenAddr) -> prometheus::IntCounter {
pub(crate) fn connect_requests_cache(&self, protocol: &ListenAddr) -> IntCounter {
self.incoming_connections_total
.with_label_values(&[protocollisten_name(protocol)])
}

6
network/src/participant.rs
View File

@ -474,7 +474,7 @@ impl BParticipant {
recv_protocols.is_empty()
};
let mut defered_orphan = DeferredTracer::new(tracing::Level::WARN);
let mut defered_orphan = DeferredTracer::new(Level::WARN);
loop {
let (event, addp, remp) = select!(
@ -705,7 +705,7 @@ impl BParticipant {
.map(|(timeout_time, _)| *timeout_time)
.unwrap_or_default(),
);
let timeout = tokio::select! {
let timeout = select! {
_ = wait_for_manager() => false,
_ = timeout => true,
};
@ -825,7 +825,7 @@ mod tests {
watch::Receiver<f32>,
JoinHandle<()>,
) {
let runtime = Arc::new(tokio::runtime::Runtime::new().unwrap());
let runtime = Arc::new(Runtime::new().unwrap());
let runtime_clone = Arc::clone(&runtime);
let (b2s_prio_statistic_s, b2s_prio_statistic_r) =

6
network/src/scheduler.rs
View File

@ -402,7 +402,7 @@ impl Scheduler {
use network_protocol::InitProtocol;
let init_result = protocol
.initialize(send_handshake, local_pid, local_secret)
.instrument(tracing::info_span!("handshake", ?cid))
.instrument(info_span!("handshake", ?cid))
.await;
match init_result {
Ok((pid, sid, secret)) => {
@ -447,7 +447,7 @@ impl Scheduler {
tokio::spawn(
bparticipant
.run(participant_channels.b2s_prio_statistic_s)
.instrument(tracing::info_span!("remote", ?p)),
.instrument(info_span!("remote", ?p)),
);
//create a new channel within BParticipant and wait for it to run
let (b2s_create_channel_done_s, b2s_create_channel_done_r) =
@ -516,7 +516,7 @@ impl Scheduler {
},
}
}
.instrument(tracing::info_span!("")),
.instrument(info_span!("")),
); /*WORKAROUND FOR SPAN NOT TO GET LOST*/
}
}

4
network/tests/helper.rs
View File

@ -15,11 +15,11 @@ use veloren_network::{ConnectAddr, ListenAddr, Network, Participant, Pid, Promis
// sleep time when only internal rust calculations are done
#[allow(dead_code)]
pub const SLEEP_INTERNAL: std::time::Duration = std::time::Duration::from_millis(3000);
pub const SLEEP_INTERNAL: Duration = Duration::from_millis(3000);
// sleep time when we interact with the system, e.g. actually send TCP/UDP
// package
#[allow(dead_code)]
pub const SLEEP_EXTERNAL: std::time::Duration = std::time::Duration::from_millis(5000);
pub const SLEEP_EXTERNAL: Duration = Duration::from_millis(5000);
#[allow(dead_code)]
pub fn setup(tracing: bool, sleep: u64) -> (u64, u64) {

8
network/tests/integration.rs
View File

@ -118,7 +118,7 @@ fn stream_simple_udp_3msg() {
#[test]
#[ignore]
fn tcp_and_udp_2_connections() -> std::result::Result<(), Box<dyn std::error::Error>> {
fn tcp_and_udp_2_connections() -> Result<(), Box<dyn std::error::Error>> {
let (_, _) = helper::setup(false, 0);
let r = Arc::new(Runtime::new().unwrap());
let network = Network::new(Pid::new(), &r);
@ -145,7 +145,7 @@ fn tcp_and_udp_2_connections() -> std::result::Result<(), Box<dyn std::error::Er
#[test]
#[ignore]
fn failed_listen_on_used_ports() -> std::result::Result<(), Box<dyn std::error::Error>> {
fn failed_listen_on_used_ports() -> Result<(), Box<dyn std::error::Error>> {
let (_, _) = helper::setup(false, 0);
let r = Arc::new(Runtime::new().unwrap());
let network = Network::new(Pid::new(), &r);
@ -176,7 +176,7 @@ fn failed_listen_on_used_ports() -> std::result::Result<(), Box<dyn std::error::
/// So i rather put the same test into a unit test, these are now duplicate to
/// the api, but are left here, just to be save!
#[test]
fn api_stream_send_main() -> std::result::Result<(), Box<dyn std::error::Error>> {
fn api_stream_send_main() -> Result<(), Box<dyn std::error::Error>> {
let (_, _) = helper::setup(false, 0);
// Create a Network, listen on Port `1200` and wait for a Stream to be opened,
// then answer `Hello World`
@ -205,7 +205,7 @@ fn api_stream_send_main() -> std::result::Result<(), Box<dyn std::error::Error>>
}
#[test]
fn api_stream_recv_main() -> std::result::Result<(), Box<dyn std::error::Error>> {
fn api_stream_recv_main() -> Result<(), Box<dyn std::error::Error>> {
let (_, _) = helper::setup(false, 0);
// Create a Network, listen on Port `1220` and wait for a Stream to be opened,
// then listen on it

4
nix/README.md
View File

@ -8,7 +8,7 @@ We include instructions for Nix without flakes enabled, but using flakes is the
See the [NixOS wiki](https://nixos.wiki/wiki/Flakes) for information on how to enable and use flakes.
It is recommended to first setup the [Cachix](https://cachix.org) cache to save time with builds:
It is recommended to first set up the [Cachix](https://cachix.org) cache to save time with builds:
```shell
nix shell nixpkgs#cachix -c cachix use veloren-nix
# or if you don't have flakes:
@ -16,7 +16,7 @@ nix-shell -p cachix --run "cachix use veloren-nix"
```
As this repository uses `git-lfs`, please make sure `git-lfs` is in your path.
If you have a locally cloned repo, you can make sure it is setup with:
If you have a locally cloned repo, you can make sure it is set up with:
```shell
git lfs install --local && git lfs fetch && git lfs checkout
```

2
plugin/api/src/lib.rs
View File

@ -121,7 +121,7 @@ pub mod event {
/// #[event_handler]
/// pub fn on_command_testplugin(command: ChatCommandEvent) -> Result<Vec<String>, String> {
/// Ok(vec![format!(
/// "Player of id {:?} named {} with {:?} sended command with args {:?}",
/// "Player of id {:?} named {} with {:?} sent command with args {:?}",
/// command.player.id,
/// command
/// .player

4
plugin/rt/src/lib.rs
View File

@ -55,7 +55,7 @@ pub fn read_input<T>(ptr: i64, len: i64) -> Result<T, &'static str>
where
T: DeserializeOwned,
{
let slice = unsafe { ::std::slice::from_raw_parts(from_i64(ptr) as _, from_i64(len) as _) };
let slice = unsafe { std::slice::from_raw_parts(from_i64(ptr) as _, from_i64(len) as _) };
bincode::deserialize(slice).map_err(|_| "Failed to deserialize function input")
}
@ -100,7 +100,7 @@ static mut BUFFERS: Vec<u8> = Vec::new();
/// Allocate buffer from wasm linear memory
/// # Safety
/// This function should never be used only intented to by used by the host
/// This function should never be used only intended to by used by the host
#[no_mangle]
pub unsafe fn wasm_prepare_buffer(size: i32) -> i64 {
BUFFERS = vec![0u8; size as usize];

2
server-cli/src/settings.rs
View File

@ -31,7 +31,7 @@ impl Settings {
let mut new_path = path.to_owned();
new_path.pop();
new_path.push("settings.invalid.ron");
if let Err(e) = std::fs::rename(&path, &new_path) {
if let Err(e) = fs::rename(&path, &new_path) {
warn!(?e, ?path, ?new_path, "Failed to rename settings file.");
}
},

2
server-cli/src/tui_runner.rs
View File

@ -100,7 +100,7 @@ impl Tui {
},
Ok(_) => {
debug!(?line, "basic mode: command entered");
crate::cli::parse_command(line.trim(), &mut msg_s);
cli::parse_command(line.trim(), &mut msg_s);
},
}
}

6
server/src/client.rs
View File

@ -101,7 +101,7 @@ impl Client {
| ServerGeneral::CharacterSuccess => {
self.character_screen_stream.lock().unwrap().send(g)
},
//Ingame related
//In-game related
ServerGeneral::GroupUpdate(_)
| ServerGeneral::Invite { .. }
| ServerGeneral::InvitePending(_)
@ -175,7 +175,7 @@ impl Client {
| ServerGeneral::CharacterSuccess => {
PreparedMsg::new(1, &g, &self.character_screen_stream_params)
},
//Ingame related
//In-game related
ServerGeneral::GroupUpdate(_)
| ServerGeneral::Invite { .. }
| ServerGeneral::InvitePending(_)
@ -192,7 +192,7 @@ impl Client {
| ServerGeneral::WeatherUpdate(_) => {
PreparedMsg::new(2, &g, &self.in_game_stream_params)
},
//Ingame related, terrain
//In-game related, terrain
ServerGeneral::TerrainChunkUpdate { .. }
| ServerGeneral::LodZoneUpdate { .. }
| ServerGeneral::TerrainBlockUpdates(_) => {

72
server/src/cmd.rs
View File

@ -273,7 +273,7 @@ fn uuid(server: &Server, entity: EcsEntity, descriptor: &str) -> CmdResult<Uuid>
.ok_or_else(|| format!("Cannot get player information for {:?}", descriptor))
}
fn real_role(server: &Server, uuid: Uuid, descriptor: &str) -> CmdResult<comp::AdminRole> {
fn real_role(server: &Server, uuid: Uuid, descriptor: &str) -> CmdResult<AdminRole> {
server
.editable_settings()
.admins
@ -294,7 +294,7 @@ fn uid(server: &Server, target: EcsEntity, descriptor: &str) -> CmdResult<Uid> {
.ok_or_else(|| format!("Cannot get uid for {:?}", descriptor))
}
fn area(server: &mut Server, area_name: &str) -> CmdResult<depot::Id<vek::Aabb<i32>>> {
fn area(server: &mut Server, area_name: &str) -> CmdResult<depot::Id<Aabb<i32>>> {
server
.state
.mut_resource::<BuildAreas>()
@ -458,13 +458,13 @@ fn handle_drop_all(
if let Some(mut inventory) = server
.state
.ecs()
.write_storage::<comp::Inventory>()
.write_storage::<Inventory>()
.get_mut(target)
{
items = inventory.drain().collect();
}
let mut rng = rand::thread_rng();
let mut rng = thread_rng();
let item_to_place = items
.into_iter()
@ -512,7 +512,7 @@ fn handle_give_item(
server
.state
.ecs()
.write_storage::<comp::Inventory>()
.write_storage::<Inventory>()
.get_mut(target)
.map(|mut inv| {
// NOTE: Deliberately ignores items that couldn't be pushed.
@ -530,7 +530,7 @@ fn handle_give_item(
server
.state
.ecs()
.write_storage::<comp::Inventory>()
.write_storage::<Inventory>()
.get_mut(target)
.map(|mut inv| {
for i in 0..give_amount {
@ -618,7 +618,7 @@ fn handle_make_npc(
Err(_err) => return Err(format!("Failed to load entity config: {}", entity_config)),
};
let mut loadout_rng = rand::thread_rng();
let mut loadout_rng = thread_rng();
for _ in 0..number {
let comp::Pos(pos) = position(server, target, "target")?;
let entity_info = EntityInfo::at(pos).with_entity_config(
@ -861,7 +861,7 @@ fn handle_home(
_action: &ServerChatCommand,
) -> CmdResult<()> {
let home_pos = server.state.mut_resource::<SpawnPoint>().0;
let time = *server.state.mut_resource::<common::resources::Time>();
let time = *server.state.mut_resource::<Time>();
position_mut(server, target, "target", |current_pos| {
current_pos.0 = home_pos
@ -972,12 +972,12 @@ fn handle_time(
// 'developer commentary' mode created by digging up the long-decayed
// skeletons of the Veloren team, measuring various attributes of their
// jawlines, and using them to recreate their voices. But how to go about
// this Herculean task? This code is jibberish! The last of the core Rust
// this Herculean task? This code is gibberish! The last of the core Rust
// dev team died exactly 337,194 years ago! Rust is now a long-forgotten
// dialect of the ancient ones, lost to the sands of time. Ashes to ashes,
// dust to dust. When all hope is lost, one particularly intrepid
// post-human hominid exployed by the 'Veloren Revival Corp' (no doubt we
// still won't have gotted rid of this blasted 'capitalism' thing by then)
// still won't have gotten rid of this blasted 'capitalism' thing by then)
// might notice, after years of searching, a particularly curious
// inscription within the code. The letters `D`, `A`, `Y`. Curious! She
// consults the post-human hominid scholars of the old. Care to empathise
@ -986,7 +986,7 @@ fn handle_time(
// 'day' in the post-human hominid language, which is of course universal.
// Imagine also her surprise when, after much further translating, she
// finds a comment predicting her very existence and her struggle to
// decode this great mystery. Rejoyce! The Veloren Revival Corp. may now
// decode this great mystery. Rejoice! The Veloren Revival Corp. may now
// persist with their great Ultimate Edition DLC because the day period
// might now be changed because they have found the constant that controls
// it! Everybody was henceforth happy until the end of time.
@ -1170,8 +1170,8 @@ fn handle_spawn(
for _ in 0..amount {
let vel = Vec3::new(
rand::thread_rng().gen_range(-2.0..3.0),
rand::thread_rng().gen_range(-2.0..3.0),
thread_rng().gen_range(-2.0..3.0),
thread_rng().gen_range(-2.0..3.0),
10.0,
);
@ -1208,10 +1208,10 @@ fn handle_spawn(
pet_entity: new_entity,
});
} else if let Some(group) = match alignment {
comp::Alignment::Wild => None,
comp::Alignment::Passive => None,
comp::Alignment::Enemy => Some(comp::group::ENEMY),
comp::Alignment::Npc | comp::Alignment::Tame => Some(comp::group::NPC),
Alignment::Wild => None,
Alignment::Passive => None,
Alignment::Enemy => Some(comp::group::ENEMY),
Alignment::Npc | Alignment::Tame => Some(comp::group::NPC),
comp::Alignment::Owned(_) => unreachable!(),
} {
insert_or_replace_component(server, new_entity, group, "new entity")?;
@ -1249,8 +1249,8 @@ fn handle_spawn_training_dummy(
) -> CmdResult<()> {
let pos = position(server, target, "target")?;
let vel = Vec3::new(
rand::thread_rng().gen_range(-2.0..3.0),
rand::thread_rng().gen_range(-2.0..3.0),
thread_rng().gen_range(-2.0..3.0),
thread_rng().gen_range(-2.0..3.0),
10.0,
);
@ -1302,7 +1302,7 @@ fn handle_spawn_airship(
200.0,
)
});
let mut rng = rand::thread_rng();
let mut rng = thread_rng();
let ship = comp::ship::Body::random_airship_with(&mut rng);
let mut builder = server
.state
@ -1350,7 +1350,7 @@ fn handle_spawn_ship(
200.0,
)
});
let mut rng = rand::thread_rng();
let mut rng = thread_rng();
let ship = comp::ship::Body::random_ship_with(&mut rng);
let mut builder = server
.state
@ -1782,11 +1782,11 @@ fn handle_help(
Ok(())
}
fn parse_alignment(owner: Uid, alignment: &str) -> CmdResult<comp::Alignment> {
fn parse_alignment(owner: Uid, alignment: &str) -> CmdResult<Alignment> {
match alignment {
"wild" => Ok(comp::Alignment::Wild),
"enemy" => Ok(comp::Alignment::Enemy),
"npc" => Ok(comp::Alignment::Npc),
"wild" => Ok(Alignment::Wild),
"enemy" => Ok(Alignment::Enemy),
"npc" => Ok(Alignment::Npc),
"pet" => Ok(comp::Alignment::Owned(owner)),
_ => Err(format!("Invalid alignment: {:?}", alignment)),
}
@ -1808,7 +1808,7 @@ fn handle_kill_npcs(
let ecs = server.state.ecs();
let mut healths = ecs.write_storage::<comp::Health>();
let players = ecs.read_storage::<comp::Player>();
let alignments = ecs.read_storage::<comp::Alignment>();
let alignments = ecs.read_storage::<Alignment>();
let mut count = 0;
for (mut health, (), alignment) in (&mut healths, !&players, alignments.maybe()).join() {
@ -1907,7 +1907,7 @@ where
server
.state()
.ecs()
.write_storage::<comp::Inventory>()
.write_storage::<Inventory>()
.get_mut(target),
server.state.ecs().write_storage::<comp::InventoryUpdate>(),
) {
@ -1918,7 +1918,7 @@ where
let mut rng = thread_rng();
for (item_id, quantity) in kit {
let mut item = match &item_id {
KitSpec::Item(item_id) => comp::Item::new_from_asset(item_id)
KitSpec::Item(item_id) => Item::new_from_asset(item_id)
.map_err(|_| format!("Unknown item: {:#?}", item_id))?,
KitSpec::ModularWeapon { tool, material } => {
comp::item::modular::random_weapon(*tool, *material, None, &mut rng)
@ -2029,7 +2029,7 @@ fn handle_light(
let (opt_r, opt_g, opt_b, opt_x, opt_y, opt_z, opt_s) =
parse_cmd_args!(args, f32, f32, f32, f32, f32, f32, f32);
let mut light_emitter = comp::LightEmitter::default();
let mut light_emitter = LightEmitter::default();
let mut light_offset_opt = None;
if let (Some(r), Some(g), Some(b)) = (opt_r, opt_g, opt_b) {
@ -2083,7 +2083,7 @@ fn handle_lantern(
if let Some(mut light) = server
.state
.ecs()
.write_storage::<comp::LightEmitter>()
.write_storage::<LightEmitter>()
.get_mut(target)
{
light.strength = s.max(0.1).min(10.0);
@ -2181,7 +2181,7 @@ fn handle_waypoint(
_action: &ServerChatCommand,
) -> CmdResult<()> {
let pos = position(server, target, "target")?;
let time = *server.state.mut_resource::<common::resources::Time>();
let time = *server.state.mut_resource::<Time>();
insert_or_replace_component(
server,
target,
@ -2778,7 +2778,7 @@ spawn_rate {:?} "#,
server.notify_client(client, ServerGeneral::server_msg(ChatType::CommandInfo, s));
Ok(())
} else {
Err("Not a pregenerated chunk.".into())
Err("Not a pre-generated chunk.".into())
}
}
@ -2897,8 +2897,8 @@ fn handle_remove_lights(
for (entity, pos, _, _, _) in (
&ecs.entities(),
&ecs.read_storage::<comp::Pos>(),
&ecs.read_storage::<comp::LightEmitter>(),
!&ecs.read_storage::<comp::WaypointArea>(),
&ecs.read_storage::<LightEmitter>(),
!&ecs.read_storage::<WaypointArea>(),
!&ecs.read_storage::<comp::Player>(),
)
.join()
@ -3072,7 +3072,7 @@ fn kick_player(
.mut_resource::<EventBus<ServerEvent>>()
.emit_now(ServerEvent::ClientDisconnect(
target_player,
common::comp::DisconnectReason::Kicked,
comp::DisconnectReason::Kicked,
));
Ok(())
}
@ -3131,7 +3131,7 @@ fn handle_ban(
.map(|duration| chrono::Duration::from_std(duration.into()))
.transpose()
.map_err(|err| format!("Error converting to duration: {}", err))?
// On overflow (someone adding some ridiculous timespan), just make the ban infinite.
// On overflow (someone adding some ridiculous time span), just make the ban infinite.
.and_then(|duration| now.checked_add_signed(duration));
let ban_info = BanInfo {

3
server/src/connection_handler.rs
View File

@ -68,7 +68,8 @@ impl ConnectionHandler {
Some(Err(e)) => {
error!(
?e,
"Stopping Conection Handler, no new connections can be made to server now!"
"Stopping Connection Handler, no new connections can be made to server \
now!"
);
break;
},

12
server/src/events/entity_creation.rs
View File

@ -131,7 +131,7 @@ pub fn handle_create_npc(
.map(|g| (g, c))
})
.map(|(g, c)| {
// Might be unneccessary, but maybe pets can somehow have map
// Might be unnecessary, but maybe pets can somehow have map
// markers in the future
update_map_markers(&map_markers, &uids, c, &group_change);
c.send_fallible(ServerGeneral::GroupUpdate(g));
@ -140,10 +140,10 @@ pub fn handle_create_npc(
);
}
} else if let Some(group) = match alignment {
comp::Alignment::Wild => None,
comp::Alignment::Passive => None,
comp::Alignment::Enemy => Some(comp::group::ENEMY),
comp::Alignment::Npc | comp::Alignment::Tame => Some(comp::group::NPC),
Alignment::Wild => None,
Alignment::Passive => None,
Alignment::Enemy => Some(comp::group::ENEMY),
Alignment::Npc | Alignment::Tame => Some(comp::group::NPC),
comp::Alignment::Owned(_) => unreachable!(),
} {
let _ = server.state.ecs().write_storage().insert(new_entity, group);
@ -152,7 +152,7 @@ pub fn handle_create_npc(
pub fn handle_create_ship(
server: &mut Server,
pos: comp::Pos,
pos: Pos,
ship: comp::ship::Body,
mountable: bool,
agent: Option<Agent>,

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

@ -172,7 +172,7 @@ pub fn handle_destroy(server: &mut Server, entity: EcsEntity, last_change: Healt
// one, we probably don't care about emitting death outcome)
if state
.ecs()
.read_storage::<comp::CharacterState>()
.read_storage::<CharacterState>()
.get(entity)
.is_some()
{
@ -225,7 +225,7 @@ pub fn handle_destroy(server: &mut Server, entity: EcsEntity, last_change: Healt
let inventories = state.ecs().read_storage::<Inventory>();
let players = state.ecs().read_storage::<Player>();
let bodies = state.ecs().read_storage::<Body>();
let poises = state.ecs().read_storage::<comp::Poise>();
let poises = state.ecs().read_storage::<Poise>();
let positions = state.ecs().read_storage::<Pos>();
let groups = state.ecs().read_storage::<Group>();
@ -307,7 +307,7 @@ pub fn handle_destroy(server: &mut Server, entity: EcsEntity, last_change: Healt
let alignments = state.ecs().read_storage::<Alignment>();
let uids = state.ecs().read_storage::<Uid>();
let mut outcomes = state.ecs().write_resource::<EventBus<Outcome>>();
let inventories = state.ecs().read_storage::<comp::Inventory>();
let inventories = state.ecs().read_storage::<Inventory>();
let destroyed_group = groups.get(entity);
@ -416,7 +416,7 @@ pub fn handle_destroy(server: &mut Server, entity: EcsEntity, last_change: Healt
.map(|e| error!(?e, ?entity, "Failed to insert ForceUpdate on dead client"));
state
.ecs()
.write_storage::<comp::Energy>()
.write_storage::<Energy>()
.get_mut(entity)
.map(|mut energy| {
let energy = &mut *energy;
@ -424,11 +424,11 @@ pub fn handle_destroy(server: &mut Server, entity: EcsEntity, last_change: Healt
});
let _ = state
.ecs()
.write_storage::<comp::CharacterState>()
.insert(entity, comp::CharacterState::default());
.write_storage::<CharacterState>()
.insert(entity, CharacterState::default());
false
} else if state.ecs().read_storage::<comp::Agent>().contains(entity)
} else if state.ecs().read_storage::<Agent>().contains(entity)
&& !matches!(
state.ecs().read_storage::<comp::Alignment>().get(entity),
Some(comp::Alignment::Owned(_))
@ -445,7 +445,7 @@ pub fn handle_destroy(server: &mut Server, entity: EcsEntity, last_change: Healt
};
if let Some(item) = item {
let pos = state.ecs().read_storage::<comp::Pos>().get(entity).cloned();
let pos = state.ecs().read_storage::<Pos>().get(entity).cloned();
let vel = state.ecs().read_storage::<comp::Vel>().get(entity).cloned();
if let Some(pos) = pos {
// Remove entries where zero exp was awarded - this happens because some
@ -471,7 +471,7 @@ pub fn handle_destroy(server: &mut Server, entity: EcsEntity, last_change: Healt
} else {
let uid = state
.ecs()
.read_storage::<comp::Body>()
.read_storage::<Body>()
.get(winner)
.and_then(|body| {
// Only humanoids are awarded loot ownership - if the winner
@ -490,7 +490,7 @@ pub fn handle_destroy(server: &mut Server, entity: EcsEntity, last_change: Healt
};
let item_drop_entity = state
.create_item_drop(comp::Pos(pos.0 + Vec3::unit_z() * 0.25), item)
.create_item_drop(Pos(pos.0 + Vec3::unit_z() * 0.25), item)
.maybe_with(vel)
.build();
@ -502,7 +502,7 @@ pub fn handle_destroy(server: &mut Server, entity: EcsEntity, last_change: Healt
state
.ecs()
.write_storage::<comp::LootOwner>()
.write_storage::<LootOwner>()
.insert(item_drop_entity, LootOwner::new(uid))
.unwrap();
}
@ -633,7 +633,7 @@ pub fn handle_respawn(server: &Server, entity: EcsEntity) {
state
.ecs()
.write_storage::<comp::Health>()
.write_storage::<Health>()
.get_mut(entity)
.map(|mut health| health.revive());
state
@ -643,7 +643,7 @@ pub fn handle_respawn(server: &Server, entity: EcsEntity) {
.map(|mut combo| combo.reset());
state
.ecs()
.write_storage::<comp::Pos>()
.write_storage::<Pos>()
.get_mut(entity)
.map(|pos| pos.0 = respawn_point);
state
@ -692,7 +692,7 @@ pub fn handle_explosion(server: &Server, pos: Vec3<f32>, explosion: Explosion, o
.any(|e| matches!(e, RadiusEffect::Attack(_))),
reagent: explosion.reagent,
});
let groups = ecs.read_storage::<comp::Group>();
let groups = ecs.read_storage::<Group>();
// Used to get strength of explosion effects as they falloff over distance
fn cylinder_sphere_strength(
@ -859,12 +859,12 @@ pub fn handle_explosion(server: &Server, pos: Vec3<f32>, explosion: Explosion, o
}
},
RadiusEffect::Attack(attack) => {
let energies = &ecs.read_storage::<comp::Energy>();
let energies = &ecs.read_storage::<Energy>();
let combos = &ecs.read_storage::<comp::Combo>();
let inventories = &ecs.read_storage::<comp::Inventory>();
let inventories = &ecs.read_storage::<Inventory>();
let alignments = &ecs.read_storage::<Alignment>();
let uid_allocator = &ecs.read_resource::<UidAllocator>();
let players = &ecs.read_storage::<comp::Player>();
let players = &ecs.read_storage::<Player>();
for (
entity_b,
pos_b,
@ -872,13 +872,13 @@ pub fn handle_explosion(server: &Server, pos: Vec3<f32>, explosion: Explosion, o
(body_b_maybe, stats_b_maybe, ori_b_maybe, char_state_b_maybe, uid_b),
) in (
&ecs.entities(),
&ecs.read_storage::<comp::Pos>(),
&ecs.read_storage::<comp::Health>(),
&ecs.read_storage::<Pos>(),
&ecs.read_storage::<Health>(),
(
ecs.read_storage::<comp::Body>().maybe(),
ecs.read_storage::<comp::Stats>().maybe(),
ecs.read_storage::<Body>().maybe(),
ecs.read_storage::<Stats>().maybe(),
ecs.read_storage::<comp::Ori>().maybe(),
ecs.read_storage::<comp::CharacterState>().maybe(),
ecs.read_storage::<CharacterState>().maybe(),
&ecs.read_storage::<Uid>(),
),
)
@ -975,11 +975,11 @@ pub fn handle_explosion(server: &Server, pos: Vec3<f32>, explosion: Explosion, o
RadiusEffect::Entity(mut effect) => {
let alignments = &ecs.read_storage::<Alignment>();
let uid_allocator = &ecs.read_resource::<UidAllocator>();
let players = &ecs.read_storage::<comp::Player>();
let players = &ecs.read_storage::<Player>();
for (entity_b, pos_b, body_b_maybe) in (
&ecs.entities(),
&ecs.read_storage::<comp::Pos>(),
ecs.read_storage::<comp::Body>().maybe(),
&ecs.read_storage::<Pos>(),
ecs.read_storage::<Body>().maybe(),
)
.join()
{
@ -1011,7 +1011,7 @@ pub fn handle_explosion(server: &Server, pos: Vec3<f32>, explosion: Explosion, o
};
if strength > 0.0 {
let is_alive = ecs
.read_storage::<comp::Health>()
.read_storage::<Health>()
.get(entity_b)
.map_or(true, |h| !h.is_dead);
@ -1056,7 +1056,7 @@ pub fn handle_bonk(server: &mut Server, pos: Vec3<f32>, owner: Option<Uid>, targ
Some(SpriteKind::Bomb) => comp::object::Body::Bomb,
_ => comp::object::Body::Pouch,
})
.with(comp::Pos(pos.map(|e| e as f32) + Vec3::new(0.5, 0.5, 0.0)))
.with(Pos(pos.map(|e| e as f32) + Vec3::new(0.5, 0.5, 0.0)))
.with(item)
.maybe_with(match block.get_sprite() {
Some(SpriteKind::Bomb) => Some(comp::Object::Bomb { owner }),
@ -1071,7 +1071,7 @@ pub fn handle_bonk(server: &mut Server, pos: Vec3<f32>, owner: Option<Uid>, targ
pub fn handle_aura(server: &mut Server, entity: EcsEntity, aura_change: aura::AuraChange) {
let ecs = &server.state.ecs();
let mut auras_all = ecs.write_storage::<comp::Auras>();
let mut auras_all = ecs.write_storage::<Auras>();
if let Some(mut auras) = auras_all.get_mut(entity) {
use aura::AuraChange;
match aura_change {
@ -1090,7 +1090,7 @@ pub fn handle_aura(server: &mut Server, entity: EcsEntity, aura_change: aura::Au
pub fn handle_buff(server: &mut Server, entity: EcsEntity, buff_change: buff::BuffChange) {
let ecs = &server.state.ecs();
let mut buffs_all = ecs.write_storage::<comp::Buffs>();
let bodies = ecs.read_storage::<comp::Body>();
let bodies = ecs.read_storage::<Body>();
if let Some(mut buffs) = buffs_all.get_mut(entity) {
use buff::BuffChange;
match buff_change {
@ -1238,7 +1238,7 @@ pub fn handle_combo_change(server: &Server, entity: EcsEntity, change: i32) {
pub fn handle_parry(server: &Server, entity: EcsEntity, energy_cost: f32) {
let ecs = &server.state.ecs();
if let Some(mut character) = ecs.write_storage::<comp::CharacterState>().get_mut(entity) {
if let Some(mut character) = ecs.write_storage::<CharacterState>().get_mut(entity) {
*character =
CharacterState::Wielding(common::states::wielding::Data { is_sneaking: false });
};
@ -1316,11 +1316,11 @@ pub fn handle_entity_attacked_hook(server: &Server, entity: EcsEntity) {
// Remove potion/saturation buff if attacked
server_eventbus.emit_now(ServerEvent::Buff {
entity,
buff_change: buff::BuffChange::RemoveByKind(buff::BuffKind::Potion),
buff_change: buff::BuffChange::RemoveByKind(BuffKind::Potion),
});
server_eventbus.emit_now(ServerEvent::Buff {
entity,
buff_change: buff::BuffChange::RemoveByKind(buff::BuffKind::Saturation),
buff_change: buff::BuffChange::RemoveByKind(BuffKind::Saturation),
});
}
@ -1332,8 +1332,8 @@ pub fn handle_change_ability(
new_ability: ability::AuxiliaryAbility,
) {
let ecs = &server.state.ecs();
let inventories = ecs.read_storage::<comp::Inventory>();
let skill_sets = ecs.read_storage::<comp::SkillSet>();
let inventories = ecs.read_storage::<Inventory>();
let skill_sets = ecs.read_storage::<SkillSet>();
if let Some(mut active_abilities) = ecs.write_storage::<comp::ActiveAbilities>().get_mut(entity)
{

10
server/src/events/group_manip.rs
View File

@ -2,7 +2,7 @@ use crate::{client::Client, Server};
use common::{
comp::{
self,
group::{self, ChangeNotification, Group, GroupManager},
group::{ChangeNotification, Group, GroupManager},
invite::{InviteKind, PendingInvites},
ChatType, GroupManip,
},
@ -113,7 +113,7 @@ pub fn update_map_markers<'a>(
}
// TODO: turn chat messages into enums
pub fn handle_group(server: &mut Server, entity: specs::Entity, manip: GroupManip) {
pub fn handle_group(server: &mut Server, entity: Entity, manip: GroupManip) {
match manip {
GroupManip::Leave => {
let state = server.state_mut();
@ -184,7 +184,7 @@ pub fn handle_group(server: &mut Server, entity: specs::Entity, manip: GroupMani
return;
}
let mut groups = state.ecs().write_storage::<group::Group>();
let mut groups = state.ecs().write_storage::<Group>();
let mut group_manager = state.ecs().write_resource::<GroupManager>();
let map_markers = state.ecs().read_storage::<comp::MapMarker>();
// Make sure kicker is the group leader
@ -222,7 +222,7 @@ pub fn handle_group(server: &mut Server, entity: specs::Entity, manip: GroupMani
"You were removed from the group.",
));
}
// Tell kicker that they were succesful
// Tell kicker that they were successful
if let Some(client) = clients.get(entity) {
client.send_fallible(ServerGeneral::server_msg(
ChatType::Meta,
@ -267,7 +267,7 @@ pub fn handle_group(server: &mut Server, entity: specs::Entity, manip: GroupMani
return;
},
};
let groups = state.ecs().read_storage::<group::Group>();
let groups = state.ecs().read_storage::<Group>();
let mut group_manager = state.ecs().write_resource::<GroupManager>();
let map_markers = state.ecs().read_storage::<comp::MapMarker>();
// Make sure assigner is the group leader

6
server/src/events/interaction.rs
View File

@ -100,7 +100,7 @@ pub fn handle_mount(server: &mut Server, rider: EcsEntity, mount: EcsEntity) {
let not_mounting_yet = state.ecs().read_storage::<Is<Mount>>().get(mount).is_none();
let within_range = || {
let positions = state.ecs().read_storage::<comp::Pos>();
let positions = state.ecs().read_storage::<Pos>();
within_mounting_range(positions.get(rider), positions.get(mount))
};
let healths = state.ecs().read_storage::<comp::Health>();
@ -234,7 +234,7 @@ pub fn handle_mine_block(
}
let item_drop = state
.create_item_drop(Default::default(), item)
.with(comp::Pos(pos.map(|e| e as f32) + Vec3::new(0.5, 0.5, 0.0)));
.with(Pos(pos.map(|e| e as f32) + Vec3::new(0.5, 0.5, 0.0)));
if let Some(uid) = maybe_uid {
item_drop.with(LootOwner::new(LootOwnerKind::Player(uid)))
} else {
@ -257,7 +257,7 @@ pub fn handle_mine_block(
pub fn handle_sound(server: &mut Server, sound: &Sound) {
let ecs = &server.state.ecs();
let positions = &ecs.read_storage::<comp::Pos>();
let positions = &ecs.read_storage::<Pos>();
let agents = &mut ecs.write_storage::<comp::Agent>();
// TODO: Reduce the complexity of this problem by using spatial partitioning

67
server/src/events/inventory_manip.rs
View File

@ -33,7 +33,7 @@ use common::{
use common_net::msg::ServerGeneral;
pub fn swap_lantern(
storage: &mut WriteStorage<comp::LightEmitter>,
storage: &mut WriteStorage<LightEmitter>,
entity: EcsEntity,
(lantern_color, lantern_strength): (Rgb<f32>, f32),
) {
@ -43,7 +43,7 @@ pub fn swap_lantern(
}
}
pub fn snuff_lantern(storage: &mut WriteStorage<comp::LightEmitter>, entity: EcsEntity) {
pub fn snuff_lantern(storage: &mut WriteStorage<LightEmitter>, entity: EcsEntity) {
storage.remove(entity);
}
@ -212,9 +212,9 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
);
drop(item_storage);
drop(inventories);
comp::InventoryUpdate::new(comp::InventoryUpdateEvent::EntityCollectFailed {
comp::InventoryUpdate::new(InventoryUpdateEvent::EntityCollectFailed {
entity: pickup_uid,
reason: comp::CollectFailedReason::InventoryFull,
reason: CollectFailedReason::InventoryFull,
})
},
Ok(_) => {
@ -227,10 +227,10 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
component.",
);
let ecs = state.ecs();
if let Some(group_id) = ecs.read_storage::<comp::Group>().get(entity) {
if let Some(group_id) = ecs.read_storage::<Group>().get(entity) {
announce_loot_to_group(group_id, ecs, entity, &item_msg.name());
}
comp::InventoryUpdate::new(comp::InventoryUpdateEvent::Collected(item_msg))
comp::InventoryUpdate::new(InventoryUpdateEvent::Collected(item_msg))
},
};
@ -255,12 +255,10 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
let event = match inventory.push(item) {
Ok(_) => {
let ecs = state.ecs();
if let Some(group_id) =
ecs.read_storage::<comp::Group>().get(entity)
{
if let Some(group_id) = ecs.read_storage::<Group>().get(entity) {
announce_loot_to_group(group_id, ecs, entity, &item_msg.name());
}
comp::InventoryUpdate::new(comp::InventoryUpdateEvent::Collected(
comp::InventoryUpdate::new(InventoryUpdateEvent::Collected(
item_msg,
))
},
@ -269,9 +267,9 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
Err(_) => {
drop_item = Some(item_msg);
comp::InventoryUpdate::new(
comp::InventoryUpdateEvent::BlockCollectFailed {
InventoryUpdateEvent::BlockCollectFailed {
pos,
reason: comp::CollectFailedReason::InventoryFull,
reason: CollectFailedReason::InventoryFull,
},
)
},
@ -343,18 +341,16 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
)
}));
}
Some(comp::InventoryUpdateEvent::Used)
Some(InventoryUpdateEvent::Used)
} else if let Some(item) = inventory.take(
slot,
&state.ecs().read_resource::<AbilityMap>(),
&state.ecs().read_resource::<item::MaterialStatManifest>(),
&state.ecs().read_resource::<MaterialStatManifest>(),
) {
match &*item.kind() {
ItemKind::Consumable { effects, .. } => {
maybe_effect = Some(effects.clone());
Some(comp::InventoryUpdateEvent::Consumed(
item.name().into_owned(),
))
Some(InventoryUpdateEvent::Consumed(item.name().into_owned()))
},
ItemKind::Throwable { kind, .. } => {
if let Some(pos) =
@ -374,10 +370,10 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
*kind,
));
}
Some(comp::InventoryUpdateEvent::Used)
Some(InventoryUpdateEvent::Used)
},
ItemKind::Utility {
kind: comp::item::Utility::Collar,
kind: item::Utility::Collar,
..
} => {
const MAX_PETS: usize = 3;
@ -385,7 +381,7 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
state.read_storage::<comp::Pos>().get(entity)
{
if (
&state.read_storage::<comp::Alignment>(),
&state.read_storage::<Alignment>(),
&state.read_storage::<comp::Agent>(),
)
.join()
@ -399,17 +395,16 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
} else if let Some(tameable_entity) = {
let nearest_tameable = (
&state.ecs().entities(),
&state.ecs().read_storage::<comp::Body>(),
&state.ecs().read_storage::<Body>(),
&state.ecs().read_storage::<comp::Pos>(),
&state.ecs().read_storage::<comp::Alignment>(),
&state.ecs().read_storage::<Alignment>(),
)
.join()
.filter(|(_, _, wild_pos, _)| {
wild_pos.0.distance_squared(pos.0) < 5.0f32.powi(2)
})
.filter(|(_, body, _, alignment)| {
alignment == &&comp::Alignment::Wild
&& is_tameable(body)
alignment == &&Alignment::Wild && is_tameable(body)
})
.min_by_key(|(_, _, wild_pos, _)| {
(wild_pos.0.distance_squared(pos.0) * 100.0) as i32
@ -435,7 +430,7 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
let _ = inventory.insert_or_stack_at(slot, item);
}
Some(comp::InventoryUpdateEvent::Used)
Some(InventoryUpdateEvent::Used)
},
_ => {
inventory.insert_or_stack_at(slot, item).expect(
@ -468,7 +463,7 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
}));
}
}
Some(comp::InventoryUpdateEvent::Used)
Some(InventoryUpdateEvent::Used)
},
};
@ -509,7 +504,7 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
if let Some(pos) = ecs.read_storage::<comp::Pos>().get(entity) {
let mut merged_stacks = false;
// If both slots have items and we're attemping to drag from one stack
// If both slots have items and we're attempting to drag from one stack
// into another, stack the items.
if let (Slot::Inventory(slot_a), Slot::Inventory(slot_b)) = (a, b) {
merged_stacks |= inventory.merge_stack_into(slot_a, slot_b);
@ -535,7 +530,7 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
.write_storage()
.insert(
entity,
comp::InventoryUpdate::new(comp::InventoryUpdateEvent::Swapped),
comp::InventoryUpdate::new(InventoryUpdateEvent::Swapped),
)
.expect("We know entity exists since we got its inventory.");
},
@ -543,7 +538,7 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
let ability_map = state.ecs().read_resource::<AbilityMap>();
let msm = state.ecs().read_resource::<MaterialStatManifest>();
// If both slots have items and we're attemping to split from one stack
// If both slots have items and we're attempting to split from one stack
// into another, ensure that they are the same type of item. If they are
// the same type do nothing, as you don't want to overwrite the existing item.
@ -576,7 +571,7 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
.write_storage()
.insert(
entity,
comp::InventoryUpdate::new(comp::InventoryUpdateEvent::Swapped),
comp::InventoryUpdate::new(InventoryUpdateEvent::Swapped),
)
.expect("We know entity exists since we got its inventory.");
drop(inventories);
@ -605,7 +600,7 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
.write_storage()
.insert(
entity,
comp::InventoryUpdate::new(comp::InventoryUpdateEvent::Dropped),
comp::InventoryUpdate::new(InventoryUpdateEvent::Dropped),
)
.expect("We know entity exists since we got its inventory.");
drop(inventories);
@ -637,7 +632,7 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
.write_storage()
.insert(
entity,
comp::InventoryUpdate::new(comp::InventoryUpdateEvent::Dropped),
comp::InventoryUpdate::new(InventoryUpdateEvent::Dropped),
)
.expect("We know entity exists since we got its inventory.");
drop(inventories);
@ -692,7 +687,7 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
&mut inventory,
slots,
&state.ecs().read_resource::<AbilityMap>(),
&state.ecs().read_resource::<item::MaterialStatManifest>(),
&state.ecs().read_resource::<MaterialStatManifest>(),
)
.ok()
}),
@ -757,7 +752,7 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
modifier,
slots,
&state.ecs().read_resource::<AbilityMap>(),
&state.ecs().read_resource::<item::MaterialStatManifest>(),
&state.ecs().read_resource::<MaterialStatManifest>(),
)
.ok()
})
@ -794,7 +789,7 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
if items_were_crafted {
let _ = state.ecs().write_storage().insert(
entity,
comp::InventoryUpdate::new(comp::InventoryUpdateEvent::Craft),
comp::InventoryUpdate::new(InventoryUpdateEvent::Craft),
);
}
},
@ -934,7 +929,7 @@ mod tests {
use super::*;
// Helper function
fn test_cylinder(pos: comp::Pos) -> Option<Cylinder> {
fn test_cylinder(pos: Pos) -> Option<Cylinder> {
Some(Cylinder::from_components(pos.0, None, None, None))
}

25
server/src/events/invite.rs
View File

@ -26,12 +26,7 @@ const INVITE_TIMEOUT_DUR: Duration = Duration::from_secs(31);
/// Reduced duration shown to the client to help alleviate latency issues
const PRESENTED_INVITE_TIMEOUT_DUR: Duration = Duration::from_secs(30);
pub fn handle_invite(
server: &mut Server,
inviter: specs::Entity,
invitee_uid: Uid,
kind: InviteKind,
) {
pub fn handle_invite(server: &mut Server, inviter: Entity, invitee_uid: Uid, kind: InviteKind) {
let max_group_size = server.settings().max_player_group_size;
let state = server.state_mut();
let clients = state.ecs().read_storage::<Client>();
@ -61,12 +56,12 @@ pub fn handle_invite(
}
let mut pending_invites = state.ecs().write_storage::<PendingInvites>();
let mut agents = state.ecs().write_storage::<comp::Agent>();
let mut agents = state.ecs().write_storage::<Agent>();
let mut invites = state.ecs().write_storage::<Invite>();
if let InviteKind::Trade = kind {
// Check whether the inviter is in range of the invitee
let positions = state.ecs().read_storage::<comp::Pos>();
let positions = state.ecs().read_storage::<Pos>();
if !within_trading_range(positions.get(inviter), positions.get(invitee)) {
return;
}
@ -118,7 +113,7 @@ pub fn handle_invite(
}
let mut invite_sent = false;
// Returns true if insertion was succesful
// Returns true if insertion was successful
let mut send_invite = || {
match invites.insert(invitee, Invite { inviter, kind }) {
Err(err) => {
@ -180,18 +175,14 @@ pub fn handle_invite(
}
}
}
pub fn handle_invite_response(
server: &mut Server,
entity: specs::Entity,
response: InviteResponse,
) {
pub fn handle_invite_response(server: &mut Server, entity: Entity, response: InviteResponse) {
match response {
InviteResponse::Accept => handle_invite_accept(server, entity),
InviteResponse::Decline => handle_invite_decline(server, entity),
}
}
pub fn handle_invite_accept(server: &mut Server, entity: specs::Entity) {
pub fn handle_invite_accept(server: &mut Server, entity: Entity) {
let index = server.index.clone();
let state = server.state_mut();
if let Some((inviter, kind)) = get_inviter_and_kind(entity, state) {
@ -324,7 +315,7 @@ fn handle_invite_answer(
client
.send_fallible(ServerGeneral::FinishedTrade(TradeResult::Declined));
}
if let Some(agent) = state.ecs().write_storage::<comp::Agent>().get_mut(e) {
if let Some(agent) = state.ecs().write_storage::<Agent>().get_mut(e) {
agent
.inbox
.push_back(AgentEvent::FinishedTrade(TradeResult::Declined));
@ -342,7 +333,7 @@ fn handle_invite_answer(
}
}
pub fn handle_invite_decline(server: &mut Server, entity: specs::Entity) {
pub fn handle_invite_decline(server: &mut Server, entity: Entity) {
let state = server.state_mut();
if let Some((inviter, kind)) = get_inviter_and_kind(entity, state) {
// Inform inviter of rejection

18
server/src/events/player.rs
View File

@ -223,12 +223,12 @@ fn persist_entity(state: &mut State, entity: EcsEntity) -> EcsEntity {
PresenceKind::Character(char_id) => {
let waypoint = state
.ecs()
.read_storage::<common::comp::Waypoint>()
.read_storage::<comp::Waypoint>()
.get(entity)
.cloned();
let map_marker = state
.ecs()
.read_storage::<common::comp::MapMarker>()
.read_storage::<comp::MapMarker>()
.get(entity)
.cloned();
// Store last battle mode change
@ -421,8 +421,9 @@ pub fn handle_possess(server: &mut Server, possessor_uid: Uid, possessee_uid: Ui
if let Some(player) = players.get(possessee) {
use common_net::msg;
let add_player_msg = ServerGeneral::PlayerListUpdate(
msg::server::PlayerListUpdate::Add(possessee_uid, msg::server::PlayerInfo {
let add_player_msg = ServerGeneral::PlayerListUpdate(PlayerListUpdate::Add(
possessee_uid,
msg::server::PlayerInfo {
player_alias: player.alias.clone(),
is_online: true,
is_moderator: admins.contains(possessee),
@ -432,11 +433,10 @@ pub fn handle_possess(server: &mut Server, possessor_uid: Uid, possessee_uid: Ui
}
}),
uuid: player.uuid(),
}),
);
let remove_player_msg = ServerGeneral::PlayerListUpdate(
msg::server::PlayerListUpdate::Remove(possessor_uid),
);
},
));
let remove_player_msg =
ServerGeneral::PlayerListUpdate(PlayerListUpdate::Remove(possessor_uid));
drop((clients, players)); // need to drop so we can use `notify_players` below
state.notify_players(remove_player_msg);

36
server/src/lib.rs
View File

@ -333,7 +333,7 @@ impl Server {
state.ecs_mut().register::<Presence>();
state.ecs_mut().register::<wiring::WiringElement>();
state.ecs_mut().register::<wiring::Circuit>();
state.ecs_mut().register::<comp::Anchor>();
state.ecs_mut().register::<Anchor>();
state.ecs_mut().register::<comp::Pet>();
state.ecs_mut().register::<login_provider::PendingLogin>();
state.ecs_mut().register::<RepositionOnChunkLoad>();
@ -346,7 +346,7 @@ impl Server {
Ok(file) => match ron::de::from_reader(&file) {
Ok(vec) => vec,
Err(error) => {
tracing::warn!(?error, ?file, "Couldn't deserialize banned words file");
warn!(?error, ?file, "Couldn't deserialize banned words file");
return Err(Error::Other(format!(
"Couldn't read banned words file \"{}\"",
path.to_string_lossy()
@ -354,7 +354,7 @@ impl Server {
},
},
Err(error) => {
tracing::warn!(?error, ?path, "Couldn't open banned words file");
warn!(?error, ?path, "Couldn't open banned words file");
return Err(Error::Other(format!(
"Couldn't open banned words file \"{}\". Error: {}",
path.to_string_lossy(),
@ -365,8 +365,8 @@ impl Server {
banned_words.append(&mut list);
}
let banned_words_count = banned_words.len();
tracing::debug!(?banned_words_count);
tracing::trace!(?banned_words);
debug!(?banned_words_count);
trace!(?banned_words);
state.ecs_mut().insert(AliasValidator::new(banned_words));
#[cfg(feature = "worldgen")]
@ -759,10 +759,10 @@ impl Server {
}
// Prevent anchor entity chains which are not currently supported
let anchors = self.state.ecs().read_storage::<comp::Anchor>();
let anchors = self.state.ecs().read_storage::<Anchor>();
let anchored_anchor_entities: Vec<Entity> = (
&self.state.ecs().entities(),
&self.state.ecs().read_storage::<comp::Anchor>(),
&self.state.ecs().read_storage::<Anchor>(),
)
.join()
.filter_map(|(_, anchor)| match anchor {
@ -792,7 +792,7 @@ impl Server {
&self.state.ecs().entities(),
&self.state.ecs().read_storage::<comp::Pos>(),
!&self.state.ecs().read_storage::<Presence>(),
self.state.ecs().read_storage::<comp::Anchor>().maybe(),
self.state.ecs().read_storage::<Anchor>().maybe(),
)
.join()
.filter(|(_, pos, _, anchor)| {
@ -847,15 +847,9 @@ impl Server {
// 7 Persistence updates
let before_persistence_updates = Instant::now();
let character_loader = self
.state
.ecs()
.read_resource::<persistence::character_loader::CharacterLoader>();
let character_loader = self.state.ecs().read_resource::<CharacterLoader>();
let character_updater = self
.state
.ecs()
.read_resource::<persistence::character_updater::CharacterUpdater>();
let character_updater = self.state.ecs().read_resource::<CharacterUpdater>();
// Get character-related database responses and notify the requesting client
character_loader
@ -1005,7 +999,7 @@ impl Server {
{
// Report timing info
let tick_metrics = self.state.ecs().read_resource::<metrics::TickMetrics>();
let tick_metrics = self.state.ecs().read_resource::<TickMetrics>();
let tt = &tick_metrics.tick_time;
tt.with_label_values(&["new connections"])
@ -1049,8 +1043,8 @@ impl Server {
fn initialize_client(
&mut self,
client: crate::connection_handler::IncomingClient,
) -> Result<Option<specs::Entity>, Error> {
client: connection_handler::IncomingClient,
) -> Result<Option<Entity>, Error> {
if self.settings().max_players <= self.state.ecs().read_storage::<Client>().join().count() {
trace!(
?client.participant,
@ -1166,7 +1160,7 @@ impl Server {
while let Ok(sender) = self.connection_handler.info_requester_receiver.try_recv() {
// can fail, e.g. due to timeout or network prob.
trace!("sending info to connection_handler");
let _ = sender.send(crate::connection_handler::ServerInfoPacket {
let _ = sender.send(connection_handler::ServerInfoPacket {
info: self.get_server_info(),
time: self.state.get_time(),
});
@ -1391,7 +1385,7 @@ impl Server {
let world_dims_chunks = self.world.sim().get_size();
let world_dims_blocks = TerrainChunkSize::blocks(world_dims_chunks);
// NOTE: origin is in the corner of the map
// TODO: extend this function to have picking a random position or specifiying a
// TODO: extend this function to have picking a random position or specifying a
// position as options
//let mut rng = rand::thread_rng();
// // Pick a random position but not to close to the edge

6
server/src/login_provider.rs
View File

@ -164,13 +164,13 @@ impl LoginProvider {
info!(?username, "New User");
Some(Ok((username, uuid)))
},
Err(tokio::sync::oneshot::error::TryRecvError::Closed) => {
Err(oneshot::error::TryRecvError::Closed) => {
error!("channel got closed to early, this shouldn't happen");
Some(Err(RegisterError::AuthError(
"Internal Error verifying".to_string(),
)))
},
Err(tokio::sync::oneshot::error::TryRecvError::Empty) => None,
Err(oneshot::error::TryRecvError::Empty) => None,
}
}
@ -186,7 +186,7 @@ impl LoginProvider {
match async {
let uuid = srv.validate(token).await?;
let username = srv.uuid_to_username(uuid).await?;
let r: Result<_, authc::AuthClientError> = Ok((username, uuid));
let r: Result<_, AuthClientError> = Ok((username, uuid));
r
}
.await

6
server/src/persistence/character.rs
View File

@ -543,9 +543,7 @@ pub fn edit_character(
.iter_mut()
.find(|c| c.character.id == Some(character_id))
{
if let (crate::comp::Body::Humanoid(new), crate::comp::Body::Humanoid(old)) =
(body, char.body)
{
if let (comp::Body::Humanoid(new), comp::Body::Humanoid(old)) = (body, char.body) {
if new.species != old.species || new.body_type != old.body_type {
warn!(
"Character edit rejected due to failed validation - Character ID: {} \
@ -948,7 +946,7 @@ fn delete_pets(
pub fn update(
char_id: CharacterId,
char_skill_set: comp::SkillSet,
inventory: comp::Inventory,
inventory: Inventory,
pets: Vec<PetPersistenceData>,
char_waypoint: Option<comp::Waypoint>,
active_abilities: comp::ability::ActiveAbilities,

38
server/src/persistence/character/conversions.rs
View File

@ -28,7 +28,7 @@ use tracing::{trace, warn};
#[derive(Debug)]
pub struct ItemModelPair {
pub comp: Arc<common::comp::item::ItemId>,
pub comp: Arc<item::ItemId>,
pub model: Item,
}
@ -193,23 +193,23 @@ pub fn convert_body_to_database_json(
comp_body: &CompBody,
) -> Result<(&str, String), PersistenceError> {
Ok(match comp_body {
common::comp::Body::Humanoid(body) => (
Body::Humanoid(body) => (
"humanoid",
serde_json::to_string(&HumanoidBody::from(body))?,
),
common::comp::Body::QuadrupedLow(body) => (
Body::QuadrupedLow(body) => (
"quadruped_low",
serde_json::to_string(&GenericBody::from(body))?,
),
common::comp::Body::QuadrupedMedium(body) => (
Body::QuadrupedMedium(body) => (
"quadruped_medium",
serde_json::to_string(&GenericBody::from(body))?,
),
common::comp::Body::QuadrupedSmall(body) => (
Body::QuadrupedSmall(body) => (
"quadruped_small",
serde_json::to_string(&GenericBody::from(body))?,
),
common::comp::Body::BirdMedium(body) => (
Body::BirdMedium(body) => (
"bird_medium",
serde_json::to_string(&GenericBody::from(body))?,
),
@ -544,8 +544,8 @@ pub fn convert_body_from_database(
// extra fields on its body struct
"humanoid" => {
let json_model = serde_json::de::from_str::<HumanoidBody>(body_data)?;
CompBody::Humanoid(common::comp::humanoid::Body {
species: common::comp::humanoid::ALL_SPECIES
CompBody::Humanoid(humanoid::Body {
species: humanoid::ALL_SPECIES
.get(json_model.species as usize)
.ok_or_else(|| {
PersistenceError::ConversionError(format!(
@ -554,7 +554,7 @@ pub fn convert_body_from_database(
))
})?
.to_owned(),
body_type: common::comp::humanoid::ALL_BODY_TYPES
body_type: humanoid::ALL_BODY_TYPES
.get(json_model.body_type as usize)
.ok_or_else(|| {
PersistenceError::ConversionError(format!(
@ -600,16 +600,16 @@ pub fn convert_character_from_database(character: &Character) -> common::charact
}
}
pub fn convert_stats_from_database(alias: String) -> common::comp::Stats {
let mut new_stats = common::comp::Stats::empty();
pub fn convert_stats_from_database(alias: String) -> Stats {
let mut new_stats = Stats::empty();
new_stats.name = alias;
new_stats
}
pub fn convert_skill_set_from_database(skill_groups: &[SkillGroup]) -> common::comp::SkillSet {
pub fn convert_skill_set_from_database(skill_groups: &[SkillGroup]) -> SkillSet {
let (skillless_skill_groups, deserialized_skills) =
convert_skill_groups_from_database(skill_groups);
common::comp::SkillSet::load_from_database(skillless_skill_groups, deserialized_skills)
SkillSet::load_from_database(skillless_skill_groups, deserialized_skills)
}
#[allow(clippy::type_complexity)]
@ -618,9 +618,9 @@ fn convert_skill_groups_from_database(
) -> (
// Skill groups in the vec do not contain skills, those are added later. The skill group only
// contains fields related to experience and skill points
HashMap<skillset::SkillGroupKind, skillset::SkillGroup>,
HashMap<SkillGroupKind, skillset::SkillGroup>,
//
HashMap<skillset::SkillGroupKind, Result<Vec<skills::Skill>, skillset::SkillsPersistenceError>>,
HashMap<SkillGroupKind, Result<Vec<Skill>, skillset::SkillsPersistenceError>>,
) {
let mut new_skill_groups = HashMap::new();
let mut deserialized_skills = HashMap::new();
@ -657,7 +657,7 @@ fn convert_skill_groups_from_database(
Err(SkillsPersistenceError::HashMismatch)
} else {
// Else attempt to deserialize skills from a json string
match serde_json::from_str::<Vec<skills::Skill>>(&skill_group.skills) {
match serde_json::from_str::<Vec<Skill>>(&skill_group.skills) {
// If it correctly deserializes, return the persisted skills
Ok(skills) => Ok(skills),
// Else if doesn't deserialize correctly, force a respec
@ -702,7 +702,7 @@ pub fn convert_skill_groups_to_database<'a, I: Iterator<Item = &'a skillset::Ski
pub fn convert_active_abilities_to_database(
entity_id: CharacterId,
active_abilities: &ability::ActiveAbilities,
active_abilities: &ActiveAbilities,
) -> AbilitySets {
let ability_sets = json_models::active_abilities_to_db_model(active_abilities);
AbilitySets {
@ -711,9 +711,7 @@ pub fn convert_active_abilities_to_database(
}
}
pub fn convert_active_abilities_from_database(
ability_sets: &AbilitySets,
) -> ability::ActiveAbilities {
pub fn convert_active_abilities_from_database(ability_sets: &AbilitySets) -> ActiveAbilities {
let ability_sets = serde_json::from_str::<Vec<DatabaseAbilitySet>>(&ability_sets.ability_sets)
.unwrap_or_else(|err| {
common_base::dev_panic!(format!(

10
server/src/persistence/json_models.rs
View File

@ -118,7 +118,7 @@ pub struct DatabaseAbilitySet {
abilities: Vec<String>,
}
fn aux_ability_to_string(ability: common::comp::ability::AuxiliaryAbility) -> String {
fn aux_ability_to_string(ability: comp::ability::AuxiliaryAbility) -> String {
use common::comp::ability::AuxiliaryAbility;
match ability {
AuxiliaryAbility::MainWeapon(index) => format!("Main Weapon:index:{}", index),
@ -127,7 +127,7 @@ fn aux_ability_to_string(ability: common::comp::ability::AuxiliaryAbility) -> St
}
}
fn aux_ability_from_string(ability: &str) -> common::comp::ability::AuxiliaryAbility {
fn aux_ability_from_string(ability: &str) -> comp::ability::AuxiliaryAbility {
use common::comp::ability::AuxiliaryAbility;
let mut parts = ability.split(":index:");
match parts.next() {
@ -184,7 +184,7 @@ fn aux_ability_from_string(ability: &str) -> common::comp::ability::AuxiliaryAbi
}
}
fn tool_kind_to_string(tool: Option<common::comp::item::tool::ToolKind>) -> String {
fn tool_kind_to_string(tool: Option<comp::item::tool::ToolKind>) -> String {
use common::comp::item::tool::ToolKind::*;
String::from(match tool {
Some(Sword) => "Sword",
@ -199,7 +199,7 @@ fn tool_kind_to_string(tool: Option<common::comp::item::tool::ToolKind>) -> Stri
Some(Blowgun) => "Blowgun",
Some(Pick) => "Pick",
// Toolkinds that are not anticipated to have many active aiblities (if any at all)
// Toolkinds that are not anticipated to have many active abilities (if any at all)
Some(Farming) => "Farming",
Some(Debug) => "Debug",
Some(Natural) => "Natural",
@ -208,7 +208,7 @@ fn tool_kind_to_string(tool: Option<common::comp::item::tool::ToolKind>) -> Stri
})
}
fn tool_kind_from_string(tool: String) -> Option<common::comp::item::tool::ToolKind> {
fn tool_kind_from_string(tool: String) -> Option<comp::item::tool::ToolKind> {
use common::comp::item::tool::ToolKind::*;
match tool.as_str() {
"Sword" => Some(Sword),

22
server/src/rtsim/entity.rs
View File

@ -47,7 +47,7 @@ const BIRD_MEDIUM_ROSTER: &[comp::bird_medium::Species] = &[
];
const BIRD_LARGE_ROSTER: &[comp::bird_large::Species] = &[
// Flame Wyvern not incuded until proper introduction
// Flame Wyvern not included until proper introduction
comp::bird_large::Species::Phoenix,
comp::bird_large::Species::Cockatrice,
comp::bird_large::Species::Roc,
@ -1022,7 +1022,7 @@ mod tests {
#[test]
fn test_entity_configs() {
let dummy_pos = Vec3::new(0.0, 0.0, 0.0);
let mut dummy_rng = rand::thread_rng();
let mut dummy_rng = thread_rng();
// Bird Large test
for bird_large_species in BIRD_LARGE_ROSTER {
let female_body = comp::bird_large::Body {
@ -1035,13 +1035,9 @@ mod tests {
};
let female_config = bird_large_config(female_body);
std::mem::drop(
EntityInfo::at(dummy_pos).with_asset_expect(female_config, &mut dummy_rng),
);
drop(EntityInfo::at(dummy_pos).with_asset_expect(female_config, &mut dummy_rng));
let male_config = bird_large_config(male_body);
std::mem::drop(
EntityInfo::at(dummy_pos).with_asset_expect(male_config, &mut dummy_rng),
);
drop(EntityInfo::at(dummy_pos).with_asset_expect(male_config, &mut dummy_rng));
}
// Bird Medium test
for bird_med_species in BIRD_MEDIUM_ROSTER {
@ -1055,19 +1051,15 @@ mod tests {
};
let female_config = bird_medium_config(female_body);
std::mem::drop(
EntityInfo::at(dummy_pos).with_asset_expect(female_config, &mut dummy_rng),
);
drop(EntityInfo::at(dummy_pos).with_asset_expect(female_config, &mut dummy_rng));
let male_config = bird_medium_config(male_body);
std::mem::drop(
EntityInfo::at(dummy_pos).with_asset_expect(male_config, &mut dummy_rng),
);
drop(EntityInfo::at(dummy_pos).with_asset_expect(male_config, &mut dummy_rng));
}
// Humanoid test
for kind in RtSimEntityKind::iter() {
for rank in TravelerRank::iter() {
let config = humanoid_config(kind, rank);
std::mem::drop(EntityInfo::at(dummy_pos).with_asset_expect(config, &mut dummy_rng));
drop(EntityInfo::at(dummy_pos).with_asset_expect(config, &mut dummy_rng));
}
}
}

2
server/src/settings/admin.rs
View File

@ -18,7 +18,7 @@ pub use self::v1::*;
#[derive(Deserialize, Serialize)]
pub enum AdminsRaw {
V0(v0::Admins),
V1(v1::Admins),
V1(Admins),
}
impl From<Admins> for AdminsRaw {

4
server/src/settings/banlist.rs
View File

@ -19,7 +19,7 @@ pub use self::v1::*;
#[derive(Deserialize, Serialize)]
pub enum BanlistRaw {
V0(v0::Banlist),
V1(v1::Banlist),
V1(Banlist),
}
impl From<Banlist> for BanlistRaw {
@ -477,7 +477,7 @@ mod v1 {
impl Banlist {
/// Attempt to perform the ban action `action` for the user with UUID
/// `uuid` and username `username`, starting from itme `now`
/// `uuid` and username `username`, starting from time `now`
/// (the information about the banning party will
/// be in the `action` record), with a settings file maintained at path
/// root `data_dir`.

4
server/src/settings/editable.rs
View File

@ -83,8 +83,8 @@ pub trait EditableSetting: Clone + Default {
file.seek(SeekFrom::Start(0))?;
ron::de::from_reader(file)
.map(|legacy| Ok((Version::Old, Self::Legacy::into(legacy))))
// When both legacy and nonlegacy have parse errors, prioritize the
// nonlegacy one, since we can't tell which one is "right" and legacy
// When both legacy and non-legacy have parse errors, prioritize the
// non-legacy one, since we can't tell which one is "right" and legacy
// formats are simple, early, and uncommon enough that we expect
// few parse errors in those.
.or(Err(orig_err))

2
server/src/settings/server_description.rs
View File

@ -19,7 +19,7 @@ pub use self::v1::*;
#[derive(Deserialize, Serialize)]
pub enum ServerDescriptionRaw {
V0(v0::ServerDescription),
V1(v1::ServerDescription),
V1(ServerDescription),
}
impl From<ServerDescription> for ServerDescriptionRaw {

2
server/src/settings/whitelist.rs
View File

@ -18,7 +18,7 @@ pub use self::v1::*;
#[derive(Deserialize, Serialize)]
pub enum WhitelistRaw {
V0(v0::Whitelist),
V1(v1::Whitelist),
V1(Whitelist),
}
impl From<Whitelist> for WhitelistRaw {

29
server/src/state_ext.rs
View File

@ -50,8 +50,8 @@ pub trait StateExt {
stats: comp::Stats,
skill_set: comp::SkillSet,
health: Option<comp::Health>,
poise: comp::Poise,
inventory: comp::Inventory,
poise: Poise,
inventory: Inventory,
body: comp::Body,
) -> EcsEntityBuilder;
/// Build a static object entity
@ -139,7 +139,7 @@ impl StateExt for State {
Effect::Damage(damage) => {
let inventories = self.ecs().read_storage::<Inventory>();
let stats = self.ecs().read_storage::<comp::Stats>();
let groups = self.ecs().read_storage::<comp::Group>();
let groups = self.ecs().read_storage::<Group>();
let damage_contributor = source.and_then(|uid| {
self.ecs().entity_from_uid(uid.0).map(|attacker_entity| {
@ -159,7 +159,7 @@ impl StateExt for State {
0.0,
1.0,
*time,
rand::random(),
random(),
);
self.ecs()
.write_storage::<comp::Health>()
@ -176,7 +176,7 @@ impl StateExt for State {
.get(entity)
{
if !character_state.is_stunned() {
let groups = self.ecs().read_storage::<comp::Group>();
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())
@ -191,7 +191,7 @@ impl StateExt for State {
time: *time,
};
self.ecs()
.write_storage::<comp::Poise>()
.write_storage::<Poise>()
.get_mut(entity)
.map(|mut poise| poise.change(poise_change));
}
@ -219,8 +219,8 @@ impl StateExt for State {
stats: comp::Stats,
skill_set: comp::SkillSet,
health: Option<comp::Health>,
poise: comp::Poise,
inventory: comp::Inventory,
poise: Poise,
inventory: Inventory,
body: comp::Body,
) -> EcsEntityBuilder {
self.ecs_mut()
@ -310,7 +310,7 @@ impl StateExt for State {
.with(body)
.with(comp::Scale(comp::ship::AIRSHIP_SCALE))
.with(comp::Controller::default())
.with(comp::inventory::Inventory::with_empty())
.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()`
@ -561,7 +561,7 @@ impl StateExt for State {
);
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, comp::Poise::new(body));
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);
@ -952,13 +952,8 @@ impl StateExt for State {
}
}
fn send_to_group(g: &comp::Group, ecs: &specs::World, msg: &comp::ChatMsg) {
for (client, group) in (
&ecs.read_storage::<Client>(),
&ecs.read_storage::<comp::Group>(),
)
.join()
{
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()));
}

12
server/src/sys/agent.rs
View File

@ -157,7 +157,7 @@ impl<'a> System<'a> for Sys {
// Default to looking in orientation direction
// (can be overridden below)
//
// This definetly breaks LeapMelee and
// This definitely breaks LeapMelee and
// probably not only that, do we really need this at all?
controller.reset();
controller.inputs.look_dir = ori.look_dir();
@ -1104,7 +1104,7 @@ impl<'a> AgentData<'a> {
self.chat_npc(msg, event_emitter);
}
} else {
let mut rng = rand::thread_rng();
let mut rng = thread_rng();
if let Some(extreme_trait) =
self.rtsim_entity.and_then(|e| {
e.brain.personality.random_chat_trait(&mut rng)
@ -1359,7 +1359,7 @@ impl<'a> AgentData<'a> {
let balance1: f32 = prices.balance(&pending.offers, &inventories, who, false);
if balance0 >= balance1 {
// If the trade is favourable to us, only send an accept message if we're
// not already accepting (since otherwise, spamclicking the accept button
// not already accepting (since otherwise, spam-clicking the accept button
// results in lagging and moving to the review phase of an unfavorable trade
// (although since the phase is included in the message, this shouldn't
// result in fully accepting an unfavourable trade))
@ -1614,8 +1614,8 @@ impl<'a> AgentData<'a> {
};
let is_valid_target = |entity: EcsEntity| match read_data.bodies.get(entity) {
Some(Body::ItemDrop(item)) => {
//If the agent is humanoid, it will pick up all kinds of itemdrops. If the
// agent isn't humanoid, it will pick up only consumable itemdrops.
//If the agent is humanoid, it will pick up all kinds of item drops. If the
// agent isn't humanoid, it will pick up only consumable item drops.
let wants_pickup = matches!(self.body, Some(Body::Humanoid(_)))
|| matches!(item, item_drop::Body::Consumable);
@ -2174,7 +2174,7 @@ impl<'a> AgentData<'a> {
let sound_pos = Pos(sound.pos);
let dist_sqrd = self.pos.0.distance_squared(sound_pos.0);
// NOTE: There is an implicit distance requirement given that sound volume
// disipates as it travels, but we will not want to flee if a sound is super
// dissipates as it travels, but we will not want to flee if a sound is super
// loud but heard from a great distance, regardless of how loud it was.
// `is_close` is this limiter.
let is_close = dist_sqrd < 35.0_f32.powi(2);

8
server/src/sys/agent/attack.rs
View File

@ -924,7 +924,7 @@ impl<'a> AgentData<'a> {
_ =>
// if some illegal value slipped in, get zero vector
{
vek::Vec2::zero()
Vec2::zero()
},
};
let obstacle = read_data
@ -1411,7 +1411,7 @@ impl<'a> AgentData<'a> {
const MINION_SUMMON_THRESHOLD: f32 = 0.20;
let health_fraction = self.health.map_or(0.5, |h| h.fraction());
// Sets counter at start of combat, using `condition` to keep track of whether
// it was already intitialized
// it was already initialized
if !agent.action_state.condition {
agent.action_state.counter = 1.0 - MINION_SUMMON_THRESHOLD;
agent.action_state.condition = true;
@ -1742,7 +1742,7 @@ impl<'a> AgentData<'a> {
&& attack_data.angle < 90.0
&& attack_data.in_min_range()
{
// Triplestrike
// Triple strike
controller.push_basic_input(InputKind::Secondary);
agent.action_state.timer += read_data.dt.0;
} else {
@ -2152,7 +2152,7 @@ impl<'a> AgentData<'a> {
};
// Sets counter at start of combat, using `condition` to keep track of whether
// it was already intitialized
// it was already initialized
if !agent.action_state.condition {
agent.action_state.counter = 1.0 - MINION_SUMMON_THRESHOLD;
agent.action_state.condition = true;

2
server/src/sys/agent/data.rs
View File

@ -71,7 +71,7 @@ impl AttackData {
#[derive(Eq, PartialEq)]
// When adding a new variant, first decide if it should instead fall under one
// of the pre-exisitng tactics
// of the pre-existing tactics
pub enum Tactic {
// General tactics
SimpleMelee,

2
server/src/sys/mod.rs
View File

@ -30,7 +30,7 @@ pub fn add_server_systems(dispatch_builder: &mut DispatcherBuilder) {
dispatch::<melee::Sys>(dispatch_builder, &[&projectile::Sys::sys_name()]);
//Note: server should not depend on interpolation system
dispatch::<agent::Sys>(dispatch_builder, &[]);
dispatch::<terrain::Sys>(dispatch_builder, &[&msg::terrain::Sys::sys_name()]);
dispatch::<terrain::Sys>(dispatch_builder, &[&terrain::Sys::sys_name()]);
dispatch::<waypoint::Sys>(dispatch_builder, &[]);
dispatch::<invite_timeout::Sys>(dispatch_builder, &[]);
dispatch::<persistence::Sys>(dispatch_builder, &[]);

12
server/src/sys/msg/register.rs
View File

@ -12,7 +12,7 @@ use common::{
use common_ecs::{Job, Origin, Phase, System};
use common_net::msg::{
CharacterInfo, ClientRegister, DisconnectReason, PlayerInfo, PlayerListUpdate, RegisterError,
ServerGeneral, ServerRegisterAnswer,
ServerGeneral,
};
use hashbrown::HashMap;
use plugin_api::Health;
@ -110,7 +110,7 @@ impl<'a> System<'a> for Sys {
for (entity, client, pending) in
(&read_data.entities, &read_data.clients, &mut pending_logins).join()
{
if let Err(e) = || -> std::result::Result<(), crate::error::Error> {
if let Err(e) = || -> Result<(), crate::error::Error> {
#[cfg(feature = "plugins")]
let ecs_world = EcsWorld {
entities: &read_data.entities,
@ -140,7 +140,7 @@ impl<'a> System<'a> for Sys {
entity,
common::comp::DisconnectReason::Kicked,
));
client.send(ServerRegisterAnswer::Err(e))?;
client.send(Err(e))?;
return Ok(());
},
Ok((username, uuid)) => (username, uuid),
@ -183,7 +183,7 @@ impl<'a> System<'a> for Sys {
if !player.is_valid() {
// Invalid player
client.send(ServerRegisterAnswer::Err(RegisterError::InvalidCharacter))?;
client.send(Err(RegisterError::InvalidCharacter))?;
return Ok(());
}
@ -201,7 +201,7 @@ impl<'a> System<'a> for Sys {
}
// Tell the client its request was successful.
client.send(ServerRegisterAnswer::Ok(()))?;
client.send(Ok(()))?;
// Send initial player list
client.send(ServerGeneral::PlayerListUpdate(PlayerListUpdate::Init(
@ -213,7 +213,7 @@ impl<'a> System<'a> for Sys {
}
Ok(())
}() {
tracing::trace!(?e, "failed to process register")
trace!(?e, "failed to process register")
};
}
for e in finished_pending {

2
server/src/sys/subscription.rs
View File

@ -214,7 +214,7 @@ pub fn initialize_region_subscription(world: &World, entity: specs::Entity) {
let fuzzy_chunk = (Vec2::<f32>::from(client_pos.0))
.map2(TerrainChunkSize::RECT_SIZE, |e, sz| e as i32 / sz as i32);
let chunk_size = TerrainChunkSize::RECT_SIZE.reduce_max() as f32;
let regions = common::region::regions_in_vd(
let regions = regions_in_vd(
client_pos.0,
(presence.view_distance as f32 * chunk_size) as f32
+ (presence::CHUNK_FUZZ as f32 + chunk_size) * 2.0f32.sqrt(),

7
server/src/terrain_persistence.rs
View File

@ -88,10 +88,7 @@ impl TerrainPersistence {
File::open(&path)
.ok()
.map(|f| {
let bytes = match std::io::BufReader::new(f)
.bytes()
.collect::<Result<Vec<_>, _>>()
{
let bytes = match io::BufReader::new(f).bytes().collect::<Result<Vec<_>, _>>() {
Ok(bytes) => bytes,
Err(err) => {
error!(
@ -101,7 +98,7 @@ impl TerrainPersistence {
return Chunk::default();
},
};
match Chunk::deserialize_from(std::io::Cursor::new(bytes)) {
match Chunk::deserialize_from(io::Cursor::new(bytes)) {
Some(chunk) => chunk,
None => {
// Find an untaken name for a backup

2
voxygen/anim/src/arthropod/mod.rs
View File

@ -134,7 +134,7 @@ pub struct SkeletonAttr {
snapper: bool,
}
impl<'a> std::convert::TryFrom<&'a comp::Body> for SkeletonAttr {
impl<'a> TryFrom<&'a comp::Body> for SkeletonAttr {
type Error = ();
fn try_from(body: &'a comp::Body) -> Result<Self, Self::Error> {

Some files were not shown because too many files have changed in this diff Show More