Add mana costs to decklist

elm.json

@@ -11,6 +11,7 @@
             "elm/core": "1.0.5",
             "elm/html": "1.0.0",
             "elm/json": "1.1.3",
+            "elm/parser": "1.1.0",
             "elm/svg": "1.0.1",
             "elm-community/list-extra": "8.7.0",
             "myrho/elm-round": "1.0.5",
@@ -19,7 +20,6 @@
         "indirect": {
             "K-Adam/elm-dom": "1.0.0",
             "danhandrea/elm-time-extra": "1.1.0",
-            "elm/parser": "1.1.0",
             "elm/time": "1.0.0",
             "elm/url": "1.0.0",
             "elm/virtual-dom": "1.0.2",

src/Card.elm

@@ -4,14 +4,19 @@ module Card exposing
     , CardPerformanceData
     , CardType(..)
     , ManaColor(..)
+    , ManaCost(..)
     , Power(..)
     , alpa
     , alsa
     , gihwr
     , iwd
+    , manaCostToSymbol
+    , parseManaCost
     , pickRate
     )
 
+import Parser as P exposing ((|.), Parser, Trailing(..))
+
 
 type ManaColor
     = Red
@@ -53,8 +58,7 @@ type alias CardDetails =
     , power : Maybe Power
     , toughness : Maybe Power
     , colors : List ManaColor
-
-    --, manaCost : List ManaColor
+    , manaCost : Maybe (List ManaCost)
     }
 
 
@@ -95,3 +99,232 @@ gihwr card =
 iwd : CardData -> Maybe Float
 iwd card =
     card.performance.improvementWhenDrawn
