module BishBosh.Cartesian.Ordinate(
yOrigin,
yLength,
yMin,
yMax,
yRange,
centre,
firstRank,
lastRank,
pawnsFirstRank,
enPassantRank,
reflect,
translate,
maybeTranslate,
inBounds
) where
import qualified BishBosh.Attribute.LogicalColour as Attribute.LogicalColour
import qualified BishBosh.Cartesian.Abscissa as Cartesian.Abscissa
import qualified BishBosh.Property.Opposable as Property.Opposable
import qualified BishBosh.Types as T
import qualified Control.Exception
yOrigin :: Int
yOrigin :: Int
yOrigin = Int
Cartesian.Abscissa.xOrigin
yLength :: T.Distance
yLength :: Int
yLength = Int
Cartesian.Abscissa.xLength
yMin :: Enum y => y
yMin :: y
yMin = Int -> y
forall a. Enum a => Int -> a
toEnum Int
yOrigin
yMax :: Enum y => y
yMax :: y
yMax = Int -> y
forall a. Enum a => Int -> a
toEnum (Int -> y) -> Int -> y
forall a b. (a -> b) -> a -> b
$ Int
yOrigin Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int
forall a. Enum a => a -> a
pred Int
yLength)
yBounds :: Enum y => (y, y)
yBounds :: (y, y)
yBounds = (y
forall y. Enum y => y
yMin, y
forall y. Enum y => y
yMax)
yRange :: Enum y => [y]
yRange :: [y]
yRange = (y -> y -> [y]) -> (y, y) -> [y]
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry y -> y -> [y]
forall a. Enum a => a -> a -> [a]
enumFromTo (y, y)
forall y. Enum y => (y, y)
yBounds
centre :: Fractional centre => centre
centre :: centre
centre = Int -> centre
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Int -> Int -> Int) -> (Int, Int) -> Int
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Int -> Int -> Int
forall a. Num a => a -> a -> a
(+) (Int, Int)
forall y. Enum y => (y, y)
yBounds :: T.Y) centre -> centre -> centre
forall a. Fractional a => a -> a -> a
/ centre
2
firstRank :: Enum y => Attribute.LogicalColour.LogicalColour -> y
firstRank :: LogicalColour -> y
firstRank LogicalColour
Attribute.LogicalColour.Black = y
forall y. Enum y => y
yMax
firstRank LogicalColour
_ = y
forall y. Enum y => y
yMin
lastRank :: Enum y => Attribute.LogicalColour.LogicalColour -> y
lastRank :: LogicalColour -> y
lastRank = LogicalColour -> y
forall y. Enum y => LogicalColour -> y
firstRank (LogicalColour -> y)
-> (LogicalColour -> LogicalColour) -> LogicalColour -> y
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LogicalColour -> LogicalColour
forall a. Opposable a => a -> a
Property.Opposable.getOpposite
pawnsFirstRank :: Enum y => Attribute.LogicalColour.LogicalColour -> y
{-# INLINE pawnsFirstRank #-}
pawnsFirstRank :: LogicalColour -> y
pawnsFirstRank LogicalColour
Attribute.LogicalColour.Black = y -> y
forall a. Enum a => a -> a
pred y
forall y. Enum y => y
yMax
pawnsFirstRank LogicalColour
_ = y -> y
forall a. Enum a => a -> a
succ y
forall y. Enum y => y
yMin
enPassantRank :: Enum y => Attribute.LogicalColour.LogicalColour -> y
{-# INLINE enPassantRank #-}
enPassantRank :: LogicalColour -> y
enPassantRank LogicalColour
Attribute.LogicalColour.Black = Int -> y
forall a. Enum a => Int -> a
toEnum (Int -> y) -> Int -> y
forall a b. (a -> b) -> a -> b
$ Int
yOrigin Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3
enPassantRank LogicalColour
_ = Int -> y
forall a. Enum a => Int -> a
toEnum (Int -> y) -> Int -> y
forall a b. (a -> b) -> a -> b
$ Int
yOrigin Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4
reflect :: Enum y => y -> y
reflect :: y -> y
reflect = Int -> y
forall a. Enum a => Int -> a
toEnum (Int -> y) -> (y -> Int) -> y -> y
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (
Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (Int
2 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
yOrigin Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int
forall a. Enum a => a -> a
pred Int
yLength))
) (Int -> Int) -> (y -> Int) -> y -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int
forall a. Num a => a -> a
negate (Int -> Int) -> (y -> Int) -> y -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. y -> Int
forall a. Enum a => a -> Int
fromEnum
inBounds :: (Enum y, Ord y) => y -> Bool
{-# INLINE inBounds #-}
inBounds :: y -> Bool
inBounds y
y = y
y y -> y -> Bool
forall a. Ord a => a -> a -> Bool
>= y
forall y. Enum y => y
yMin Bool -> Bool -> Bool
&& y
y y -> y -> Bool
forall a. Ord a => a -> a -> Bool
<= y
forall y. Enum y => y
yMax
translate :: (Enum y, Ord y) => (y -> y) -> y -> y
translate :: (y -> y) -> y -> y
translate y -> y
transformation = (\y
y -> Bool -> y -> y
forall a. (?callStack::CallStack) => Bool -> a -> a
Control.Exception.assert (y -> Bool
forall y. (Enum y, Ord y) => y -> Bool
inBounds y
y) y
y) (y -> y) -> (y -> y) -> y -> y
forall b c a. (b -> c) -> (a -> b) -> a -> c
. y -> y
transformation
maybeTranslate :: (Enum y, Ord y) => (y -> y) -> y -> Maybe y
maybeTranslate :: (y -> y) -> y -> Maybe y
maybeTranslate y -> y
transformation = (
\y
y -> if y -> Bool
forall y. (Enum y, Ord y) => y -> Bool
inBounds y
y
then y -> Maybe y
forall a. a -> Maybe a
Just y
y
else Maybe y
forall a. Maybe a
Nothing
) (y -> Maybe y) -> (y -> y) -> y -> Maybe y
forall b c a. (b -> c) -> (a -> b) -> a -> c
. y -> y
transformation