diff --git a/src/autotile.rs b/src/autotile.rs
index 14d6c24bb8d5a944d151008cd3d79f9c6bf22b9b..0ab76cc2fe0fefc95734925195eab9ddb3fd4caf 100644
--- a/src/autotile.rs
+++ b/src/autotile.rs
@@ -1,7 +1,7 @@
+use crate::output::TileOutput;
+use crate::{TileLayout, TileMatcher};
use std::fmt::{Debug, Formatter};
use std::ops::Add;
-use crate::{TileLayout, TileMatcher};
-use crate::output::TileOutput;
/// Checks tile layouts against a matcher instance, and uses the output to produce a value
#[derive(Clone, Default)]
@@ -19,9 +19,17 @@ impl Debug for AutoTileRule {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
if f.alternate() {
// Perform grid style formatting for matcher value
- write!(f, "AutoTileRule \n{:#?}output: {:?}, chance: {:.2}", self.matcher, self.output, self.chance)
+ write!(
+ f,
+ "AutoTileRule \n{:#?}output: {:?}, chance: {:.2}",
+ self.matcher, self.output, self.chance
+ )
} else {
- write!(f, "AutoTileRule {{ matcher: {:?}, output: {:?}, chance: {:.2} }}", self.matcher, self.output, self.chance)
+ write!(
+ f,
+ "AutoTileRule {{ matcher: {:?}, output: {:?}, chance: {:.2} }}",
+ self.matcher, self.output, self.chance
+ )
}
}
}
@@ -62,11 +70,7 @@ impl AutoTileRule {
/// Create a rule that will produce one of the values contained in `output_value`
/// when the target tile matches `input_value` and the selection chacne is rolled under the
/// value of `chance` (0.0 to 1.0)
- pub const fn single_any_chance(
- input_value: i32,
- output_value: Vec<i32>,
- chance: f32,
- ) -> Self {
+ pub const fn single_any_chance(input_value: i32, output_value: Vec<i32>, chance: f32) -> Self {
AutoTileRule {
matcher: TileMatcher::single_match(input_value),
output: TileOutput::any(output_value),
@@ -141,11 +145,7 @@ impl AutoTileRule {
/// Will use the provided RNG to select from a list, if the output resolves to
/// a random selection
#[cfg(feature = "impl_fastrand")]
- pub fn resolve_match_seeded(
- &self,
- input: &TileLayout,
- seeded: &fastrand::Rng,
- ) -> Option<i32> {
+ pub fn resolve_match_seeded(&self, input: &TileLayout, seeded: &fastrand::Rng) -> Option<i32> {
self.get_match_seeded(input, seeded)
.and_then(|out| out.resolve_with(seeded))
}
@@ -263,13 +263,8 @@ impl AutoRuleSet {
/// Will use the provided RNG to select from a list, if the output resolves to
/// a random selection
#[cfg(feature = "impl_fastrand")]
- pub fn resolve_match_seeded(
- &self,
- input: &TileLayout,
- seeded: &fastrand::Rng,
- ) -> Option<i32> {
+ pub fn resolve_match_seeded(&self, input: &TileLayout, seeded: &fastrand::Rng) -> Option<i32> {
self.get_match_seeded(input, seeded)
.and_then(|out| out.resolve_with(seeded))
}
}
-
diff --git a/src/layout.rs b/src/layout.rs
index 78badce40ef00e9ecd3046ba6eafe426d8f37a02..48d0c2b31ab5295636d5239ea9102a3155c3c0ff 100644
--- a/src/layout.rs
+++ b/src/layout.rs
@@ -1,5 +1,5 @@
-use std::fmt::{Debug, Formatter};
use crate::utils::IntoTile;
+use std::fmt::{Debug, Formatter};
/// The size of the grid that can be matched; equal to the length of one side of the square grid
const RULE_MAGNITUDE: usize = 7;
@@ -37,41 +37,38 @@ impl Debug for TileStatus {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Self::Ignore => write!(f, "Any Or No Tile"),
- Self::Nothing => write!(f, "No Tile"),
- Self::Anything => write!(f, "Any Tile"),
- Self::Is(value) => write!(f, "Must Match [{}]", value),
- Self::IsNot(value) => write!(f, "Must Not Match [{}]", value),
+ Self::Nothing => write!(f, "No Tile"),
+ Self::Anything => write!(f, "Any Tile"),
+ Self::Is(value) => write!(f, "Must Match [{}]", value),
+ Self::IsNot(value) => write!(f, "Must Not Match [{}]", value),
}
}
}
impl PartialEq<Option<i32>> for TileStatus {
fn eq(&self, other: &Option<i32>) -> bool {
- let matched = match self {
+ match self {
Self::Ignore => true,
Self::Nothing => other.is_none(),
Self::Anything => other.is_some(),
Self::Is(value) => &Some(*value) == other,
Self::IsNot(value) => &Some(*value) != other,
- };
-
- matched
+ }
}
}
impl TileStatus {
- #[deprecated(since = "0.2.0", note = "Use `TileStatus::into` directly instead")]
+ #[deprecated(since = "0.2.0", note = "Use `TileStatus::into` directly instead")]
pub fn to_ldtk_value(self) -> i64 {
- self.into_tile() as i64
+ self.into_tile() as i64
}
- #[deprecated(since = "0.2.0", note = "Use `TileStatus::from` directly instead")]
+ #[deprecated(since = "0.2.0", note = "Use `TileStatus::from` directly instead")]
pub fn from_ldtk_value(value: i64) -> Self {
- Self::from(value)
+ Self::from(value)
}
}
-
/// Holds a grid of raw input data, as a more ideal format for interop and storage
#[repr(transparent)]
pub struct TileLayout(pub [Option<i32>; TILE_GRID_SIZE]);
@@ -95,19 +92,17 @@ impl TileLayout {
}
/// Filter the layout data so that it only contains the tiles surrounding the target tile. This
- /// means that the array index of every entry before the center point will match the original data
- /// array, but ever entry after the center point will have its index shifted down by 1
- ///
- /// The main utility of this is to perform set operations on every tile _other_ than the target tile.
+ /// means that the array index of every entry before the center point will match the original data
+ /// array, but ever entry after the center point will have its index shifted down by 1
+ ///
+ /// The main utility of this is to perform set operations on every tile _other_ than the target tile.
///
/// ## Examples
///
/// ```
/// # use micro_autotile::TileLayout;
/// let layout = TileLayout::single(123);
- /// let has_any_surrounding_tiles = layout.surrounding()
- /// .iter()
- /// .any(|tile| tile.is_some());
+ /// let has_any_surrounding_tiles = layout.surrounding().iter().any(|tile| tile.is_some());
///
/// assert_eq!(has_any_surrounding_tiles, false);
/// ```
@@ -124,12 +119,8 @@ impl Debug for TileLayout {
let lines = as_lines(&self.0);
let mut max_width = 1;
- for line in lines.iter() {
- for value in line.iter() {
- if let Some(value) = value {
- max_width = max_width.max(value.to_string().len());
- }
- }
+ for value in lines.iter().copied().flatten().flatten() {
+ max_width = max_width.max(value.to_string().len());
}
for line in lines {
@@ -139,22 +130,31 @@ impl Debug for TileLayout {
} else {
write!(f, "{:^max_width$} ", "#")?;
}
- }
- write!(f, "\n")?;
+ }
+ writeln!(f)?;
}
- write!(f, "\n")
+ writeln!(f)
} else {
writeln!(f, "{:?}", self.0)
}
}
}
-impl <T> TryFrom<&[T]> for TileLayout where T: IntoTile + Copy + Default {
+impl<T> TryFrom<&[T]> for TileLayout
+where
+ T: IntoTile + Copy + Default,
+{
type Error = NotSquareError;
fn try_from(value: &[T]) -> Result<Self, Self::Error> {
if is_square(value.len()) {
let formatted = transpose(value);
- Ok(Self(formatted.map(|t| if t.into_tile() == 0 { None } else { Some(t.into_tile()) })))
+ Ok(Self(formatted.map(|t| {
+ if t.into_tile() == 0 {
+ None
+ } else {
+ Some(t.into_tile())
+ }
+ })))
} else {
Err(NotSquareError)
}
@@ -174,9 +174,9 @@ impl Debug for TileMatcher {
for value in line {
write!(f, "{:?} ", value)?;
}
- write!(f, "\n")?;
+ writeln!(f)?;
}
- writeln!(f, "\n")
+ writeln!(f)
} else {
write!(f, "TileMatcher({:?})", self.0)
}
@@ -185,8 +185,8 @@ impl Debug for TileMatcher {
impl Default for TileMatcher {
fn default() -> Self {
- TileMatcher([TileStatus::default(); TILE_GRID_SIZE])
- }
+ TileMatcher([TileStatus::default(); TILE_GRID_SIZE])
+ }
}
impl TileMatcher {
@@ -196,7 +196,6 @@ impl TileMatcher {
TileMatcher(rules)
}
-
/// Create a 1x1 matcher, with any rule for the target tile
pub const fn single_match(value: i32) -> Self {
Self::single(TileStatus::Is(value))
@@ -217,7 +216,10 @@ impl TileMatcher {
}
}
-impl <T> TryFrom<&[T]> for TileMatcher where T: IntoTile + Copy + Default {
+impl<T> TryFrom<&[T]> for TileMatcher
+where
+ T: IntoTile + Copy + Default,
+{
type Error = NotSquareError;
fn try_from(value: &[T]) -> Result<Self, Self::Error> {
if is_square(value.len()) {
@@ -232,10 +234,10 @@ impl TryFrom<&[TileStatus]> for TileMatcher {
type Error = NotSquareError;
fn try_from(value: &[TileStatus]) -> Result<Self, Self::Error> {
if is_square(value.len()) {
- Ok(Self(transpose(value)))
- } else {
- Err(NotSquareError)
- }
+ Ok(Self(transpose(value)))
+ } else {
+ Err(NotSquareError)
+ }
}
}
@@ -287,8 +289,10 @@ impl TryFrom<&[TileStatus]> for TileMatcher {
/// 1 1 1 1 1 1 1
/// 1 1 1 1 1 1 1
/// ```
-///
-fn transpose<Value>(input: &[Value]) -> [Value; TILE_GRID_SIZE] where Value: Default + Copy {
+fn transpose<Value>(input: &[Value]) -> [Value; TILE_GRID_SIZE]
+where
+ Value: Default + Copy,
+{
if input.len() == TILE_GRID_SIZE {
match input.try_into() {
Ok(output) => return output,
@@ -301,7 +305,7 @@ fn transpose<Value>(input: &[Value]) -> [Value; TILE_GRID_SIZE] where Value: Def
if !is_square(input.len()) {
// Length isn't square == it does not represent a square grid
- panic!("Input must be a square grid");
+ panic!("Input must be a square grid");
}
let input_size = (input.len() as f64).sqrt() as usize;
@@ -333,7 +337,7 @@ fn transpose<Value>(input: &[Value]) -> [Value; TILE_GRID_SIZE] where Value: Def
let output_idx = adjusted_output_y * RULE_MAGNITUDE + adjusted_output_x;
output[output_idx] = input[input_idx];
- }
+ }
}
output
@@ -356,15 +360,10 @@ mod tests {
fn it_transposes_odd_grids() {
let input = [2, 2, 2, 2, 2, 2, 2, 2, 2];
let expected = [
- 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 2, 2, 2, 0, 0,
- 0, 0, 2, 2, 2, 0, 0,
- 0, 0, 2, 2, 2, 0, 0,
- 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0,
+ 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
];
assert_eq!(expected, transpose(&input));
}
-}
\ No newline at end of file
+}
diff --git a/src/lib.rs b/src/lib.rs
index 88c7a72a8d83140332e09ccdb82aa54188378dcd..f705f75b833ace158888fd00dd75d5989842c85d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -98,33 +98,33 @@
//! const OTHER_TILE: i32 = 342;
//!
//! let wall_rules = AutoRuleSet(vec![
-//! AutoTileRule::single_when(TileMatcher::try_from([ // Top Left Corner
-//! TileStatus::IsNot(WALL_TILE), TileStatus::IsNot(WALL_TILE), TileStatus::IsNot(WALL_TILE),
-//! TileStatus::IsNot(WALL_TILE), TileStatus::Is(WALL_TILE), TileStatus::Is(WALL_TILE),
-//! TileStatus::IsNot(WALL_TILE), TileStatus::Is(WALL_TILE), TileStatus::Is(WALL_TILE),
-//! ].as_slice()).unwrap(), 54),
-//! AutoTileRule::single_when(TileMatcher::try_from([ // Top Right Corner
-//! TileStatus::IsNot(WALL_TILE), TileStatus::IsNot(WALL_TILE), TileStatus::IsNot(WALL_TILE),
-//! TileStatus::Is(WALL_TILE), TileStatus::Is(WALL_TILE), TileStatus::IsNot(WALL_TILE),
-//! TileStatus::Is(WALL_TILE), TileStatus::Is(WALL_TILE), TileStatus::IsNot(WALL_TILE),
-//! ].as_slice()).unwrap(), 55),
-//! // ... Etc
+//! AutoTileRule::single_when(TileMatcher::try_from([ // Top Left Corner
+//! TileStatus::IsNot(WALL_TILE), TileStatus::IsNot(WALL_TILE), TileStatus::IsNot(WALL_TILE),
+//! TileStatus::IsNot(WALL_TILE), TileStatus::Is(WALL_TILE), TileStatus::Is(WALL_TILE),
+//! TileStatus::IsNot(WALL_TILE), TileStatus::Is(WALL_TILE), TileStatus::Is(WALL_TILE),
+//! ].as_slice()).unwrap(), 54),
+//! AutoTileRule::single_when(TileMatcher::try_from([ // Top Right Corner
+//! TileStatus::IsNot(WALL_TILE), TileStatus::IsNot(WALL_TILE), TileStatus::IsNot(WALL_TILE),
+//! TileStatus::Is(WALL_TILE), TileStatus::Is(WALL_TILE), TileStatus::IsNot(WALL_TILE),
+//! TileStatus::Is(WALL_TILE), TileStatus::Is(WALL_TILE), TileStatus::IsNot(WALL_TILE),
+//! ].as_slice()).unwrap(), 55),
+//! // ... Etc
//! ]);
//!
//! let ground_rules = AutoRuleSet(vec![
-//! // Use decorated tiles in 10% of cases
-//! AutoTileRule::single_any_chance(GROUND_TILE, vec![45, 46, 47], 0.1),
-//! // Fall back to the basic tile if we don't match previously
-//! AutoTileRule::exact(GROUND_TILE, 44),
+//! // Use decorated tiles in 10% of cases
+//! AutoTileRule::single_any_chance(GROUND_TILE, vec![45, 46, 47], 0.1),
+//! // Fall back to the basic tile if we don't match previously
+//! AutoTileRule::exact(GROUND_TILE, 44),
//! ]);
//!
//! // Easily merge rule sets in an ordered way
//! let combined_rules = wall_rules + ground_rules;
//!
//! let sublayout = TileLayout::try_from([
-//! Some(OTHER_TILE), Some(GROUND_TILE), Some(GROUND_TILE),
-//! Some(WALL_TILE), Some(WALL_TILE), Some(OTHER_TILE),
-//! Some(WALL_TILE), Some(WALL_TILE), Some(GROUND_TILE),
+//! Some(OTHER_TILE), Some(GROUND_TILE), Some(GROUND_TILE),
+//! Some(WALL_TILE), Some(WALL_TILE), Some(OTHER_TILE),
+//! Some(WALL_TILE), Some(WALL_TILE), Some(GROUND_TILE),
//! ].as_slice()).unwrap();
//!
//! // We've got a layout that represents the top right corner of a wall, the second rule in our
@@ -136,12 +136,11 @@
//! # }
//! ```
-mod layout;
mod autotile;
+mod layout;
mod output;
mod utils;
-pub use layout::*;
pub use autotile::*;
+pub use layout::*;
pub use output::*;
-
diff --git a/src/output.rs b/src/output.rs
index b5704d1bd65dcd589fc12595869ec82392dbc37b..ed16ddd48de60e08a772f6cca126b346b53a7ddc 100644
--- a/src/output.rs
+++ b/src/output.rs
@@ -41,4 +41,4 @@ impl TileOutput {
Self::Random(vals) => vals.get(rng.usize(0..vals.len())).copied(),
}
}
-}
\ No newline at end of file
+}
diff --git a/src/utils.rs b/src/utils.rs
index 1c04ee7ae06c3f81ec903a8185068668773a247e..7417ed390c557cb82c1a100af2fd31e40711fb05 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,140 +1,140 @@
use crate::TileStatus;
pub trait IntoTile {
- fn into_tile(self) -> i32;
+ fn into_tile(self) -> i32;
}
// Implementations for unsigned integer types
impl IntoTile for u8 {
- fn into_tile(self) -> i32 {
- self as i32
- }
+ fn into_tile(self) -> i32 {
+ self as i32
+ }
}
impl IntoTile for u16 {
- fn into_tile(self) -> i32 {
- self as i32
- }
+ fn into_tile(self) -> i32 {
+ self as i32
+ }
}
impl IntoTile for u32 {
- fn into_tile(self) -> i32 {
- self as i32
- }
+ fn into_tile(self) -> i32 {
+ self as i32
+ }
}
impl IntoTile for u64 {
- fn into_tile(self) -> i32 {
- self as i32
- }
+ fn into_tile(self) -> i32 {
+ self as i32
+ }
}
impl IntoTile for u128 {
- fn into_tile(self) -> i32 {
- self as i32
- }
+ fn into_tile(self) -> i32 {
+ self as i32
+ }
}
impl IntoTile for usize {
- fn into_tile(self) -> i32 {
- self as i32
- }
+ fn into_tile(self) -> i32 {
+ self as i32
+ }
}
// Implementations for signed integer types
impl IntoTile for i8 {
- fn into_tile(self) -> i32 {
- self as i32
- }
+ fn into_tile(self) -> i32 {
+ self as i32
+ }
}
impl IntoTile for i16 {
- fn into_tile(self) -> i32 {
- self as i32
- }
+ fn into_tile(self) -> i32 {
+ self as i32
+ }
}
impl IntoTile for i32 {
- fn into_tile(self) -> i32 {
- self
- }
+ fn into_tile(self) -> i32 {
+ self
+ }
}
impl IntoTile for i64 {
- fn into_tile(self) -> i32 {
- self as i32
- }
+ fn into_tile(self) -> i32 {
+ self as i32
+ }
}
impl IntoTile for i128 {
- fn into_tile(self) -> i32 {
- self as i32
- }
+ fn into_tile(self) -> i32 {
+ self as i32
+ }
}
impl IntoTile for isize {
- fn into_tile(self) -> i32 {
- self as i32
- }
+ fn into_tile(self) -> i32 {
+ self as i32
+ }
}
// We don't actually implement IntoTile for TileStatus, as this would conflict with a later From impl
impl TileStatus {
- pub fn into_tile(self) -> i32 {
- match self {
- Self::Ignore => 0,
- Self::Nothing => -1000001,
- Self::Anything => 1000001,
- Self::Is(value) => value,
- Self::IsNot(value) => -(value),
- }
- }
+ pub fn into_tile(self) -> i32 {
+ match self {
+ Self::Ignore => 0,
+ Self::Nothing => -1000001,
+ Self::Anything => 1000001,
+ Self::Is(value) => value,
+ Self::IsNot(value) => -(value),
+ }
+ }
}
impl From<TileStatus> for i32 {
- fn from(value: TileStatus) -> Self {
- value.into_tile()
- }
+ fn from(value: TileStatus) -> Self {
+ value.into_tile()
+ }
}
impl From<TileStatus> for i64 {
- fn from(value: TileStatus) -> Self {
- value.into_tile() as i64
- }
-}
-
-impl <T: IntoTile> IntoTile for Option<T> {
- fn into_tile(self) -> i32 {
- match self {
- Some(value) => value.into_tile(),
- None => 0,
- }
- }
-}
-
-impl <T: IntoTile, E> IntoTile for Result<T, E> {
- fn into_tile(self) -> i32 {
- match self {
- Ok(value) => value.into_tile(),
- Err(_) => 0,
- }
- }
-}
-
-impl <I: IntoTile> From<I> for TileStatus {
- fn from(value: I) -> Self {
- let value = value.into_tile();
- match value {
- 0 => Self::Ignore,
- 1000001 => Self::Anything,
- -1000001 => Self::Nothing,
- other => {
- if other > 0 {
- Self::Is(other.into_tile())
- } else {
- Self::IsNot(other.abs().into_tile())
- }
- }
- }
- }
-}
\ No newline at end of file
+ fn from(value: TileStatus) -> Self {
+ value.into_tile() as i64
+ }
+}
+
+impl<T: IntoTile> IntoTile for Option<T> {
+ fn into_tile(self) -> i32 {
+ match self {
+ Some(value) => value.into_tile(),
+ None => 0,
+ }
+ }
+}
+
+impl<T: IntoTile, E> IntoTile for Result<T, E> {
+ fn into_tile(self) -> i32 {
+ match self {
+ Ok(value) => value.into_tile(),
+ Err(_) => 0,
+ }
+ }
+}
+
+impl<I: IntoTile> From<I> for TileStatus {
+ fn from(value: I) -> Self {
+ let value = value.into_tile();
+ match value {
+ 0 => Self::Ignore,
+ 1000001 => Self::Anything,
+ -1000001 => Self::Nothing,
+ other => {
+ if other > 0 {
+ Self::Is(other.into_tile())
+ } else {
+ Self::IsNot(other.abs().into_tile())
+ }
+ }
+ }
+ }
+}