desck 0.4.2

package/src/DeckView.elm

@@ -0,0 +1,415 @@
+module DeckView exposing (backface, cardSize, cornerRadius, frontface, includes)
+
+import Deck exposing (..)
+import Svg exposing (Svg)
+import Svg.Attributes as A
+import Util exposing (num, rotate, scale, scaleXY, translate, url)
+import Vec exposing (Vec2)
+
+
+cardSize : Vec2
+cardSize =
+    Vec2 250 350
+
+
+var : String -> String
+var name =
+    "var(--" ++ name ++ ")"
+
+
+black : String
+black =
+    var "black"
+
+
+white : String
+white =
+    var "white"
+
+
+stripes : Float -> String -> String -> Float -> Svg msg
+stripes width a b deg =
+    Svg.pattern
+        [ A.id "stripes"
+        , A.patternUnits "userSpaceOnUse"
+        , num A.width 10
+        , num A.height (width * 2)
+        , A.patternTransform <| rotate deg
+        ]
+        [ Svg.rect
+            [ num A.width 10
+            , num A.height width
+            , A.fill a
+            ]
+            []
+        , Svg.rect
+            [ num A.width 10
+            , num A.height width
+            , num A.y width
+            , A.fill b
+            ]
+            []
+        ]
+
+
+includes : List (Svg msg)
+includes =
+    [ Svg.defs [ A.id "defs" ]
+        [ stripes 15 "#444" "#666" 45.0
+        , Svg.symbol [ A.id "backface" ]
+            [ Svg.rect
+                [ num A.x 0
+                , num A.y 0
+                , num A.width <| 250
+                , num A.height <| 350
+                , A.class "card-back-pattern"
+                , A.rx cornerRadius
+                , A.fill (url "stripes")
+                , A.strokeWidth borderWidth
+                ]
+                []
+            ]
+        ]
+    ]
+
+
+cornerRadius : String
+cornerRadius =
+    "8"
+
+
+borderWidth : String
+borderWidth =
+    "2"
+
+
+backface : Float -> Float -> CardModel -> List (Svg msg)
+backface w h _ =
+    let
+        p =
+            8
+    in
+    [ Svg.rect
+        [ num A.width <| w
+        , num A.height <| h
+        , A.rx cornerRadius
+        , A.class "card-back-rect"
+        , A.fill white
+        , A.stroke black
+        , A.strokeWidth borderWidth
+        ]
+        []
+
+    -- , Svg.rect
+    --     [ num A.width <| w
+    --     , num A.height <| h
+    --     , A.transform <| translate p p ++ scaleXY (1.0 - (2 * p / 250)) (1.0 - (2 * p / 350))
+    --     , A.rx cornerRadius
+    --     , A.class "card-back-rect"
+    --     , A.fill "var(--red)"
+    --     , A.stroke black
+    --     , A.strokeWidth borderWidth
+    --     ]
+    --     []
+    , Svg.use
+        [ A.xlinkHref "#backface"
+        , A.transform <| translate p p ++ scaleXY (1.0 - (2 * p / 250)) (1.0 - (2 * p / 350))
+        ]
+        []
+    ]
+
+
+type alias Pip =
+    ( Float, Float )
+
+
+pips : Rank -> List Pip
+pips r =
+    let
+        top =
+            0.32
+
+        htop =
+            top / 2.0
+
+        stop =
+            top / 3.0
+
+        mtop =
+            ((top - stop) / 2.0) + stop
+
+        side =
+            0.2
+
+        center4 =
+            [ ( -side, stop ), ( side, stop ), ( -side, -stop ), ( side, -stop ) ]
+
+        courtSide =
+            side * 1.2
+
+        courtTop =
+            top * 0.95
+
+        court =
+            [ ( courtSide, courtTop ), ( -courtSide, -courtTop ) ]
+
+        shiftx : Float -> List Pip -> List Pip
+        shiftx v ls =
+            List.map (\p -> ( v + Tuple.first p, Tuple.second p )) ls
+    in
+    case r of
+        Ace ->
+            [ ( 0.0, 0.0 ) ]
+
+        Two ->
+            [ ( 0.0, top ), ( 0.0, -top ) ]
+
+        Three ->
+            pips Ace ++ pips Two
+
+        Four ->
+            (pips Two |> shiftx -side) ++ (pips Two |> shiftx side)
+
+        Five ->
+            pips Ace ++ pips Four
+
+        Six ->
+            (pips Three |> shiftx -side) ++ (pips Three |> shiftx side)
+
+        Seven ->
+            ( 0.0, -htop ) :: pips Six
+
+        Eight ->
+            ( 0.0, htop ) :: pips Seven
+
+        Nine ->
+            center4 ++ pips Five
+
+        Ten ->
+            center4 ++ [ ( 0.0, mtop ), ( 0.0, -mtop ) ] ++ pips Four
+
+        Jack ->
+            court
+
+        Queen ->
+            court
+
+        King ->
+            court
+
+
+suitIcon : CardModel -> Svg msg
+suitIcon model =
+    case maybeSuit model of
+        Just suit ->
+            let
+                href =
+                    "#"
+                        ++ suitAsString suit
+            in
+            Svg.use
+                [ A.xlinkHref href
+                , transform
+                    [ translate -50.0 -50.0
+                    ]
+                , A.class "card-suit-icon"
+                , A.class <| suitAsString suit
+                , A.fill <| var <| suitAsColor suit
+                ]
+                []
+
+        Nothing ->
+            Svg.text ""
+
+
+
+-- Svg.image
+--     [ imageUrl <| suitString suit
+--     , A.transform <| translate (-size / 2.0) (-size / 2.0)
+--     , A.filter <| url <| suitAsColor suit
+--     ]
+--     []
+
+
+cornerPip : CardModel -> Svg msg
+cornerPip model =
+    let
+        textScale =
+            scale 3.7
+
+        textPos =
+            translate 0 7
+
+        rankChar =
+            case model of
+                Ranked rank _ ->
+                    rankAsChar rank
+
+                Joker _ ->
+                    "x"
+    in
+    Svg.g
+        []
+        [ Svg.g
+            [ transform [ textPos, textScale ] ]
+            [ Svg.use
+                [ A.xlinkHref <| "#" ++ rankChar
+                , A.fill <| var <| modelAsColor model
+                ]
+                []
+            ]
+        , Svg.g
+            [ transform
+                [ translate 12.0 60.0
+                , scale 0.26
+                ]
+            ]
+            [ suitIcon model ]
+        ]
+
+
+transform : List String -> Svg.Attribute msg
+transform ls =
+    A.transform <| String.join " " ls
+
+
+frontface : Float -> Float -> CardModel -> List (Svg msg)
+frontface w h model =
+    let
+        p =
+            5
+
+        -- TODO Cards - Jumbo index setting
+        cp =
+            34.0
+
+        pipx pos =
+            (w / 2.0) + w * Tuple.first pos
+
+        pipy pos =
+            (h / 2.0) + h * Tuple.second pos
+
+        size =
+            0.65
+
+        courtSymbol m =
+            "#"
+                ++ modelAsShort m
+
+        isPicture m =
+            case m of
+                Ranked rank _ ->
+                    List.member rank [ Jack, Queen, King ]
+
+                Joker _ ->
+                    True
+
+        courtCard =
+            if isPicture model then
+                Svg.g
+                    []
+                    [ Svg.use
+                        [ A.xlinkHref <| courtSymbol model
+                        , A.transform <| translate cp cp ++ scaleXY (1.0 - (cp / 250.0) * 2.0) (1.0 - (cp / 350.0) * 2.0)
+                        ]
+                        []
+
+                    -- , Svg.rect
+                    --     [ case model of
+                    --         Ranked _ _ ->
+                    --             A.stroke "#ffffff"
+                    --         Joker _ ->
+                    --             A.stroke "transparent"
+                    --     , A.fill "transparent"
+                    --     , A.strokeWidth "5px"
+                    --     , A.class "card-court-border"
+                    --     , A.rx cornerRadius
+                    --     -- , A.filter <| url "blue"
+                    --     , A.transform <| translate cp cp ++ scaleXY (1.0 - (cp / 250.0) * 2.0) (1.0 - (cp / 350.0) * 2.0)
+                    --     , num A.width 250
+                    --     , num A.height 350
+                    --     ]
+                    --     []
+                    ]
+
+            else
+                Svg.text ""
+
+        courtPipSize =
+            size * 0.8
+
+        suitIconFromPos pos =
+            Svg.g
+                [ transform
+                    [ translate (pipx pos) (pipy pos)
+                    , rotate
+                        (if Tuple.second pos <= 0.0 then
+                            0.0
+
+                         else
+                            180.0
+                        )
+                    , scale
+                        (case maybeRank model of
+                            Just rank ->
+                                case rank of
+                                    Ace ->
+                                        size * 2
+
+                                    Jack ->
+                                        courtPipSize
+
+                                    Queen ->
+                                        courtPipSize
+
+                                    King ->
+                                        courtPipSize
+
+                                    _ ->
+                                        size
+
+                            Nothing ->
+                                size
+                        )
+                    ]
+                ]
+                [ suitIcon model
+                ]
+
+        pipIcons =
+            case maybeRank model of
+                Just rank ->
+                    pips rank
+                        |> List.map suitIconFromPos
+                        |> Svg.g []
+
+                Nothing ->
+                    Svg.text ""
+
+        cornerLabels =
+            Svg.g []
+                [ Svg.g
+                    [ A.transform <| translate p p
+                    ]
+                    [ cornerPip model ]
+                , Svg.g
+                    [ A.transform <| translate (w - p) (h - p) ++ rotate 180
+                    ]
+                    [ cornerPip model ]
+                ]
+    in
+    [ Svg.rect
+        [ num A.width <| w
+        , num A.height <| h
+        , A.rx cornerRadius
+        , A.class "card-front-rect"
+        , A.ry cornerRadius
+        , A.fill white
+        , A.stroke black
+        , A.strokeWidth borderWidth
+        ]
+        []
+    , courtCard
+    , pipIcons
+    , cornerLabels
+    ]

