diff --git a/assets/voxygen/shaders/include/constants.glsl b/assets/voxygen/shaders/include/constants.glsl index d1f793af15..b409fd4cfb 100644 --- a/assets/voxygen/shaders/include/constants.glsl +++ b/assets/voxygen/shaders/include/constants.glsl @@ -3,8 +3,8 @@ /* TODO: Add the ability to control the tendency to do stuff in the vertex vs. fragment shader. * Currently this flag is ignored and always set to prefer fragment, but this tradeoff is not correct on all * machines in all cases (mine, for instance). */ -#define VOXYGEN_COMPUTATION_PREERENCE_FRAGMENT 0 -#define VOXYGEN_COMPUTATION_PREERENCE_VERTEX 1 +#define VOXYGEN_COMPUTATION_PREFERENCE_FRAGMENT 0 +#define VOXYGEN_COMPUTATION_PREFERENCE_VERTEX 1 #define FLUID_MODE_CHEAP 0 #define FLUID_MODE_SHINY 1 @@ -43,7 +43,7 @@ /* Constants expected to be defined automatically by configuration: */ /* -#define VOXYGEN_COMPUTATION_PREERENCE +#define VOXYGEN_COMPUTATION_PREFERENCE #define FLUID_MODE #define CLOUD_MODE #define LIGHTING_ALGORITHM diff --git a/client/src/lib.rs b/client/src/lib.rs index 187c33306f..4b5bea63e0 100644 --- a/client/src/lib.rs +++ b/client/src/lib.rs @@ -1000,7 +1000,7 @@ impl Client { // -0.5 for being able to move to the corner of the current chunk // -1 because chunks are not meshed if they don't have all their neighbors // (notice also that view_distance is decreased by 1) - // (this subtraction on vd is ommitted elsewhere in order to provide + // (this subtraction on vd is omitted elsewhere in order to provide // a buffer layer of loaded chunks) let top = if 2 * (dist - 2).max(0).pow(2) > (view_distance - 1).pow(2) as i32 { ((view_distance - 1).pow(2) as f32 - (dist - 2).pow(2) as f32) @@ -1383,7 +1383,7 @@ impl Client { ); }, ServerMsg::Disconnect => { - debug!("finally sendinge ClientMsg::Terminate"); + debug!("finally sending ClientMsg::Terminate"); frontend_events.push(Event::Disconnect); self.singleton_stream.send(ClientMsg::Terminate)?; break Ok(()); diff --git a/common/src/comp/controller.rs b/common/src/comp/controller.rs index ff00ac4b49..a8e930a83e 100644 --- a/common/src/comp/controller.rs +++ b/common/src/comp/controller.rs @@ -87,7 +87,7 @@ impl Input { } /// Update input with newer version - /// Used to update inputs with input recieved from clients + /// Used to update inputs with input received from clients pub fn update_with_new(&mut self, new: Self) { if self.pressed != new.pressed { self.freshness = Freshness::New; diff --git a/common/src/comp/group.rs b/common/src/comp/group.rs index bf11ad7f58..d7eb39de42 100644 --- a/common/src/comp/group.rs +++ b/common/src/comp/group.rs @@ -11,7 +11,7 @@ use tracing::{error, warn}; // - no support for more complex group structures // - lack of npc group integration // - relies on careful management of groups to maintain a valid state -// - the possesion rod could probably wreck this +// - the possession rod could probably wreck this // - clients don't know which pets are theirs (could be easy to solve by // putting owner uid in Role::Pet) @@ -72,7 +72,7 @@ pub enum ChangeNotification { // Note: now that we are dipping into uids here consider just using // ChangeNotification everywhere // Also note when the same notification is sent to multiple destinations the -// maping might be duplicated effort +// mapping might be duplicated effort impl ChangeNotification { pub fn try_map(self, f: impl Fn(E) -> Option) -> Option> { match self { diff --git a/common/src/comp/inventory/slot.rs b/common/src/comp/inventory/slot.rs index db09354b25..9aa2eb6389 100644 --- a/common/src/comp/inventory/slot.rs +++ b/common/src/comp/inventory/slot.rs @@ -86,7 +86,7 @@ impl ArmorSlot { // when they are not equipped, when that is implemented this helper function // should no longer be needed -/// Create an ItemConfig for an item. Apply abilties to item. +/// Create an ItemConfig for an item. Apply abilities to item. fn item_config(item: item::Item) -> comp::ItemConfig { let mut abilities = if let item::ItemKind::Tool(tool) = &item.kind { tool.get_abilities() @@ -105,7 +105,7 @@ fn item_config(item: item::Item) -> comp::ItemConfig { } } -/// Replace an equiptment slot with an item. Return the item that was in the +/// Replace an equipment slot with an item. Return the item that was in the /// slot, if any. Doesn't update the inventory. fn loadout_replace( equip_slot: EquipSlot, diff --git a/common/src/comp/stats.rs b/common/src/comp/stats.rs index 3e8bd44a9e..0f9dd9f470 100644 --- a/common/src/comp/stats.rs +++ b/common/src/comp/stats.rs @@ -161,7 +161,7 @@ impl Stats { // TODO: define base stats somewhere else (maybe method on Body?) let (endurance, fitness, willpower) = match species { Some(Species::Danari) => (0, 2, 3), // Small, flexible, intelligent, physically weak - Some(Species::Dwarf) => (2, 2, 1), // phyiscally strong, intelligent, slow reflexes + Some(Species::Dwarf) => (2, 2, 1), // physically strong, intelligent, slow reflexes Some(Species::Elf) => (1, 2, 2), // Intelligent, quick, physically weak Some(Species::Human) => (2, 1, 2), // Perfectly balanced Some(Species::Orc) => (3, 2, 0), /* Physically strong, non intelligent, medium */ diff --git a/common/src/msg/server.rs b/common/src/msg/server.rs index 6b8904d892..cae6dd9360 100644 --- a/common/src/msg/server.rs +++ b/common/src/msg/server.rs @@ -116,7 +116,7 @@ pub struct WorldMapMsg { /// big a deal on the world map but is probably needed in order to ensure /// smooth transitions between chunks in LoD view. Additionally, when we /// start using the shadow information to do local lighting on the world - /// map, we'll want a quick way to test where we can go out of shadoow at + /// map, we'll want a quick way to test where we can go out of shadow at /// arbitrary heights (since the player and other entities cajn find /// themselves far from the ground at times). While this is only an /// approximation to a proper distance map, hopefully it will give us @@ -151,7 +151,7 @@ pub struct WorldMapMsg { /// probably be less effective. /// /// For related reasons, rather than storing distances as in a standard - /// distance map (which would lead to monotonically *decreaing* values + /// distance map (which would lead to monotonically *decreasing* values /// as we approached the occluder from a given direction), we store the /// estimated *occluder height.* The idea here is that we replace the /// monotonic sequences with constant sequences, which are extremely @@ -196,7 +196,7 @@ pub enum ServerMsg { CharacterDataLoadError(String), /// A list of characters belonging to the a authenticated player was sent CharacterListUpdate(Vec), - /// An error occured while creating or deleting a character + /// An error occurred while creating or deleting a character CharacterActionError(String), PlayerListUpdate(PlayerListUpdate), GroupUpdate(comp::group::ChangeNotification), diff --git a/common/src/npc.rs b/common/src/npc.rs index 15ddc96a2e..445743329f 100644 --- a/common/src/npc.rs +++ b/common/src/npc.rs @@ -117,7 +117,7 @@ impl FromStr for NpcBody { type Err = (); /// Get an NPC kind from a string. If a body kind is matched without an - /// associated species, generate the species randmly within it; if an + /// associated species, generate the species randomly within it; if an /// explicit species is found, generate a random member of the species; /// otherwise, return Err(()). fn from_str(s: &str) -> Result { Self::from_str_with(s, kind_to_body) } diff --git a/common/src/region.rs b/common/src/region.rs index cac795e32e..4a36a49179 100644 --- a/common/src/region.rs +++ b/common/src/region.rs @@ -18,7 +18,7 @@ pub struct Region { // Indices of neighboring regions neighbors: [Option; 8], // TODO consider SmallVec for these - // Entites that left or entered this region + // Entities that left or entered this region events: Vec, } impl Region { @@ -96,7 +96,7 @@ impl RegionMap { tracked_entities: BitSet::new(), entities_to_move: Vec::new(), entities_to_remove: Vec::new(), - // rate is depedent on the rate the caller calls region_manager.tick() + // rate is dependent on the rate the caller calls region_manager.tick() tick: 0, } } @@ -115,7 +115,7 @@ impl RegionMap { .clear(); } - // Add any untracked entites + // Add any untracked entities for (pos, id) in (&pos, &entities, !&self.tracked_entities) .join() .map(|(pos, e, _)| (pos, e.id())) @@ -146,7 +146,7 @@ impl RegionMap { let current_region = self.index_key(i).unwrap(); let key = Self::pos_key(pos); // Consider switching - // Caculate distance outside border + // Calculate distance outside border if key != current_region && (Vec2::::from(pos) - Self::key_pos(current_region)) .map(|e| e.abs() as u32) @@ -168,7 +168,7 @@ impl RegionMap { } // Remove region if it is empty - // TODO: distribute this betweeen ticks + // TODO: distribute this between ticks let (key, region) = self.regions.get_index(i).unwrap(); if region.removable() { regions_to_remove.push(*key); diff --git a/common/src/states/basic_ranged.rs b/common/src/states/basic_ranged.rs index b41bd6c208..dd7f0ff820 100644 --- a/common/src/states/basic_ranged.rs +++ b/common/src/states/basic_ranged.rs @@ -9,7 +9,7 @@ use std::time::Duration; #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] pub struct Data { - /// Can you hold the abilty beyond the prepare duration + /// Can you hold the ability beyond the prepare duration pub holdable: bool, /// How long we have to prepare the weapon pub prepare_duration: Duration, diff --git a/common/src/states/charged_ranged.rs b/common/src/states/charged_ranged.rs index 7014f8de58..b876fe59ef 100644 --- a/common/src/states/charged_ranged.rs +++ b/common/src/states/charged_ranged.rs @@ -23,7 +23,7 @@ pub struct Data { pub initial_damage: u32, /// How much damage is dealt with max charge pub max_damage: u32, - /// How much knockback there is with no chage + /// How much knockback there is with no charge pub initial_knockback: f32, /// How much knockback there is at max charge pub max_knockback: f32, diff --git a/common/src/states/triple_strike.rs b/common/src/states/triple_strike.rs index fcb62f5846..2a9c76b679 100644 --- a/common/src/states/triple_strike.rs +++ b/common/src/states/triple_strike.rs @@ -60,7 +60,7 @@ pub struct Data { pub stage_time_active: Duration, /// Whether current stage has exhausted its attack pub stage_exhausted: bool, - /// Whether state has performed intialization logic + /// Whether state has performed initialization logic pub initialized: bool, /// What this instance's current transition stat is pub transition_style: TransitionStyle, diff --git a/common/src/sys/agent.rs b/common/src/sys/agent.rs index 1cc870b3b5..de42980705 100644 --- a/common/src/sys/agent.rs +++ b/common/src/sys/agent.rs @@ -141,7 +141,7 @@ impl<'a> System<'a> for Sys { let mut inputs = &mut controller.inputs; - // Default to looking in orientation direction (can be overriden below) + // Default to looking in orientation direction (can be overridden below) inputs.look_dir = ori.0; const AVG_FOLLOW_DIST: f32 = 6.0; @@ -553,7 +553,7 @@ impl<'a> System<'a> for Sys { debug_assert!(inputs.look_dir.map(|e| !e.is_nan()).reduce_and()); } - // Proccess group invites + // Process group invites for (_invite, alignment, agent, controller) in (&invites, &alignments, &mut agents, &mut controllers).join() { diff --git a/common/src/sys/character_behavior.rs b/common/src/sys/character_behavior.rs index eccf237433..591a46e227 100644 --- a/common/src/sys/character_behavior.rs +++ b/common/src/sys/character_behavior.rs @@ -130,7 +130,7 @@ impl<'a> JoinData<'a> { } /// ## Character Behavior System -/// Passes `JoinData` to `CharacterState`'s `behavior` handler fn's. Recieves a +/// Passes `JoinData` to `CharacterState`'s `behavior` handler fn's. Receives a /// `StateUpdate` in return and performs updates to ECS Components from that. pub struct Sys; diff --git a/common/src/sys/phys.rs b/common/src/sys/phys.rs index 99e914298c..10b0e503d6 100644 --- a/common/src/sys/phys.rs +++ b/common/src/sys/phys.rs @@ -21,9 +21,10 @@ pub const GRAVITY: f32 = 9.81 * 5.0; const BOUYANCY: f32 = 1.0; // Friction values used for linear damping. They are unitless quantities. The // value of these quantities must be between zero and one. They represent the -// amount an object will slow down within 1/60th of a second. Eg. if the frction -// is 0.01, and the speed is 1.0, then after 1/60th of a second the speed will -// be 0.99. after 1 second the speed will be 0.54, which is 0.99 ^ 60. +// amount an object will slow down within 1/60th of a second. Eg. if the +// friction is 0.01, and the speed is 1.0, then after 1/60th of a second the +// speed will be 0.99. after 1 second the speed will be 0.54, which is 0.99 ^ +// 60. const FRIC_GROUND: f32 = 0.15; const FRIC_AIR: f32 = 0.0125; const FRIC_FLUID: f32 = 0.2; diff --git a/common/src/sys/stats.rs b/common/src/sys/stats.rs index 100cd4170b..8576754f59 100644 --- a/common/src/sys/stats.rs +++ b/common/src/sys/stats.rs @@ -112,7 +112,7 @@ impl<'a> System<'a> for Sys { energy.get_mut_unchecked().regen_rate = 0.0 } }, - // recover small amount of pasive energy from blocking, and bonus energy from + // recover small amount of passive energy from blocking, and bonus energy from // blocking attacks? CharacterState::BasicBlock => { let res = { diff --git a/common/src/terrain/map.rs b/common/src/terrain/map.rs index e8977fb1bb..2a50b9a982 100644 --- a/common/src/terrain/map.rs +++ b/common/src/terrain/map.rs @@ -250,7 +250,7 @@ pub struct MapConfig<'a> { /// /// (where θ is the half-angle of the FOV). /// - /// Taking the limit as θ → 90, we show that this degenrates to an + /// Taking the limit as θ → 90, we show that this degenerates to an /// orthogonal projection: /// /// lim{n → ∞}(-f(-n / z - 1) / (f - n)) = -(z - -n) / (f - n). @@ -560,7 +560,7 @@ impl<'a> MapConfig<'a> { }); }); - // Color in connectins. + // Color in connections. let water_color_factor = 2.0; let g_water = 32.0 * water_color_factor; let b_water = 64.0 * water_color_factor; diff --git a/common/src/typed.rs b/common/src/typed.rs index 1dbf98f069..dda903a180 100644 --- a/common/src/typed.rs +++ b/common/src/typed.rs @@ -93,7 +93,7 @@ impl, T, S> Typed, S> for T { /// } /// /// /// The actual *cases.* If you think of pattern match arms as being closures that accept -/// /// the cconstructor types as arguments, you can think of this structure as somehow +/// /// the constructor types as arguments, you can think of this structure as somehow /// /// representing just the data *owned* by the closure. This is also what you will /// /// generally store in your ron file--it has a field for each constructor of your enum, /// /// with the types of all the fields specified by the implementation of [PackedElim] for diff --git a/common/src/util/color.rs b/common/src/util/color.rs index 61a166693e..e20b526bb8 100644 --- a/common/src/util/color.rs +++ b/common/src/util/color.rs @@ -141,7 +141,7 @@ pub fn saturate_srgb(col: Rgb, value: f32) -> Rgb { linear_to_srgb(hsv_to_rgb(hsv).map(|e| e.min(1.0).max(0.0))) } -/// Preserves the luma of one color while changing its chromaticty to match the +/// Preserves the luma of one color while changing its chromaticity to match the /// other #[inline(always)] pub fn chromify_srgb(luma: Rgb, chroma: Rgb) -> Rgb { diff --git a/common/src/util/dir.rs b/common/src/util/dir.rs index 22aa1b0fe6..af9a29ced0 100644 --- a/common/src/util/dir.rs +++ b/common/src/util/dir.rs @@ -81,7 +81,7 @@ impl Dir { Self(slerp_normalized(from.0, to.0, factor)) } - /// Note: this uses `from` if `to` is unormalizable + /// Note: this uses `from` if `to` is unnormalizable pub fn slerp_to_vec3(from: Self, to: Vec3, factor: f32) -> Self { Self(slerp_to_unnormalized(from.0, to, factor).unwrap_or_else(|e| e)) } @@ -185,7 +185,7 @@ fn slerp_normalized(from: vek::Vec3, to: vek::Vec3, factor: f32) -> ve /// Additionally, it avoids unnecessary calculations if they are near identical /// Assumes `from` is normalized and returns a normalized vector, but `to` /// doesn't need to be normalized -/// Returns `Err(from)`` if `to` is unormalizable +/// Returns `Err(from)`` if `to` is unnormalizable // TODO: in some cases we might want to base the slerp rate on the magnitude of // `to` for example when `to` is velocity and `from` is orientation fn slerp_to_unnormalized( diff --git a/network/examples/fileshare/src/main.rs b/network/examples/fileshare/src/main.rs index a0fde1a622..38a72d2021 100644 --- a/network/examples/fileshare/src/main.rs +++ b/network/examples/fileshare/src/main.rs @@ -83,7 +83,7 @@ fn get_options<'a, 'b>() -> App<'a, 'b> { .setting(clap::AppSettings::ColorAuto) .subcommand(SubCommand::with_name("quit").about("closes program")) .subcommand(SubCommand::with_name("disconnect").about("stop connections to all servers")) - .subcommand(SubCommand::with_name("t").about("quick test by connectiong to 127.0.0.1:1231")) + .subcommand(SubCommand::with_name("t").about("quick test by connecting to 127.0.0.1:1231")) .subcommand( SubCommand::with_name("connect") .about("opens a connection to another instance of this fileserver network") diff --git a/network/examples/fileshare/src/server.rs b/network/examples/fileshare/src/server.rs index a94a1e668c..7a5f814a05 100644 --- a/network/examples/fileshare/src/server.rs +++ b/network/examples/fileshare/src/server.rs @@ -72,7 +72,7 @@ impl Server { match self.network.connect(addr.clone()).await { Ok(p) => self.loop_participant(p).await, Err(e) => { - println!("Failled to connect to {:?}, err: {:?}", &addr, e); + println!("Failed to connect to {:?}, err: {:?}", &addr, e); }, } }, diff --git a/network/examples/tcp-loadtest/src/main.rs b/network/examples/tcp-loadtest/src/main.rs index d1d2bbe9f4..92a3c9cd51 100644 --- a/network/examples/tcp-loadtest/src/main.rs +++ b/network/examples/tcp-loadtest/src/main.rs @@ -93,7 +93,7 @@ fn main() -> Result<(), u32> { let cur = Instant::now(); let dur = cur.duration_since(start_time); println!("================"); - println!("test endet"); + println!("test ended"); println!( "total send: {}MiB", total_bytes_send.load(Ordering::Relaxed) / (1024 * 1024) diff --git a/network/src/api.rs b/network/src/api.rs index 07fbcd1375..33cfac8015 100644 --- a/network/src/api.rs +++ b/network/src/api.rs @@ -166,7 +166,7 @@ impl Network { /// * `FnOnce` - you need to run the returning FnOnce exactly once, probably /// in it's own thread. this is NOT done internally, so that you are free /// to choose the threadpool implementation of your choice. We recommend - /// using [`ThreadPool`] from [`uvth`] crate. This fn will runn the + /// using [`ThreadPool`] from [`uvth`] crate. This fn will run the /// Scheduler to handle all `Network` internals. Additional threads will /// be allocated on an internal async-aware threadpool /// @@ -208,7 +208,7 @@ impl Network { /// See [`new`] /// /// # additional Arguments - /// * `registry` - Provide a Registy in order to collect Prometheus metrics + /// * `registry` - Provide a Registry in order to collect Prometheus metrics /// by this `Network`, `None` will deactivate Tracing. Tracing is done via /// [`prometheus`] /// @@ -301,14 +301,14 @@ impl Network { .send((address, s2a_result_s)) .await?; match s2a_result_r.await? { - //waiting guarantees that we either listened sucessfully or get an error like port in + //waiting guarantees that we either listened successfully or get an error like port in // use Ok(()) => Ok(()), Err(e) => Err(NetworkError::ListenFailed(e)), } } - /// starts connectiong to an [`ProtocolAddr`]. + /// starts connection to an [`ProtocolAddr`]. /// When the method returns the Network either returns a [`Participant`] /// ready to open [`Streams`] on OR has returned a [`NetworkError`] (e.g. /// can't connect, or invalid Handshake) # Examples @@ -443,7 +443,7 @@ impl Participant { /// * `promises` - use a combination of you prefered [`Promises`], see the /// link for further documentation. You can combine them, e.g. /// `PROMISES_ORDERED | PROMISES_CONSISTENCY` The Stream will then - /// guarantee that those promisses are met. + /// guarantee that those promises are met. /// /// A [`ParticipantError`] might be thrown if the `Participant` is already /// closed. [`Streams`] can be created without a answer from the remote @@ -511,7 +511,7 @@ impl Participant { /// /// # fn main() -> std::result::Result<(), Box> { /// // Create a Network, connect on port 2110 and wait for the other side to open a stream - /// // Note: It's quite unusal to activly connect, but then wait on a stream to be connected, usually the Appication taking initiative want's to also create the first 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 (network, f) = Network::new(Pid::new()); /// std::thread::spawn(f); /// # let (remote, fr) = Network::new(Pid::new()); @@ -557,7 +557,7 @@ impl Participant { /// There is NO `disconnected` function in `Participant`, if a `Participant` /// is no longer reachable (e.g. as the network cable was unplugged) the /// `Participant` will fail all action, but needs to be manually - /// disconected, using this function. + /// disconnected, using this function. /// /// # Examples /// ```rust @@ -607,7 +607,7 @@ impl Participant { match res { Ok(()) => trace!(?pid, "Participant is now closed"), Err(ref e) => { - trace!(?pid, ?e, "Error occured during shutdown of participant") + trace!(?pid, ?e, "Error occurred during shutdown of participant") }, }; res @@ -684,7 +684,7 @@ impl Stream { /// will be send. If the `Stream` is dropped from remote side no further /// messages are send, because the remote side has no way of listening /// to them either way. If the last channel is destroyed (e.g. by losing - /// the internet connection or non-gracefull shutdown, pending messages + /// the internet connection or non-graceful shutdown, pending messages /// are also dropped. /// /// # Example @@ -906,7 +906,7 @@ impl Drop for Participant { match task::block_on(self.a2s_disconnect_s.lock()).take() { None => trace!( ?pid, - "Participant has been shutdown cleanly, no further waiting is requiered!" + "Participant has been shutdown cleanly, no further waiting is required!" ), Some(mut a2s_disconnect_s) => { debug!(?pid, "Disconnect from Scheduler"); @@ -936,7 +936,7 @@ impl Drop for Participant { impl Drop for Stream { fn drop(&mut self) { - // send if closed is unecessary but doesnt hurt, we must not crash + // send if closed is unnecessary but doesnt hurt, we must not crash if !self.send_closed.load(Ordering::Relaxed) { let sid = self.sid; let pid = self.pid; diff --git a/network/src/channel.rs b/network/src/channel.rs index 6eae373ac5..cff0591e3b 100644 --- a/network/src/channel.rs +++ b/network/src/channel.rs @@ -88,7 +88,7 @@ pub(crate) struct Handshake { impl Handshake { #[cfg(debug_assertions)] - const WRONG_NUMBER: &'static [u8] = "Handshake does not contain the magic number requiered by \ + const WRONG_NUMBER: &'static [u8] = "Handshake does not contain the magic number required by \ veloren server.\nWe are not sure if you are a valid \ veloren client.\nClosing the connection" .as_bytes(); @@ -150,7 +150,7 @@ impl Handshake { if cnt > 0 { debug!( ?cnt, - "Some additional frames got already transfered, piping them to the \ + "Some additional frames got already transferred, piping them to the \ bparticipant as leftover_frames" ); } diff --git a/network/src/lib.rs b/network/src/lib.rs index 264527c5d3..f63eb9abb4 100644 --- a/network/src/lib.rs +++ b/network/src/lib.rs @@ -15,11 +15,11 @@ //! other [`Networks`] over the network protocols (e.g. TCP, UDP) //! //! To connect to another application, you must know it's [`ProtocolAddr`]. One -//! side will call [`connect`], the other [`connected`]. If successfull both +//! side will call [`connect`], the other [`connected`]. If successful both //! applications will now get a [`Participant`]. //! //! This [`Participant`] represents the connection between those 2 applications. -//! over the respective [`ProtocolAddr`] and with it the choosen network +//! over the respective [`ProtocolAddr`] and with it the chosen network //! protocol. However messages can't be send directly via [`Participants`], //! instead you must open a [`Stream`] on it. Like above, one side has to call //! [`open`], the other [`opened`]. [`Streams`] can have a different priority diff --git a/network/src/message.rs b/network/src/message.rs index d5ab754a26..9b2255e890 100644 --- a/network/src/message.rs +++ b/network/src/message.rs @@ -5,7 +5,7 @@ use std::{io, sync::Arc}; //Todo: Evaluate switching to VecDeque for quickly adding and removing data // from front, back. -// - It would prob requiere custom bincode code but thats possible. +// - It would prob require custom bincode code but thats possible. /// Support struct used for optimising sending the same Message to multiple /// [`Stream`] /// @@ -47,7 +47,7 @@ pub(crate) fn deserialize(buffer: MessageBuffer) -> bincode let span = lz4_compress::decompress(&buffer.data) .expect("lz4 decompression failed, failed to deserialze"); //this might fail if you choose the wrong type for M. in that case probably X - // got transfered while you assume Y. probably this means your application + // got transferred while you assume Y. probably this means your application // logic is wrong. E.g. You expect a String, but just get a u8. bincode::deserialize(span.as_slice()) } diff --git a/network/src/participant.rs b/network/src/participant.rs index ecfc548879..2eefa73857 100644 --- a/network/src/participant.rs +++ b/network/src/participant.rs @@ -197,7 +197,7 @@ impl BParticipant { mut b2s_prio_statistic_s: mpsc::UnboundedSender, ) { //This time equals the MINIMUM Latency in average, so keep it down and //Todo: - // make it configureable or switch to await E.g. Prio 0 = await, prio 50 + // make it configurable or switch to await E.g. Prio 0 = await, prio 50 // wait for more messages const TICK_TIME: Duration = Duration::from_millis(10); const FRAMES_PER_TICK: usize = 10005; @@ -244,7 +244,7 @@ impl BParticipant { self.running_mgr.fetch_sub(1, Ordering::Relaxed); } - //retruns false if sending isn't possible. In that case we have to render the + //returns false if sending isn't possible. In that case we have to render the // Participant `closed` #[must_use = "You need to check if the send was successful and report to client!"] async fn send_frame( @@ -425,7 +425,7 @@ impl BParticipant { warn!( ?e, ?mid, - "Dropping message, as streams seem to be in act of beeing \ + "Dropping message, as streams seem to be in act of being \ dropped right now" ); } @@ -584,7 +584,7 @@ impl BParticipant { self.running_mgr.fetch_sub(1, Ordering::Relaxed); } - /// when activated this function will drop the participant completly and + /// when activated this function will drop the participant completely and /// wait for everything to go right! Then return 1. Shutting down /// Streams for API and End user! 2. Wait for all "prio queued" Messages /// to be send. 3. Send Stream @@ -791,7 +791,7 @@ impl BParticipant { } } - ///closing api::Participant is done by closing all channels, exepct for the + ///closing api::Participant is done by closing all channels, expect for the /// shutdown channel at this point! async fn close_api(&self, reason: Option) { self.close_write_api(reason).await; diff --git a/network/src/prios.rs b/network/src/prios.rs index 1026b5f581..ca8ec22bc8 100644 --- a/network/src/prios.rs +++ b/network/src/prios.rs @@ -3,7 +3,7 @@ //!all 5 numbers the throughput is halved. //!E.g. in the same time 100 prio0 messages are send, only 50 prio5, 25 prio10, //! 12 prio15 or 6 prio20 messages are send. Note: TODO: prio0 will be send -//! immeadiatly when found! +//! immediately when found! //! #[cfg(feature = "metrics")] use crate::metrics::NetworkMetrics; @@ -29,7 +29,7 @@ pub(crate) struct PrioManager { messages: [VecDeque<(Sid, OutgoingMessage)>; PRIO_MAX], messages_rx: Receiver<(Prio, Sid, OutgoingMessage)>, sid_owned: HashMap, - //you can register to be notified if a pid_sid combination is flushed completly here + //you can register to be notified if a pid_sid combination is flushed completely here sid_flushed_rx: Receiver<(Sid, oneshot::Sender<()>)>, queued: HashSet, #[cfg(feature = "metrics")] @@ -194,7 +194,7 @@ impl PrioManager { lowest = n_points; lowest_id = Some(n) } else if n_points == lowest && lowest_id.is_some() && n < lowest_id.unwrap() { - //on equial points lowest first! + //on equal points lowest first! lowest_id = Some(n) } } @@ -231,7 +231,7 @@ impl PrioManager { self.points[prio as usize] += Self::PRIOS[prio as usize]; //pop message from front of VecDeque, handle it and push it back, so that all // => messages with same prio get a fair chance :) - //TODO: evalaute not poping every time + //TODO: evaluate not popping every time let (sid, mut msg) = self.messages[prio as usize].pop_front().unwrap(); if msg.fill_next(sid, frames) { //trace!(?m.mid, "finish message"); @@ -556,7 +556,7 @@ mod tests { //important in that test is, that after the first frames got cleared i reset // the Points even though 998 prio 16 messages have been send at this - // point and 0 prio20 messages the next mesasge is a prio16 message + // point and 0 prio20 messages the next message is a prio16 message // again, and only then prio20! we dont want to build dept over a idling // connection assert_header(&mut frames, 2, 3); diff --git a/network/src/protocols.rs b/network/src/protocols.rs index f26e2572f7..1616691ff7 100644 --- a/network/src/protocols.rs +++ b/network/src/protocols.rs @@ -481,8 +481,8 @@ impl UdpProtocol { start += n; if n != len { error!( - "THIS DOESNT WORK, as RECEIVER CURRENLTY ONLY HANDLES 1 FRAME per \ - UDP message. splitting up will fail!" + "THIS DOESN'T WORK, as RECEIVER CURRENTLY ONLY HANDLES 1 FRAME \ + per UDP message. splitting up will fail!" ); } }, diff --git a/network/src/scheduler.rs b/network/src/scheduler.rs index b352463166..e4fb5a3b7e 100644 --- a/network/src/scheduler.rs +++ b/network/src/scheduler.rs @@ -327,8 +327,8 @@ impl Scheduler { error!( ?pid, ?e, - "Failed to finish sending all remainding messages to participant when \ - shutting down" + "Failed to finish sending all remaining messages to participant when shutting \ + down" ); }; } @@ -490,7 +490,7 @@ impl Scheduler { //channels are unknown till PID is known! /* When A connects to a NETWORK, we, the listener answers with a Handshake. Pro: - Its easier to debug, as someone who opens a port gets a magic number back! - Contra: - DOS posibility because we answer fist + Contra: - DOS possibility because we answer first - Speed, because otherwise the message can be send with the creation */ let mut participant_channels = self.participant_channels.lock().await.clone().unwrap(); @@ -585,7 +585,7 @@ impl Scheduler { // someone is waiting with `connect`, so give them their PID pid_oneshot.send(Ok(participant)).unwrap(); } else { - // noone is waiting on this Participant, return in to Network + // no one is waiting on this Participant, return in to Network participant_channels .s2a_connected_s .send(participant) diff --git a/network/src/types.rs b/network/src/types.rs index 527fc368ae..267d539f03 100644 --- a/network/src/types.rs +++ b/network/src/types.rs @@ -25,7 +25,7 @@ pub const PROMISES_ORDERED: Promises = 1; /// like bit flips, this is done with a checksum. pub const PROMISES_CONSISTENCY: Promises = 2; /// this will guarantee that the other side will receive every message exactly -/// once no messages are droped +/// once no messages are dropped pub const PROMISES_GUARANTEED_DELIVERY: Promises = 4; /// this will enable the internal compression on this /// [`Stream`](crate::api::Stream) @@ -65,7 +65,7 @@ pub(crate) enum Frame { pid: Pid, secret: u128, }, - Shutdown, /* Shutsdown this channel gracefully, if all channels are shut down, Participant + Shutdown, /* Shutdown this channel gracefully, if all channels are shutdown, Participant * is deleted */ OpenStream { sid: Sid, diff --git a/network/tests/closing.rs b/network/tests/closing.rs index c40762e9ec..dd6cd310a8 100644 --- a/network/tests/closing.rs +++ b/network/tests/closing.rs @@ -2,7 +2,7 @@ //! - in the first line we call the helper, this is only debug code. in case //! you want to have tracing for a special test you set set the bool = true //! and the sleep to 10000 and your test will start 10 sec delayed with -//! tracing. You need a delay as otherwise the other tests polute your trace +//! tracing. You need a delay as otherwise the other tests pollute your trace //! - the second line is to simulate a client and a server //! `network_participant_stream` will return //! - 2 networks diff --git a/server/src/events/player.rs b/server/src/events/player.rs index 8b5ea37dfe..b7415c2b73 100644 --- a/server/src/events/player.rs +++ b/server/src/events/player.rs @@ -82,7 +82,7 @@ pub fn handle_client_disconnect(server: &mut Server, entity: EcsEntity) -> Event let participant = match client.participant.try_lock() { Ok(mut p) => p.take().unwrap(), Err(e) => { - error!(?e, ?entity, "coudln't lock participant for removal"); + error!(?e, ?entity, "couldn't lock participant for removal"); return Event::ClientDisconnected { entity }; }, }; @@ -102,9 +102,9 @@ pub fn handle_client_disconnect(server: &mut Server, entity: EcsEntity) -> Event trace!(?pid, "finished disconnect"); let elapsed = now.elapsed(); if elapsed.as_millis() > 100 { - warn!(?elapsed, ?pid, "disconecting took quite long"); + warn!(?elapsed, ?pid, "disconnecting took quite long"); } else { - debug!(?elapsed, ?pid, "disconecting took"); + debug!(?elapsed, ?pid, "disconnecting took"); } }); } diff --git a/server/src/lib.rs b/server/src/lib.rs index d93851401c..ce83a971f7 100644 --- a/server/src/lib.rs +++ b/server/src/lib.rs @@ -217,19 +217,19 @@ impl Server { .unwrap_or(center_chunk); // calculate the absolute position of the chunk in the world - // (we could add TerrainChunkSize::RECT_SIZE / 2 here, to spawn in the midde of + // (we could add TerrainChunkSize::RECT_SIZE / 2 here, to spawn in the middle of // the chunk) let spawn_location = spawn_chunk.map2(TerrainChunkSize::RECT_SIZE, |e, sz| { e as i32 * sz as i32 + sz as i32 / 2 }); - // get a z cache for the collumn in which we want to spawn + // get a z cache for the column in which we want to spawn let mut block_sampler = world.sample_blocks(); let z_cache = block_sampler .get_z_cache(spawn_location, index) .expect(&format!("no z_cache found for chunk: {}", spawn_chunk)); - // get the minimum and maximum z values at which there could be soild blocks + // get the minimum and maximum z values at which there could be solid blocks let (min_z, _, max_z) = z_cache.get_z_limits(&mut block_sampler, index); // round range outwards, so no potential air block is missed let min_z = min_z.floor() as i32; @@ -237,7 +237,7 @@ impl Server { // loop over all blocks from min_z to max_z + 1 // until the first air block is found - // (up to max_z + 1, because max_z could still be a soild block) + // (up to max_z + 1, because max_z could still be a solid block) // if no air block is found default to max_z + 1 let z = (min_z..(max_z + 1) + 1) .find(|z| { @@ -394,7 +394,7 @@ impl Server { let before_message_system = Instant::now(); - // Run message recieving sys before the systems in common for decreased latency + // Run message receiving sys before the systems in common for decreased latency // (e.g. run before controller system) sys::message::Sys.run_now(&self.state.ecs()); @@ -414,7 +414,7 @@ impl Server { // Apply terrain changes and update the region map after processing server // events so that changes made by server events will be immediately - // visble to client synchronization systems, minimizing the latency of + // visible to client synchronization systems, minimizing the latency of // `ServerEvent` mediated effects self.state.update_region_map(); self.state.apply_terrain_changes(); @@ -519,10 +519,10 @@ impl Server { chunk_generator.cancel_all(); if client.is_empty() { - // No cilents, so just clear all terrain. + // No clients, so just clear all terrain. terrain.clear(); } else { - // There's at leasat one client, so regenerate all chunks. + // There's at least one client, so regenerate all chunks. terrain.iter().for_each(|(pos, _)| { chunk_generator.generate_chunk( None, diff --git a/server/src/metrics.rs b/server/src/metrics.rs index a23a77db79..8c94041a2a 100644 --- a/server/src/metrics.rs +++ b/server/src/metrics.rs @@ -65,7 +65,7 @@ impl TickMetrics { "number of all chunks currently active on the server", ))?; let tick_time = IntGaugeVec::new( - Opts::new("tick_time", "time in ns requiered for a tick of the server"), + Opts::new("tick_time", "time in ns required for a tick of the server"), &["period"], )?; diff --git a/server/src/persistence/character.rs b/server/src/persistence/character.rs index 0b14c7c44c..90369e0b6b 100644 --- a/server/src/persistence/character.rs +++ b/server/src/persistence/character.rs @@ -27,7 +27,7 @@ use tracing::{error, warn}; type CharacterLoaderRequest = (specs::Entity, CharacterLoaderRequestKind); -/// Available database operations when modifying a player's characetr list +/// Available database operations when modifying a player's character list enum CharacterLoaderRequestKind { CreateCharacter { player_uuid: String, @@ -311,7 +311,7 @@ fn load_character_list(player_uuid: &str, db_dir: &str) -> CharacterListResult { /// /// Note that sqlite does not support returning the inserted data after a /// successful insert. To workaround, we wrap this in a transaction which -/// inserts, queries for the newly created chaacter id, then uses the character +/// inserts, queries for the newly created character id, then uses the character /// id for subsequent insertions fn create_character( uuid: &str, diff --git a/server/src/persistence/error.rs b/server/src/persistence/error.rs index 93d56caa14..2fd97900c6 100644 --- a/server/src/persistence/error.rs +++ b/server/src/persistence/error.rs @@ -8,11 +8,11 @@ use std::fmt; pub enum Error { // The player has already reached the max character limit CharacterLimitReached, - // An error occured while establish a db connection + // An error occurred while establish a db connection DatabaseConnectionError(diesel::ConnectionError), - // An error occured while running migrations + // An error occurred while running migrations DatabaseMigrationError(diesel_migrations::RunMigrationsError), - // An error occured when performing a database action + // An error occurred when performing a database action DatabaseError(diesel::result::Error), // Unable to load body or stats for a character CharacterDataError, diff --git a/server/src/persistence/models.rs b/server/src/persistence/models.rs index b5ad85b438..1c59e5127f 100644 --- a/server/src/persistence/models.rs +++ b/server/src/persistence/models.rs @@ -264,7 +264,7 @@ impl From<&comp::Inventory> for InventoryUpdate { /// which is loaded with their character data, however there are plans for each /// character to have multiple Loadouts which they can switch between during /// gameplay. Due to this Loadouts have a many to one relationship with -/// characetrs, and a distinct `id`. +/// characters, and a distinct `id`. #[derive(Associations, Queryable, Debug, Identifiable)] #[belongs_to(Character)] #[primary_key(id)] diff --git a/server/src/sys/entity_sync.rs b/server/src/sys/entity_sync.rs index 202592b44b..171c5bb7db 100644 --- a/server/src/sys/entity_sync.rs +++ b/server/src/sys/entity_sync.rs @@ -229,8 +229,8 @@ impl<'a> System<'a> for Sys { { let mut comp_sync_package = CompSyncPackage::new(); let mut throttle = true; - // TODO: An entity that stoppped moving on a tick that it wasn't sent to the - // player will never have it's position updated + // TODO: An entity that stopped moving on a tick that it wasn't sent to the + // player will never have its position updated match last_pos.get(entity).map(|&l| l.0 != pos) { Some(false) => {}, Some(true) => { diff --git a/server/src/sys/message.rs b/server/src/sys/message.rs index 415f9d4727..1ee944199e 100644 --- a/server/src/sys/message.rs +++ b/server/src/sys/message.rs @@ -274,7 +274,7 @@ impl Sys { Err(ChatMsgValidationError::TooLong) => { let max = MAX_BYTES_CHAT_MSG; let len = message.len(); - warn!(?len, ?max, "Recieved a chat message that's too long") + warn!(?len, ?max, "Received a chat message that's too long") }, } }, diff --git a/server/src/sys/subscription.rs b/server/src/sys/subscription.rs index 870b4f14b3..f494b30f49 100644 --- a/server/src/sys/subscription.rs +++ b/server/src/sys/subscription.rs @@ -60,9 +60,9 @@ impl<'a> System<'a> for Sys { // To update subscriptions // 1. Iterate through clients // 2. Calculate current chunk position - // 3. If chunk is the same return, otherwise continue (use fuzzyiness) + // 3. If chunk is the same return, otherwise continue (use fuzziness) // 4. Iterate through subscribed regions - // 5. Check if region is still in range (use fuzzyiness) + // 5. Check if region is still in range (use fuzziness) // 6. If not in range // - remove from hashset // - inform client of which entities to remove @@ -178,7 +178,7 @@ impl<'a> System<'a> for Sys { (vd as f32 * chunk_size) + (client::CHUNK_FUZZ as f32 + chunk_size) * 2.0f32.sqrt(), ) { - // Send client intial info about the entities in this region if it was not + // Send client initial info about the entities in this region if it was not // already within the set of subscribed regions if subscription.regions.insert(key) { if let Some(region) = region_map.get(key) { @@ -268,7 +268,7 @@ pub fn initialize_region_subscription(world: &World, entity: specs::Entity) { } else { debug!( ?entity, - "Failed to initialize region subcription. Couldn't retrieve all the neccesary \ + "Failed to initialize region subscription. Couldn't retrieve all the neccesary \ components on the provided entity" ); } diff --git a/server/src/sys/terrain.rs b/server/src/sys/terrain.rs index d64b73accf..4fa2559fdb 100644 --- a/server/src/sys/terrain.rs +++ b/server/src/sys/terrain.rs @@ -17,9 +17,9 @@ use std::{sync::Arc, time::Duration}; use vek::*; /// This system will handle loading generated chunks and unloading -/// uneeded chunks. +/// unneeded chunks. /// 1. Inserts newly generated chunks into the TerrainGrid -/// 2. Sends new chunks to neaby clients +/// 2. Sends new chunks to nearby clients /// 3. Handles the chunk's supplement (e.g. npcs) /// 4. Removes chunks outside the range of players pub struct Sys; diff --git a/voxygen/src/ecs/comp.rs b/voxygen/src/ecs/comp.rs index fbeb915a65..377b8ae67e 100644 --- a/voxygen/src/ecs/comp.rs +++ b/voxygen/src/ecs/comp.rs @@ -10,7 +10,7 @@ pub struct HpFloater { pub timer: f32, // Numbers of times significant damage has been dealt pub hp_change: i32, - // Used for randomly offseting + // Used for randomly offsetting pub rand: f32, } #[derive(Clone, Debug, Default)] diff --git a/voxygen/src/ecs/sys/floater.rs b/voxygen/src/ecs/sys/floater.rs index 0b2334bda9..fcf5cd7eb6 100644 --- a/voxygen/src/ecs/sys/floater.rs +++ b/voxygen/src/ecs/sys/floater.rs @@ -33,8 +33,8 @@ impl<'a> System<'a> for Sys { &mut self, (entities, my_entity, dt, mut my_exp_floater_list, uids, pos, stats, mut hp_floater_lists): Self::SystemData, ) { - // Add hp floater lists to all entities with stats and a postion - // Note: neccessary in order to know last_hp + // Add hp floater lists to all entities with stats and a position + // Note: necessary in order to know last_hp for (entity, last_hp) in (&entities, &stats, &pos, !&hp_floater_lists) .join() .map(|(e, s, _, _)| (e, s.health.current())) @@ -63,9 +63,9 @@ impl<'a> System<'a> for Sys { // equivalently in the same frame) if hp_floater_list.last_hp != health.current() { hp_floater_list.last_hp = health.current(); - // TODO: What if multiple health changes occured since last check here + // TODO: What if multiple health changes occurred since last check here // Also, If we make stats store a vec of the last_changes (from say the last - // frame), what if the client recieves the stats component from + // frame), what if the client receives the stats component from // two different server ticks at once, then one will be lost // (tbf this is probably a rare occurance and the results // would just be a transient glitch in the display of these damage numbers) @@ -96,7 +96,7 @@ impl<'a> System<'a> for Sys { } } - // Remove floater lists on entities without stats or without posistion + // Remove floater lists on entities without stats or without position for entity in (&entities, !&stats, &hp_floater_lists) .join() .map(|(e, _, _)| e) diff --git a/voxygen/src/hud/bag.rs b/voxygen/src/hud/bag.rs index e3ab174156..c21d4ca3f5 100644 --- a/voxygen/src/hud/bag.rs +++ b/voxygen/src/hud/bag.rs @@ -173,7 +173,7 @@ impl<'a> Widget for Bag<'a> { }; let exp_percentage = (self.stats.exp.current() as f64) / (self.stats.exp.maximum() as f64); - let exp_treshold = format!( + let exp_threshold = format!( "{}/{} {}", self.stats.exp.current(), self.stats.exp.maximum(), @@ -532,7 +532,7 @@ impl<'a> Widget for Bag<'a> { .set(state.ids.expbar, ui); // Exp-Text - Text::new(&exp_treshold) + Text::new(&exp_threshold) .mid_top_with_margin_on(state.ids.expbar, 10.0) .font_id(self.fonts.cyri.conrod_id) .font_size(self.fonts.cyri.scale(15)) diff --git a/voxygen/src/hud/minimap.rs b/voxygen/src/hud/minimap.rs index 502ee619e0..1bdeef1395 100644 --- a/voxygen/src/hud/minimap.rs +++ b/voxygen/src/hud/minimap.rs @@ -189,7 +189,7 @@ impl<'a> Widget for MiniMap<'a> { .get(self.client.entity()) .map_or(Vec3::zero(), |pos| pos.0); - // Get map image source rectangle dimensons. + // Get map image source rectangle dimensions. let w_src = max_zoom / zoom; let h_src = max_zoom / zoom; diff --git a/voxygen/src/hud/social.rs b/voxygen/src/hud/social.rs index 130b4c7494..2b3773c51e 100644 --- a/voxygen/src/hud/social.rs +++ b/voxygen/src/hud/social.rs @@ -50,7 +50,7 @@ widget_ids! { pub struct State { ids: Ids, - // Holds the time when selection is made since this selection can be overriden + // Holds the time when selection is made since this selection can be overridden // by selecting an entity in-game selected_uid: Option<(Uid, Instant)>, } diff --git a/voxygen/src/mesh/greedy.rs b/voxygen/src/mesh/greedy.rs index d906ea4d24..d1f5ec8397 100644 --- a/voxygen/src/mesh/greedy.rs +++ b/voxygen/src/mesh/greedy.rs @@ -16,7 +16,7 @@ pub struct GreedyConfig { /// for queries against the volume. pub draw_delta: Vec3, /// For each dimension i, for faces drawn in planes *parallel* to i, - /// represents the number of voxels considered along dimenson i in those + /// represents the number of voxels considered along dimension i in those /// planes, starting from `draw_delta`. pub greedy_size: Vec3, /// For each dimension i, represents the number of planes considered @@ -53,7 +53,7 @@ pub struct GreedyConfig { /// otherwise have the same orientation, dimensions, and are /// next to each other. pub should_draw: FS, - /// Create an opauqe quad (used for only display rendering) from its + /// Create an opaque quad (used for only display rendering) from its /// top-left atlas position, the rectangle's dimensions in (2D) atlas /// space, a world position, the u and v axes of the rectangle in (3D) /// world space, the normal facing out frmo the rectangle in world @@ -165,7 +165,7 @@ impl<'a> GreedyMesh<'a> { /// suspend meshing partway through in order to meet frame budget, and /// potentially use a single staged upload to the GPU. /// - /// Returns the ColLightsInfo corresponding to the consstructed atlas. + /// Returns the ColLightsInfo corresponding to the constructed atlas. pub fn finalize(self) -> ColLightInfo { let cur_size = self.col_lights_size; let col_lights = vec![ @@ -530,7 +530,7 @@ fn draw_col_lights( // could be if we used the right AO strategy). // Each indirect light needs to come in through the direct light. // Thus, we assign each light a score based on opacity (currently just 0 or - // 1, but it could support transluscent lights in the future). + // 1, but it could support translucent lights in the future). // Thus, indirect_u_opacity and indirect_v_opacity are multiplied by // direct_opacity, and indirect_uv_opacity is multiplied by // the maximum of both of u and v's indirect opacities (since there are @@ -553,7 +553,7 @@ fn draw_col_lights( // top-right block let direct_v_opacity = get_opacity(data, light_pos - uv.y); - // NOTE: Since we only support 0/1 opacities currently, we asssume + // NOTE: Since we only support 0/1 opacities currently, we assume // direct_opacity is 1, and the light value will be zero anyway for objects // with opacity 0, we only "multiply" by indirect_uv_opacity for now (since // it's the only one that could be 0 even if its light value is not). diff --git a/voxygen/src/mesh/terrain.rs b/voxygen/src/mesh/terrain.rs index 4a7c008550..a95809bfbf 100644 --- a/voxygen/src/mesh/terrain.rs +++ b/voxygen/src/mesh/terrain.rs @@ -126,7 +126,7 @@ fn calc_light + ReadVol + Debug>( } }; - // Propage light + // Propagate light while let Some(pos) = prop_que.pop_front() { let pos = Vec3::new(pos.0 as i32, pos.1 as i32, pos.2 as i32); let light = light_map[lm_idx(pos.x, pos.y, pos.z)]; diff --git a/voxygen/src/profile.rs b/voxygen/src/profile.rs index 9ebb3d480d..ee0a43b5b7 100644 --- a/voxygen/src/profile.rs +++ b/voxygen/src/profile.rs @@ -40,7 +40,7 @@ impl Default for ServerProfile { /// `Profile` contains everything that can be configured in the profile.ron /// /// Initially it is just for persisting things that don't belong in -/// setttings.ron - like the state of hotbar and any other character level +/// settings.ron - like the state of hotbar and any other character level /// configuration. #[derive(Clone, Debug, Serialize, Deserialize)] #[serde(default)] diff --git a/voxygen/src/render/mod.rs b/voxygen/src/render/mod.rs index 9aadf43031..0d791d48af 100644 --- a/voxygen/src/render/mod.rs +++ b/voxygen/src/render/mod.rs @@ -75,19 +75,19 @@ pub enum AaMode { /// Multisampling AA, up to 4 samples per pixel. /// /// NOTE: MSAA modes don't (currently) work with greedy meshing, and will - /// also struggle in the futrue with deferred shading, so they may be + /// also struggle in the future with deferred shading, so they may be /// removed in the future. MsaaX4, /// Multisampling AA, up to 8 samples per pixel. /// /// NOTE: MSAA modes don't (currently) work with greedy meshing, and will - /// also struggle in the futrue with deferred shading, so they may be + /// also struggle in the future with deferred shading, so they may be /// removed in the future. MsaaX8, /// Multisampling AA, up to 16 samples per pixel. /// /// NOTE: MSAA modes don't (currently) work with greedy meshing, and will - /// also struggle in the futrue with deferred shading, so they may be + /// also struggle in the future with deferred shading, so they may be /// removed in the future. MsaaX16, /// Super-sampling antialiasing, 4 samples per pixel. @@ -123,7 +123,7 @@ pub enum CloudMode { /// - The volumetric clouds use raymarching, which will cause catastrophic /// performance degradation on GPUs without good support for loops. There /// is an attempt to minimize the impact of this using a z-range check, - /// but on some low-end GPUs (such as some integraetd graphics cards) this + /// but on some low-end GPUs (such as some integrated graphics cards) this /// test doesn't appear to be able to be predicted well at shader /// invocation time. /// - The cloud computations themselves are fairly involved, further @@ -180,7 +180,7 @@ pub enum LightingMode { /// Ashikhmin-Shirley BRDF lighting model. Attempts to generate a /// physically plausible (to some extent) lighting distribution. /// - /// This mdoel may not work as well with purely directional lighting, and is + /// This model may not work as well with purely directional lighting, and is /// more expensive than the other models. Ashikhmin, /// Standard Blinn-Phong shading, combing Lambertian diffuse reflections and diff --git a/voxygen/src/render/pipelines/particle.rs b/voxygen/src/render/pipelines/particle.rs index 3088bcb298..dd3b383548 100644 --- a/voxygen/src/render/pipelines/particle.rs +++ b/voxygen/src/render/pipelines/particle.rs @@ -40,7 +40,7 @@ gfx_defines! { // a cube is: f32 x 3 x 3 x 12 = 3456 bits // this vec is: f32 x 3 x 1 x 1 = 96 bits (per instance!) // consider using a throw-away mesh and - // positioning the vertex verticies instead, + // positioning the vertex vertices instead, // if we have: // - a triangle mesh, and 3 or more instances. // - a quad mesh, and 6 or more instances. diff --git a/voxygen/src/render/renderer.rs b/voxygen/src/render/renderer.rs index 41ba19f4ea..b89997da99 100644 --- a/voxygen/src/render/renderer.rs +++ b/voxygen/src/render/renderer.rs @@ -75,7 +75,7 @@ pub type TgtColorRes = gfx::handle::ShaderResourceView< ::View, >; -/// A handle to a greedy meshed color-light texture as a resorce. +/// A handle to a greedy meshed color-light texture as a resource. pub type ColLightRes = gfx::handle::ShaderResourceView< gfx_backend::Resources, ::View, @@ -615,7 +615,7 @@ impl Renderer { // NOTE: Safe because GL_TEXTURE_CUBE_MAP_SEAMLESS is supported by OpenGL 3.2+ // (see https://www.khronos.org/opengl/wiki/Cubemap_Texture#Seamless_cubemap); // enabling seamless cube maps should always be safe regardless of the state of - // the OpenGL context, so no further checks are needd. + // the OpenGL context, so no further checks are needed. device.with_gl(|gl| { gl.Enable(gfx_gl::TEXTURE_CUBE_MAP_SEAMLESS); }); @@ -1686,7 +1686,7 @@ fn create_pipelines( r#" {} -#define VOXYGEN_COMPUTATION_PREERENCE {} +#define VOXYGEN_COMPUTATION_PREFERENCE {} #define FLUID_MODE {} #define CLOUD_MODE {} #define LIGHTING_ALGORITHM {} @@ -1695,7 +1695,7 @@ fn create_pipelines( "#, constants, // TODO: Configurable vertex/fragment shader preference. - "VOXYGEN_COMPUTATION_PREERENCE_FRAGMENT", + "VOXYGEN_COMPUTATION_PREFERENCE_FRAGMENT", match mode.fluid { FluidMode::Cheap => "FLUID_MODE_CHEAP", FluidMode::Shiny => "FLUID_MODE_SHINY", diff --git a/voxygen/src/run.rs b/voxygen/src/run.rs index 9d68f02ef1..6f0d3a954a 100644 --- a/voxygen/src/run.rs +++ b/voxygen/src/run.rs @@ -23,7 +23,7 @@ pub fn run(mut global_state: GlobalState, event_loop: EventLoop) { let mut polled_twice = false; event_loop.run(move |event, _, control_flow| { - // Continously run loop since we handle sleeping + // Continuously run loop since we handle sleeping *control_flow = winit::event_loop::ControlFlow::Poll; // Get events for the ui. diff --git a/voxygen/src/scene/figure/cache.rs b/voxygen/src/scene/figure/cache.rs index 4a9526dc58..ce4411bb6e 100644 --- a/voxygen/src/scene/figure/cache.rs +++ b/voxygen/src/scene/figure/cache.rs @@ -1064,7 +1064,7 @@ impl FigureModelCache { }); // Update the figure bounds to the largest granularity seen so far - // (NOTE: this is more than a little imeprfect). + // (NOTE: this is more than a little imperfect). // // FIXME: Maybe use the default bone position in the idle animation // to figure this out instead? diff --git a/voxygen/src/scene/figure/load.rs b/voxygen/src/scene/figure/load.rs index c499f6d29d..ca372ef6bd 100644 --- a/voxygen/src/scene/figure/load.rs +++ b/voxygen/src/scene/figure/load.rs @@ -275,7 +275,7 @@ impl HumHeadSpec { ) } } -// Armor spects should be in the same order, top to bottom. +// Armor aspects should be in the same order, top to bottom. // These seem overly split up, but wanted to keep the armor seperated // unlike head which is done above. #[derive(Serialize, Deserialize)] diff --git a/voxygen/src/scene/math.rs b/voxygen/src/scene/math.rs index 3ebb5fdfad..7f21fac5f5 100644 --- a/voxygen/src/scene/math.rs +++ b/voxygen/src/scene/math.rs @@ -24,7 +24,7 @@ pub fn aabb_to_points(bounds: Aabb) -> [Vec3; 8] { /// a(x - x0) + b(y - y0) + c(z - z0) = 0, i.e. /// ax + by + cz - (a * x0 + b * y0 + c * z0) = 0, i.e. /// ax + by + cz = (a * x0 + b * y0 + c * z0), i.e. -/// (lettiing d = a * x0 + b * y0 + c * z0) +/// (letting d = a * x0 + b * y0 + c * z0) /// ax + by + cz = d /// /// where d is the distance of the plane from the origin. diff --git a/voxygen/src/scene/mod.rs b/voxygen/src/scene/mod.rs index 7e47fdeb72..d006fb1684 100644 --- a/voxygen/src/scene/mod.rs +++ b/voxygen/src/scene/mod.rs @@ -121,7 +121,7 @@ impl<'a> SceneData<'a> { pub fn get_moon_dir(&self) -> Vec3 { Globals::get_moon_dir(self.state.get_time_of_day()) } } -/// Approximte a scalar field of view angle using the parameterization from +/// Approximate a scalar field of view angle using the parameterization from /// section 4.3 of Lloyd's thesis: /// /// W_e = 2 n_e tan θ @@ -678,13 +678,13 @@ impl Scene { // n_opt = 1 / sin y (z_n + √(z_n + (f - n) sin y)) // // where n is near plane, f is far plane, y is the tilt angle between view and - // light directon, and n_opt is the optimal near plane. + // light direction, and n_opt is the optimal near plane. // We also want a way to transform and scale this matrix (* 0.5 + 0.5) in order // to transform it correctly into texture coordinates, as well as // OpenGL coordinates. Note that the matrix for directional light // is *already* linear in the depth buffer. let texture_mat = Mat4::scaling_3d(0.5f32) * Mat4::translation_3d(1.0f32); - // We need to compute these offset matrices to tranform world space coordinates + // We need to compute these offset matrices to transform world space coordinates // to the translated ones we use when multiplying by the light space // matrix; this helps avoid precision loss during the // multiplication. diff --git a/voxygen/src/scene/particle.rs b/voxygen/src/scene/particle.rs index be555c1468..f14d1cfbe8 100644 --- a/voxygen/src/scene/particle.rs +++ b/voxygen/src/scene/particle.rs @@ -422,7 +422,7 @@ impl HeartbeatScheduler { } } - /// updates the last elapsed times and elasped counts + /// updates the last elapsed times and elapsed counts /// this should be called once, and only once per tick. pub fn maintain(&mut self, now: f64) { self.last_known_time = now; @@ -436,10 +436,10 @@ impl HeartbeatScheduler { *heartbeats = full_heartbeats as u8; - // the remaining partial freqency cycle, as a decimal. + // the remaining partial frequency cycle, as a decimal. let partial_heartbeat = total_heartbeats - full_heartbeats; - // the remaining partial freqency cycle, as a unit of time(f64). + // the remaining partial frequency cycle, as a unit of time(f64). let partial_heartbeat_as_time = frequency.mul_f64(partial_heartbeat).as_secs_f64(); // now minus the left over heart beat count precision as seconds, @@ -449,7 +449,7 @@ impl HeartbeatScheduler { } } - /// returns the number of times this duration has elasped since the last + /// returns the number of times this duration has elapsed since the last /// tick: /// - if it's more frequent then tick rate, it could be 1 or more. /// - if it's less frequent then tick rate, it could be 1 or 0. diff --git a/voxygen/src/scene/terrain.rs b/voxygen/src/scene/terrain.rs index e045467285..a148b34d6c 100644 --- a/voxygen/src/scene/terrain.rs +++ b/voxygen/src/scene/terrain.rs @@ -430,7 +430,7 @@ fn mesh_worker + RectRasterableVol + ReadVol + Debug>( let ori = (block.get_ori().unwrap_or((seed % 4) as u8 * 2)) & 0b111; let variation = seed as usize % cfg.variations; let key = (block.kind(), variation); - // NOTE: Safe bbecause we called sprite_config_for already. + // NOTE: Safe because we called sprite_config_for already. // NOTE: Safe because 0 ≤ ori < 8 let sprite_data = &sprite_data[&key][0]; let instance = SpriteInstance::new( @@ -2684,7 +2684,7 @@ impl Terrain { .get(&response.pos) .map(|chunk| chunk.load_time) .unwrap_or(current_time as f32); - // TODO: Allocate new atlas on allocation faillure. + // TODO: Allocate new atlas on allocation failure. let (tex, tex_size) = response.col_lights_info; let atlas = &mut self.atlas; let allocation = atlas @@ -2692,7 +2692,7 @@ impl Terrain { i32::from(tex_size.x), i32::from(tex_size.y), )) - .expect("Not yet implemented: allocate new atlas on allocation faillure."); + .expect("Not yet implemented: allocate new atlas on allocation failure."); // NOTE: Cast is safe since the origin was a u16. let atlas_offs = Vec2::new( allocation.rectangle.min.x as u16, diff --git a/voxygen/src/ui/graphic/mod.rs b/voxygen/src/ui/graphic/mod.rs index 171d4156ab..b89a9ac9ae 100644 --- a/voxygen/src/ui/graphic/mod.rs +++ b/voxygen/src/ui/graphic/mod.rs @@ -46,7 +46,7 @@ pub enum Rotation { /// Images larger than this are stored in individual textures /// Fraction of the total graphic cache size -const ATLAS_CUTTOFF_FRAC: f32 = 0.2; +const ATLAS_CUTOFF_FRAC: f32 = 0.2; /// Multiplied by current window size const GRAPHIC_CACHE_RELATIVE_SIZE: u16 = 1; @@ -182,7 +182,7 @@ impl GraphicCache { pub fn get_graphic(&self, id: Id) -> Option<&Graphic> { self.graphic_map.get(&id) } - /// Used to aquire textures for rendering + /// Used to acquire textures for rendering pub fn get_tex(&self, id: TexId) -> &Texture { self.textures.get(id.0).expect("Invalid TexId used") } @@ -287,7 +287,7 @@ impl GraphicCache { textures.push(texture); CachedDetails::Immutable { index } } else if atlas_size - .map2(dims, |a, d| a as f32 * ATLAS_CUTTOFF_FRAC >= d as f32) + .map2(dims, |a, d| a as f32 * ATLAS_CUTOFF_FRAC >= d as f32) .reduce_and() { // Fit into an atlas diff --git a/voxygen/src/ui/graphic/pixel_art.rs b/voxygen/src/ui/graphic/pixel_art.rs index fa32f569fd..a269cd6e53 100644 --- a/voxygen/src/ui/graphic/pixel_art.rs +++ b/voxygen/src/ui/graphic/pixel_art.rs @@ -14,18 +14,18 @@ const EPSILON: f32 = 0.0001; // Say we have two areas that we are combining to form a single pixel // A1 and A2 where these are the fraction of the area of the pixel each color // contributes to Then if the colors were opaque we would say that the final -// color ouput color o3 is +// color output color o3 is // E1: o3 = A1 * o1 + A2 * o2 // where o1 and o2 are the opaque colors of the two areas // now say the areas are actually translucent and these opaque colors are -// derived by blending with a common backgound color b +// derived by blending with a common background color b // E2: o1 = c1 * a1 + b * (1 - a1) // E3: o2 = c2 * a2 + b * (1 - a2) // we want to find the combined color (c3) and combined alpha (a3) such that // E4: o3 = c3 * a3 + b * (1 - a3) // substitution of E2 and E3 into E1 gives // E5: o3 = A1 * (c1 * a1 + b * (1 - a1)) + A2 * (c2 * a2 + b * (1 - a2)) -// combining E4 and E5 then separting like terms into separte equations gives +// combining E4 and E5 then separating like terms into separate equations gives // E6: c3 * a3 = A1 * c1 * a1 + A2 * c2 * a2 // E7: b * (1 - a3) = A1 * b * (1 - a1) + A2 * b * (1 - a2) // dropping b from E7 and solving for a3 @@ -119,7 +119,7 @@ pub fn resize_pixel_art(image: &RgbaImage, new_width: u32, new_height: u32) -> R } } // Divide summed color by area sample covers and convert back to srgb - // I wonder if precalulating the inverse of these divs would have a significant + // I wonder if precalculating the inverse of these divs would have a significant // effect linear_color = linear_color / wratio / hratio; linear_color = diff --git a/voxygen/src/ui/img_ids.rs b/voxygen/src/ui/img_ids.rs index e0b8ec3a37..7eb011136b 100644 --- a/voxygen/src/ui/img_ids.rs +++ b/voxygen/src/ui/img_ids.rs @@ -29,7 +29,7 @@ impl<'a> GraphicCreator<'a> for ImageGraphic { } pub enum VoxelGraphic {} -// TODO: Are these uneeded now that we have PixArtGraphic? +// TODO: Are these unneeded now that we have PixArtGraphic? pub enum VoxelSsGraphic {} pub enum VoxelSs4Graphic {} pub enum VoxelSs9Graphic {} diff --git a/voxygen/src/ui/mod.rs b/voxygen/src/ui/mod.rs index 92743c625a..23f1d608e4 100644 --- a/voxygen/src/ui/mod.rs +++ b/voxygen/src/ui/mod.rs @@ -117,7 +117,7 @@ pub struct Ui { cache: Cache, // Draw commands for the next render draw_commands: Vec, - // Mesh buffer for UI vertics; we reuse its allocation in order to limit vector reallocations + // Mesh buffer for UI vertices; we reuse its allocation in order to limit vector reallocations // during redrawing. mesh: Mesh, // Model for drawing the ui @@ -762,7 +762,7 @@ impl Ui { // Don't do anything if resolution is zero if resolution.map(|e| e == 0).reduce_or() { continue; - // TODO: consider logging uneeded elements + // TODO: consider logging unneeded elements } let color = diff --git a/world/src/layer/mod.rs b/world/src/layer/mod.rs index c6e689a22c..b018c21fb8 100644 --- a/world/src/layer/mod.rs +++ b/world/src/layer/mod.rs @@ -127,7 +127,7 @@ pub fn apply_scatter_to<'a>( None, ) }), - // Collecable Objects + // Collectable Objects // Only spawn twigs in temperate forests (Twigs, false, |c| { ((c.tree_density - 0.5).max(0.0) * 1.0e-3, None) diff --git a/world/src/sim/erosion.rs b/world/src/sim/erosion.rs index e5128c60b5..3c16eb8a83 100644 --- a/world/src/sim/erosion.rs +++ b/world/src/sim/erosion.rs @@ -637,7 +637,7 @@ fn get_max_slope( /// areas. /// 3. Now, iterate through the list in *order.* Whether we used the filling /// method to compute a "filled" version of each depression, or used the lake -/// connection algoirthm described in [1], each node is guaranteed to have +/// connection algorithm described in [1], each node is guaranteed to have /// zero or one drainage edges out, representing the direction of water flow /// for that node. For nodes i with zero drainage edges out (boundary nodes /// and lake bottoms) we set the slope to 0 (so the change in altitude is @@ -664,7 +664,7 @@ fn get_max_slope( /// /// https://github.com/fastscape-lem/fastscapelib-fortran/blob/master/src/StreamPowerLaw.f90 /// -/// The approximate equation for soil production function (predictng the rate +/// The approximate equation for soil production function (predicting the rate /// at which bedrock turns into soil, increasing the distance between the /// basement and altitude) is taken from equation (11) from [2]. This (among /// numerous other sources) also includes at least one prediction that hillslope @@ -1387,7 +1387,7 @@ fn erode( // Because in the next round, if the old height is still wh_j or under, // it will be set precisely equal to the // estimated height, meaning it effectively - // "vanishes" and just deposits sediment to its reciever. + // "vanishes" and just deposits sediment to its receiver. // (This is probably related to criteria for block Gauss-Seidel, etc.). // NOTE: If we want erosion to proceed underwater, use h_j here instead // of wh_j. @@ -1445,7 +1445,7 @@ fn erode( } if n_gs_stream_power_law == max_n_gs_stream_power_law { warn!( - "Beware: Gauss-Siedel scheme not convergent: err={:?}, expected={:?}", + "Beware: Gauss-Seidel scheme not convergent: err={:?}, expected={:?}", err, tol ); } @@ -1477,7 +1477,7 @@ fn erode( let posj = dh[posi]; // Sediment height normal to bedrock. NOTE: Currently we can actually have - // sedment and bedrock slope at different heights, meaning there's + // sediment and bedrock slope at different heights, meaning there's // no uniform slope. There are probably more correct ways to // account for this, such as averaging, integrating, or doing things // by mass / volume instead of height, but for now we use the time-honored @@ -1772,7 +1772,7 @@ pub fn fill_sinks( // Otherwise, we know this node's original height is below the new height of all // of its neighbors. Then, we try to choose the minimum new // height among all this node's neighbors that is (plus a - // constant epislon) below this node's new height. + // constant epsilon) below this node's new height. // // (If there is no such node, then the node's new height must be (minus a // constant epsilon) lower than the new height of every diff --git a/world/src/sim/mod.rs b/world/src/sim/mod.rs index 7eff3d9d8a..04be2da10e 100644 --- a/world/src/sim/mod.rs +++ b/world/src/sim/mod.rs @@ -223,7 +223,7 @@ pub enum WorldFileError { /// least, we will try hard not to break maps between versions; if we can't /// avoid it, we can at least give a reasonable error message). /// -/// NOTE: We rely somemwhat heavily on the implementation specifics of bincode +/// NOTE: We rely somewhat heavily on the implementation specifics of bincode /// to make sure this is backwards compatible. When adding new variants here, /// Be very careful to make sure tha the old variants are preserved in the /// correct order and with the correct names and indices, and make sure to keep @@ -244,7 +244,7 @@ pub enum WorldFile { } /// Data for the most recent map type. Update this when you add a new map -/// verson. +/// version. pub type ModernMap = WorldMap_0_7_0; /// The default world map. @@ -266,7 +266,7 @@ impl WorldFileLegacy { /// should construct a call chain that ultimately ends up with a modern /// version. pub fn into_modern(self) -> Result { - // NOTE: At this point, we ssume that any remaining legacy maps were 1024 × + // NOTE: At this point, we assume that any remaining legacy maps were 1024 × // 1024. if self.alt.len() != self.basement.len() || self.alt.len() != 1024 * 1024 { return Err(WorldFileError::WorldSizeInvalid); @@ -1135,7 +1135,7 @@ impl WorldSim { basement, } = map.into_modern().unwrap(); - // Additional small-scale eroson after map load, only used during testing. + // Additional small-scale erosion after map load, only used during testing. let (alt, basement) = if n_post_load_steps == 0 { (alt, basement) } else { @@ -2065,7 +2065,7 @@ impl SimChunk { // Not clear that we want this yet, let's see. let latitude_uniform = (pos.y as f32 / f32::from(self.map_size_lg().chunks().y)).sub(0.5).mul(2.0); - // Even less granular--if this matters we can make the sign affect the quantiy slightly. + // Even less granular--if this matters we can make the sign affect the quantity slightly. let abs_lat_uniform = latitude_uniform.abs(); */ // Take the weighted average of our randomly generated base humidity, and the @@ -2228,7 +2228,7 @@ impl SimChunk { // Temperate climate with jungle humidity... // https://en.wikipedia.org/wiki/Humid_subtropical_climates are often // densely wooded and full of water. Semitropical rainforests, basically. - // For now we just treet them like other rainforests. + // For now we just treat them like other rainforests. ForestKind::Oak } else if humidity > CONFIG.forest_hum { // Moderate climate, moderate humidity. diff --git a/world/src/sim/util.rs b/world/src/sim/util.rs index 3fda529d13..26f85e7e34 100644 --- a/world/src/sim/util.rs +++ b/world/src/sim/util.rs @@ -40,7 +40,7 @@ pub fn map_edge_factor(map_size_lg: MapSizeLg, posi: usize) -> f32 { /// /// NOTE: /// -/// Per [[1]], the problem of determing the CDF of +/// Per [[1]], the problem of determining the CDF of /// the sum of uniformly distributed random variables over *different* ranges is /// considerably more complicated than it is for the same-range case. /// Fortunately, it also provides a reference to [2], which contains a complete diff --git a/world/src/sim2/mod.rs b/world/src/sim2/mod.rs index 0a5dc35012..a89d327d0c 100644 --- a/world/src/sim2/mod.rs +++ b/world/src/sim2/mod.rs @@ -100,14 +100,14 @@ pub fn tick(index: &mut Index, _world: &mut WorldSim, dt: f32) { /// simulation begins by assigning arbitrary values to each commodity and then /// incrementally updates them according to the final scarcity of the commodity /// at the end of the tick. This results in the formulation of values that are -/// roughly analgous to prices for each commodity. The workforce is then +/// roughly analogous to prices for each commodity. The workforce is then /// reassigned according to the respective commodity values. The simulation also /// includes damping terms that prevent cyclical inconsistencies in value /// rationalisation magnifying enough to crash the economy. We also ensure that /// a small number of workers are allocated to every industry (even inactive /// ones) each tick. This is not an accident: a small amount of productive /// capacity in one industry allows the economy to quickly pivot to a different -/// prodution configuration should an additional commodity that acts as +/// production configuration should an additional commodity that acts as /// production input become available. This means that the economy will /// dynamically react to environmental changes. If a product becomes available /// through a mechanism such as trade, an entire arm of the economy may