+
+
+type ManaCost
+    = X
+    | Y
+    | Color ManaColor
+    | ColorPay ManaColor
+    | Hybrid ManaColor ManaColor
+    | HybridPay ManaColor ManaColor
+    | AnyColor Int
+    | TwoOrColor ManaColor
+    | Tap
+    | Pay
+
+
+parseManaCost : String -> Maybe (List ManaCost)
+parseManaCost str =
+    let
+        p =
+            P.sequence
+                { start = ""
+                , separator = ""
+                , end = ""
+                , spaces = P.spaces
+                , item = manaCostP
+                , trailing = Optional
+                }
+    in
+    case P.run p str of
+        Ok result ->
+            Just result
+
+        Err _ ->
+            Nothing
+
+
+manaCostP : Parser ManaCost
+manaCostP =
+    let
+        mapping =
+            [ ( "{X}", X )
+            , ( "{Y}", Y )
+            , ( "{R}", Color Red )
+            , ( "{U}", Color Blue )
+            , ( "{G}", Color Green )
+            , ( "{W}", Color White )
+            , ( "{B}", Color Black )
+            , ( "{R/P}", ColorPay Red )
+            , ( "{U/P}", ColorPay Blue )
+            , ( "{G/P}", ColorPay Green )
+            , ( "{W/P}", ColorPay White )
+            , ( "{B/P}", ColorPay Black )
+            , ( "{R/W}", Hybrid Red White )
+            , ( "{R/G}", Hybrid Red Green )
+            , ( "{W/U}", Hybrid White Blue )
+            , ( "{W/B}", Hybrid White Black )
+            , ( "{G/U}", Hybrid Green Blue )
+            , ( "{G/W}", Hybrid Green White )
+            , ( "{U/B}", Hybrid Blue Black )
+            , ( "{U/R}", Hybrid Blue Red )
+            , ( "{B/G}", Hybrid Black Green )
+            , ( "{B/R}", Hybrid Black Red )
+            , ( "{R/W/P}", HybridPay Red White )
+            , ( "{R/G/P}", HybridPay Red Green )
+            , ( "{W/U/P}", HybridPay White Blue )
+            , ( "{W/B/P}", HybridPay White Black )
+            , ( "{G/U/P}", HybridPay Green Blue )
+            , ( "{G/W/P}", HybridPay Green White )
+            , ( "{U/B/P}", HybridPay Blue Black )
+            , ( "{U/R/P}", HybridPay Blue Red )
+            , ( "{B/G/P}", HybridPay Black Green )
+            , ( "{B/R/P}", HybridPay Black Red )
+            , ( "{2/W}", TwoOrColor White )
+            , ( "{2/U}", TwoOrColor Blue )
+            , ( "{2/G}", TwoOrColor Green )
+            , ( "{2/R}", TwoOrColor Red )
+            , ( "{2/B}", TwoOrColor Black )
+            , ( "{T}", Tap )
+            , ( "{P}", Pay )
+            , ( "{0}", AnyColor 0 )
+            , ( "{1}", AnyColor 1 )
+            , ( "{2}", AnyColor 2 )
+            , ( "{3}", AnyColor 3 )
+            , ( "{4}", AnyColor 4 )
+            , ( "{5}", AnyColor 5 )
+            , ( "{6}", AnyColor 6 )
+            , ( "{7}", AnyColor 7 )
+            , ( "{8}", AnyColor 8 )
+            , ( "{9}", AnyColor 9 )
+            , ( "{10}", AnyColor 10 )
+            , ( "{11}", AnyColor 11 )
+            , ( "{12}", AnyColor 12 )
+            , ( "{13}", AnyColor 13 )
+            , ( "{14}", AnyColor 14 )
+            , ( "{15}", AnyColor 15 )
+            ]
+    in
+    P.oneOf
+        (List.map (\( str, manaCost ) -> P.succeed manaCost |. P.keyword str) mapping)
+
+
+manaCostToSymbol : ManaCost -> String
+manaCostToSymbol c =
+    case c of
+        X ->
+            "card-symbol-X"
+
+        Y ->
+            "card-symbol-Y"
+
+        Color Colorless ->
+            "card-symbol-C"
+
+        Color Red ->
+            "card-symbol-R"
+
+        Color Blue ->
+            "card-symbol-U"
+
+        Color Green ->
+            "card-symbol-G"
+
+        Color White ->
+            "card-symbol-W"
+
+        Color Black ->
+            "card-symbol-B"
+
+        ColorPay Red ->
+            "card-symbol-RP"
+
+        ColorPay Blue ->
+            "card-symbol-UP"
+
+        ColorPay Green ->
+            "card-symbol-GP"
+
+        ColorPay White ->
+            "card-symbol-WP"
+
+        ColorPay Black ->
+            "card-symbol-BP"
+
+        Hybrid Red White ->
+            "card-symbol-RW"
+
+        Hybrid Red Green ->
+            "card-symbol-RG"
+
+        Hybrid White Blue ->
+            "card-symbol-WU"
+
+        Hybrid White Black ->
+            "card-symbol-WB"
+
+        Hybrid Green Blue ->
+            "card-symbol-GU"
+
+        Hybrid Green White ->
+            "card-symbol-GW"
+
+        Hybrid Blue Black ->
+            "card-symbol-UB"
+
+        Hybrid Blue Red ->
+            "card-symbol-UR"
+
+        Hybrid Black Green ->
+            "card-symbol-BG"
+
+        Hybrid Black Red ->
+            "card-symbol-BR"
+
+        HybridPay Red White ->
+            "card-symbol-RWP"
+
+        HybridPay Red Green ->
+            "card-symbol-RGP"
+
+        HybridPay White Blue ->
+            "card-symbol-WUP"
+
+        HybridPay White Black ->
+            "card-symbol-WBP"
+
+        HybridPay Green Blue ->
+            "card-symbol-GUP"
+
+        HybridPay Green White ->
+            "card-symbol-GWP"
+
+        HybridPay Blue Black ->
+            "card-symbol-UBP"
+
+        HybridPay Blue Red ->
+            "card-symbol-URP"
+
+        HybridPay Black Green ->
+            "card-symbol-BGP"
+
+        HybridPay Black Red ->
+            "card-symbol-BRP"
+
+        TwoOrColor White ->
+            "card-symbol-2W"
+
+        TwoOrColor Blue ->
+            "card-symbol-2U"
+
+        TwoOrColor Green ->
+            "card-symbol-2G"
+
+        TwoOrColor Red ->
+            "card-symbol-2R"
+
+        TwoOrColor Black ->
+            "card-symbol-2B"
+
+        Tap ->
+            "card-symbol-T"
+
+        Pay ->
+            "card-symbol-P"
+
+        AnyColor n ->
+            "card-symbol-" ++ String.fromInt n
+
+        _ ->
+            ""