package/src/Layout.elm

@@ -0,0 +1,224 @@
+module Layout exposing (..)
+
+import List exposing (indexedMap, length, map, reverse)
+import Vec exposing (Vec2)
+
+
+type Spread
+    = Horizontal
+    | Vertical
+    | Diagonal
+    | Rows
+    | Columns
+    | Stack
+    | Fan
+
+
+defaultSpread : Spread -> Int
+defaultSpread s =
+    let
+        dist =
+            35
+    in
+    case s of
+        Horizontal ->
+            dist
+
+        Vertical ->
+            85
+
+        Diagonal ->
+            dist
+
+        Rows ->
+            4
+
+        Columns ->
+            4
+
+        Stack ->
+            0
+
+        Fan ->
+            15
+
+
+updateSpreadValue : Spread -> Spread -> Int -> Int
+updateSpreadValue prev next value =
+    if defaultSpread prev == defaultSpread next then
+        value
+
+    else
+        defaultSpread next
+
+
+validateSpreadValue : Spread -> Int -> Int
+validateSpreadValue spreadType value =
+    case spreadType of
+        Rows ->
+            max 1 value
+
+        Columns ->
+            max 1 value
+
+        _ ->
+            value
+
+
+spreadAsString : Spread -> String
+spreadAsString st =
+    case st of
+        Horizontal ->
+            "Horizontal"
+
+        Vertical ->
+            "Vertical"
+
+        Diagonal ->
+            "Diagonal"
+
+        Rows ->
+            "Rows"
+
+        Columns ->
+            "Columns"
+
+        Stack ->
+            "Stack"
+
+        Fan ->
+            "Fan"
+
+
+spreadTransforms : Int -> Vec2 -> Int -> Spread -> List ( Vec2, Vec2, Float )
+spreadTransforms n cardSize spreadValue s =
+    let
+        noRotation =
+            List.map (\v -> ( v, Vec.half Vec.one, 0.0 ))
+
+        vec2i : Int -> Int -> Vec2
+        vec2i x y =
+            Vec2 (toFloat x) (toFloat y)
+
+        targets =
+            List.range 0 (n - 1)
+    in
+    case s of
+        Stack ->
+            targets
+                |> map (\_ -> Vec.zero)
+                |> noRotation
+                |> indexedMap (\i ( p, pv, _ ) -> ( p, pv, toFloat <| spreadValue * i ))
+
+        Horizontal ->
+            targets
+                |> map
+                    (\i -> vec2i (i * spreadValue) 0)
+                |> reverse
+                |> noRotation
+
+        Vertical ->
+            targets
+                |> map
+                    (\i -> vec2i 0 (i * spreadValue))
+                |> reverse
+                |> noRotation
+
+        -- FIX 4 cards to 3 rows etc, same for columns
+        Rows ->
+            let
+                columns =
+                    max 1 (length targets // spreadValue)
+            in
+            targets
+                |> map
+                    (\i ->
+                        Vec2
+                            (toFloat (modBy columns i) * cardSize.x)
+                            (toFloat (i // columns) * cardSize.y)
+                    )
+                |> reverse
+                |> noRotation
+
+        Columns ->
+            let
+                rows =
+                    max 1 (length targets // spreadValue)
+            in
+            targets
+                |> map
+                    (\i ->
+                        Vec2
+                            (toFloat (i // rows) * cardSize.x)
+                            (toFloat (modBy rows i) * cardSize.y)
+                    )
+                |> reverse
+                |> noRotation
+
+        Diagonal ->
+            targets
+                |> map
+                    (\i ->
+                        Vec2
+                            (toFloat <| i * spreadValue)
+                            (toFloat <| i * spreadValue)
+                    )
+                |> reverse
+                |> noRotation
+
+        Fan ->
+            targets
+                |> map
+                    (\i ->
+                        let
+                            t =
+                                toFloat i / toFloat (n - 1)
+
+                            -- angle =
+                            --     0.2
+                            -- p =
+                            --     t * pi * 2.0 * 0.1 - pi * 0.5 - pi * angle
+                            -- x =
+                            --     cos p
+                            -- y =
+                            --     sin p
+                            -- radius =
+                            --     (toFloat <| length targets) * 80.0
+                            deg =
+                                toFloat spreadValue * 0.5 * (toFloat <| List.length targets)
+
+                            pos =
+                                -- sub (scale radius (Vec2 x y)) (Vec2 (-radius * 0.105) (-radius * 0.995))
+                                Vec.zero
+
+                            pivot =
+                                Vec2 0.5 1.0
+
+                            rot =
+                                -0.5 * deg + deg * t
+                        in
+                        ( pos, pivot, rot )
+                    )
+                |> reverse
+
+
+
+-- _ ->
+--     targets
+--         |> map (\_ -> zero)
+--         |> noRotation
+
+
+hsep : Int -> Float -> Vec2 -> Int -> Vec2
+hsep rows separation size index =
+    let
+        column =
+            index // rows
+
+        row =
+            modBy rows index
+
+        ( w, h ) =
+            Vec.tuple size
+    in
+    Vec2 (separation + toFloat column * w) (separation + toFloat row * h)