#![warn(clippy::pedantic, clippy::nursery, missing_docs)]
#![allow(
clippy::non_ascii_literal,
clippy::use_self,
clippy::upper_case_acronyms
)]
use cetkaik_fundamental::{AbsoluteSide, Profession};
use cetkaik_traits::CetkaikRepresentation;
pub mod relative;
pub mod absolute;
pub mod perspective;
#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
pub struct CetkaikNaive;
impl CetkaikRepresentation for CetkaikNaive {
type Perspective = crate::perspective::Perspective;
type AbsoluteCoord = crate::absolute::Coord;
type RelativeCoord = crate::relative::Coord;
type AbsoluteBoard = crate::absolute::Board;
type RelativeBoard = crate::relative::Board;
type AbsolutePiece = crate::absolute::Piece;
type RelativePiece = crate::relative::Piece;
type RelativeSide = crate::relative::Side;
type AbsoluteField = crate::absolute::Field;
type RelativeField = crate::relative::Field;
fn to_absolute_coord(coord: Self::RelativeCoord, p: Self::Perspective) -> Self::AbsoluteCoord {
crate::perspective::to_absolute_coord(coord, p)
}
fn to_relative_coord(coord: Self::AbsoluteCoord, p: Self::Perspective) -> Self::RelativeCoord {
crate::perspective::to_relative_coord(coord, p)
}
fn add_delta(
coord: Self::RelativeCoord,
row_delta: isize,
col_delta: isize,
) -> Option<Self::RelativeCoord> {
let [i, j] = coord;
match (
i.checked_add_signed(row_delta),
j.checked_add_signed(col_delta),
) {
(Some(l @ 0..=8), Some(m @ 0..=8)) => Some([l, m]),
_ => None,
}
}
fn relative_get(
board: Self::RelativeBoard,
coord: Self::RelativeCoord,
) -> Option<Self::RelativePiece> {
let [i, j] = coord;
board.0[i][j]
}
fn relative_clone_and_set(
board: &Self::RelativeBoard,
coord: Self::RelativeCoord,
p: Option<Self::RelativePiece>,
) -> Self::RelativeBoard {
let [i, j] = coord;
let mut new_board = *board;
new_board.0[i][j] = p;
new_board
}
fn absolute_get(
board: &Self::AbsoluteBoard,
coord: Self::AbsoluteCoord,
) -> Option<Self::AbsolutePiece> {
board.0.get(&coord).copied()
}
fn is_tam_hue_by_default(coord: Self::RelativeCoord) -> bool {
coord == [2, 2]
|| coord == [2, 6]
|| coord == [3, 3]
|| coord == [3, 5]
|| coord == [4, 4]
|| coord == [5, 3]
|| coord == [5, 5]
|| coord == [6, 2]
|| coord == [6, 6]
}
fn relative_tam2() -> Self::RelativePiece {
crate::relative::Piece::Tam2
}
fn absolute_tam2() -> Self::AbsolutePiece {
crate::absolute::Piece::Tam2
}
fn is_upward(s: Self::RelativeSide) -> bool {
s == crate::relative::Side::Upward
}
fn as_board_absolute(field: &Self::AbsoluteField) -> &Self::AbsoluteBoard {
&field.board
}
fn as_board_mut_absolute(field: &mut Self::AbsoluteField) -> &mut Self::AbsoluteBoard {
&mut field.board
}
fn as_board_relative(field: &Self::RelativeField) -> &Self::RelativeBoard {
&field.current_board
}
fn is_water_relative(c: Self::RelativeCoord) -> bool {
crate::relative::is_water(c)
}
fn is_water_absolute(c: Self::AbsoluteCoord) -> bool {
crate::absolute::is_water(c)
}
fn loop_over_one_side_and_tam(
board: &Self::RelativeBoard,
side: Self::RelativeSide,
f_tam_or_piece: &mut dyn FnMut(Self::RelativeCoord, Option<Profession>),
) {
for (rand_i, row) in board.0.iter().enumerate() {
for (rand_j, &piece) in row.iter().enumerate() {
let src = [rand_i, rand_j];
if let Some(p) = piece {
match p {
Self::RelativePiece::Tam2 => f_tam_or_piece(src, None),
Self::RelativePiece::NonTam2Piece {
side: side_,
prof,
color: _,
} if side_ == side => f_tam_or_piece(src, Some(prof)),
Self::RelativePiece::NonTam2Piece { .. } => {}
}
}
}
}
}
fn to_relative_field(field: Self::AbsoluteField, p: Self::Perspective) -> Self::RelativeField {
crate::perspective::to_relative_field(field, p)
}
fn to_relative_side(side: AbsoluteSide, p: Self::Perspective) -> Self::RelativeSide {
crate::perspective::to_relative_side(side, p)
}
fn get_one_perspective() -> Self::Perspective {
crate::perspective::Perspective::IaIsDownAndPointsUpward
}
fn absolute_distance(a: Self::AbsoluteCoord, b: Self::AbsoluteCoord) -> i32 {
crate::absolute::distance(a, b)
}
fn absolute_same_direction(
origin: Self::AbsoluteCoord,
a: Self::AbsoluteCoord,
b: Self::AbsoluteCoord,
) -> bool {
crate::absolute::same_direction(origin, a, b)
}
fn has_prof_absolute(piece: Self::AbsolutePiece, prof: Profession) -> bool {
piece.has_prof(prof)
}
fn match_on_relative_piece_and_apply<U>(
piece: Self::RelativePiece,
f_tam: &dyn Fn() -> U,
f_piece: &dyn Fn(cetkaik_fundamental::Color, Profession, Self::RelativeSide) -> U,
) -> U {
match piece {
Self::RelativePiece::Tam2 => f_tam(),
Self::RelativePiece::NonTam2Piece { color, prof, side } => f_piece(color, prof, side),
}
}
fn match_on_absolute_piece_and_apply<U>(
piece: Self::AbsolutePiece,
f_tam: &dyn Fn() -> U,
f_piece: &dyn Fn(
cetkaik_fundamental::Color,
Profession,
cetkaik_fundamental::AbsoluteSide,
) -> U,
) -> U {
match piece {
absolute::Piece::Tam2 => f_tam(),
absolute::Piece::NonTam2Piece { color, prof, side } => f_piece(color, prof, side),
}
}
}