src/Database.elm

@@ -1,6 +1,6 @@
 module Database exposing (Database, decode, get)
 
-import Card exposing (CardData, CardDetails, CardPerformanceData, CardType(..), ManaColor(..), Power(..))
+import Card exposing (CardData, CardDetails, CardPerformanceData, CardType(..), ManaColor(..), Power(..), parseManaCost)
 import Dict exposing (Dict)
 import Json.Decode as Decode exposing (Decoder, decodeString)
 import Json.Decode.Pipeline exposing (optional, required)
@@ -148,6 +148,18 @@ decodeCardDetails =
             |> optional "power" (Decode.nullable decodePower) Nothing
             |> optional "toughness" (Decode.nullable decodePower) Nothing
             |> required "colors" (Decode.list decodeManaColor)
+            |> required "mana_cost"
+                (Decode.string
+                    |> Decode.andThen
+                        (\s ->
+                            case parseManaCost s of
+                                Just m ->
+                                    Decode.succeed (Just m)
+
+                                Nothing ->
+                                    Decode.succeed Nothing
+                        )
+                )
         )
 
 

src/Main.elm

@@ -1,7 +1,7 @@
 module Main exposing (..)
 
 import Browser exposing (Document)
-import Card exposing (CardData)
+import Card exposing (CardData, manaCostToSymbol)
 import Chart as C
 import Chart.Attributes as CA
 import Database
@@ -270,10 +270,21 @@ viewDeckList model =
         decklist =
             ul [] (List.map viewCard deck)
 
+        viewManaCost : CardData -> Html Msg
+        viewManaCost card =
+            case card.details.manaCost of
+                Just xs ->
+                    span [ class "flex" ] (List.map (\x -> span [ class ("w-4 h-4 block " ++ manaCostToSymbol x) ] []) xs)
+
+                Nothing ->
+                    span
+                        []
+                        [ text "?" ]
+
         viewCard : CardData -> Html Msg
         viewCard card =
-            li [ class "" ]
-                [ text card.details.name ]
+            li [ class "flex items-center gap-2 text-white justify-between" ]
+                [ span [ class "truncate" ] [ text card.details.name ], viewManaCost card ]
     in
     div [ class "mb-2 w-full" ]
         [ button
@@ -291,7 +302,7 @@ viewDeckList model =
             ]
         , if model.toolboxAccordion.deckList then
             div [ class "py-2" ]
-                [ decklist
+                [ div [ class "max-h-[400px] overflow-y-auto pr-2" ] [ decklist ]
                 ]
 
           else

tests/TestCard.elm

@@ -0,0 +1,22 @@
+module TestCard exposing (..)
+
+import Card exposing (ManaCost(..))
+import Expect exposing (Expectation)
+import Fuzz exposing (Fuzzer, int, list, string)
+import Signals
+import Test exposing (..)
+
+
+suite : Test
+suite =
+    describe "Card"
+        [ test "parseManaCost ('')" <|
+            \_ ->
+                Expect.equal (Card.parseManaCost "") (Just [])
+        , test "parseManaCost ('{X}')" <|
+            \_ ->
+                Expect.equal (Card.parseManaCost "{X}") (Just [ X ])
+        , test "parseManaCost ('{X}{Y}')" <|
+            \_ ->
+                Expect.equal (Card.parseManaCost "{X}{Y}") (Just [ X, Y ])
+        ]