Equipped left/right hand

Janiczek · Oct 1, 2024 · d28e64a · d28e64a
1 parent 5725281
commit d28e64a
Show file tree

Hide file tree

Showing 18 changed files with 378 additions and 700 deletions.
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -18,5 +18,8 @@
     "\\bclassList[\\s\\[\\(]+\"[^\"]*\",\\s[^\\)]+\\)[\\s\\[\\(,]+\"[^\"]*\",\\s[^\\)]+\\)[\\s\\[\\(,]+\"([^\"]*)\"",
   ],
   "elmLS.elmPath": "lamdera",
-  "elmLS.elmReviewDiagnostics": "warning"
+  "elmLS.elmReviewDiagnostics": "warning",
+  "files.exclude": {
+    "src/Evergreen": true
+  }
 }
diff --git a/Makefile b/Makefile
@@ -1,10 +1,6 @@
 SEED ?= "$$RANDOM"
 FUZZ ?= "100"
 
-.PHONY: watch
-watch:
-	elmid --watched-folder=src src/DummyMain.elm
-
 .PHONY: start
 start:
 	lamdera live

diff --git a/src/Admin.elm b/src/Admin.elm
@@ -18,7 +18,6 @@ import Dict
 import Dict.ExtraExtra as Dict
 import Json.Decode as JD exposing (Decoder)
 import Json.Encode as JE
-import Logic
 import Queue
 import Random
 import Set.ExtraExtra as Set
@@ -35,30 +34,12 @@ encodeBackendModel model =
 backendModelDecoder : Random.Seed -> Decoder BackendModel
 backendModelDecoder seed =
     JD.oneOf
-        [ backendModelDecoderV2 seed
-        , backendModelDecoderV1 seed
+        [ backendModelDecoderV1 seed
         ]
 
 
 backendModelDecoderV1 : Random.Seed -> Decoder BackendModel
 backendModelDecoderV1 seed =
-    JD.map
-        (\world ->
-            { worlds = Dict.singleton Logic.mainWorldName world
-            , loggedInPlayers = BiDict.empty
-            , time = Time.millisToPosix 0
-            , adminLoggedIn = Nothing
-            , lastTenToBackendMsgs = Queue.empty
-            , randomSeed = seed
-            , playerDataCache = Dict.empty
-            }
-        )
-        World.decoder
-
-
-backendModelDecoderV2 : Random.Seed -> Decoder BackendModel
-backendModelDecoderV2 seed =
-    -- adds support for multiple worlds
     JD.map
         (\worlds ->
             { worlds = worlds
@@ -118,16 +99,36 @@ encodeToBackendMsg msg =
             JE.object
                 [ ( "type", JE.string "Wander" ) ]
 
-        EquipItem itemId ->
+        EquipArmor itemId ->
             JE.object
-                [ ( "type", JE.string "EquipItem" )
+                [ ( "type", JE.string "EquipArmor" )
+                , ( "itemId", JE.int itemId )
+                ]
+
+        EquipLeftHand itemId ->
+            JE.object
+                [ ( "type", JE.string "EquipLeftHand" )
+                , ( "itemId", JE.int itemId )
+                ]
+
+        EquipRightHand itemId ->
+            JE.object
+                [ ( "type", JE.string "EquipRightHand" )
                 , ( "itemId", JE.int itemId )
                 ]
 
         UnequipArmor ->
             JE.object
                 [ ( "type", JE.string "UnequipArmor" ) ]
 
+        UnequipLeftHand ->
+            JE.object
+                [ ( "type", JE.string "UnequipLeftHand" ) ]
+
+        UnequipRightHand ->
+            JE.object
+                [ ( "type", JE.string "UnequipRightHand" ) ]
+
         SetFightStrategy ( strategy, text ) ->
             JE.object
                 [ ( "type", JE.string "SetFightStrategy" )

diff --git a/src/Backend.elm b/src/Backend.elm
@@ -60,7 +60,7 @@ import Queue
 import Random exposing (Generator)
 import Random.List
 import SeqDict exposing (SeqDict)
-import SeqSet exposing (SeqSet)
+import SeqSet
 import Set exposing (Set)
 import Task
 import Time exposing (Posix)
@@ -854,12 +854,24 @@ updateFromFrontend sessionId clientId msg model =
         Wander ->
             withLoggedInCreatedPlayer wander
 
-        EquipItem itemId ->
-            withLoggedInCreatedPlayer <| equipItem itemId
+        EquipArmor itemId ->
+            withLoggedInCreatedPlayer <| equipArmor itemId
+
+        EquipLeftHand itemId ->
+            withLoggedInCreatedPlayer <| equipLeftHand itemId
+
+        EquipRightHand itemId ->
+            withLoggedInCreatedPlayer <| equipRightHand itemId
 
         UnequipArmor ->
             withLoggedInCreatedPlayer unequipArmor
 
+        UnequipLeftHand ->
+            withLoggedInCreatedPlayer unequipLeftHand
+
+        UnequipRightHand ->
+            withLoggedInCreatedPlayer unequipRightHand
+
         SetFightStrategy ( strategy, text ) ->
             withLoggedInCreatedPlayer <| setFightStrategy ( strategy, text )
 
@@ -1404,16 +1416,48 @@ healMe clientId _ worldName player model =
         |> sendCurrentWorld worldName player.name clientId
 
 
-equipItem : Item.Id -> ClientId -> World -> World.Name -> SPlayer -> Model -> ( Model, Cmd BackendMsg )
-equipItem itemId clientId _ worldName player model =
+equipArmor : Item.Id -> ClientId -> World -> World.Name -> SPlayer -> Model -> ( Model, Cmd BackendMsg )
+equipArmor itemId clientId _ worldName player model =
+    case Dict.get itemId player.items of
+        Nothing ->
+            ( model, Cmd.none )
+
+        Just item ->
+            if Item.isArmor item.kind then
+                model
+                    |> updatePlayer worldName player.name (SPlayer.equipArmor item)
+                    |> sendCurrentWorld worldName player.name clientId
+
+            else
+                ( model, Cmd.none )
+
+
+equipLeftHand : Item.Id -> ClientId -> World -> World.Name -> SPlayer -> Model -> ( Model, Cmd BackendMsg )
+equipLeftHand itemId clientId _ worldName player model =
+    case Dict.get itemId player.items of
+        Nothing ->
+            ( model, Cmd.none )
+
+        Just item ->
+            if Item.isHandEquippable item.kind then
+                model
+                    |> updatePlayer worldName player.name (SPlayer.equipLeftHand item)
+                    |> sendCurrentWorld worldName player.name clientId
+
+            else
+                ( model, Cmd.none )
+
+
+equipRightHand : Item.Id -> ClientId -> World -> World.Name -> SPlayer -> Model -> ( Model, Cmd BackendMsg )
+equipRightHand itemId clientId _ worldName player model =
     case Dict.get itemId player.items of
         Nothing ->
             ( model, Cmd.none )
 
         Just item ->
-            if Item.isEquippable item.kind then
+            if Item.isHandEquippable item.kind then
                 model
-                    |> updatePlayer worldName player.name (SPlayer.equipItem item)
+                    |> updatePlayer worldName player.name (SPlayer.equipRightHand item)
                     |> sendCurrentWorld worldName player.name clientId
 
             else
@@ -1512,6 +1556,30 @@ unequipArmor clientId _ worldName player model =
                 |> sendCurrentWorld worldName player.name clientId
 
 
+unequipLeftHand : ClientId -> World -> World.Name -> SPlayer -> Model -> ( Model, Cmd BackendMsg )
+unequipLeftHand clientId _ worldName player model =
+    case player.equippedLeftHand of
+        Nothing ->
+            ( model, Cmd.none )
+
+        Just _ ->
+            model
+                |> updatePlayer worldName player.name SPlayer.unequipLeftHand
+                |> sendCurrentWorld worldName player.name clientId
+
+
+unequipRightHand : ClientId -> World -> World.Name -> SPlayer -> Model -> ( Model, Cmd BackendMsg )
+unequipRightHand clientId _ worldName player model =
+    case player.equippedRightHand of
+        Nothing ->
+            ( model, Cmd.none )
+
+        Just _ ->
+            model
+                |> updatePlayer worldName player.name SPlayer.unequipRightHand
+                |> sendCurrentWorld worldName player.name clientId
+
+
 wander : ClientId -> World -> World.Name -> SPlayer -> Model -> ( Model, Cmd BackendMsg )
 wander clientId world worldName player model =
     let

diff --git a/src/Calculator/Meta/Individual.elm b/src/Calculator/Meta/Individual.elm
@@ -71,6 +71,15 @@ healingItemKindGenerator =
     Random.uniform x xs
 
 
+itemKindGenerator : Generator Item.Kind
+itemKindGenerator =
+    let
+        ( x, xs ) =
+            Item.allNonempty
+    in
+    Random.uniform x xs
+
+
 shotTypeGenerator : Generator ShotType
 shotTypeGenerator =
     Random.uniform ShotType.NormalShot
@@ -79,15 +88,54 @@ shotTypeGenerator =
 
 conditionGenerator : Generator FightStrategy.Condition
 conditionGenerator =
+    let
+        self =
+            Random.lazy (\() -> conditionGenerator)
+    in
     Random.uniform
-        (FightStrategy.Operator
-            { value = FightStrategy.MyHP
-            , op = FightStrategy.LT_
-            , number_ = 50
-            }
+        (Random.map3
+            (\lhs op rhs ->
+                FightStrategy.Operator
+                    { lhs = lhs
+                    , op = op
+                    , rhs = rhs
+                    }
+            )
+            valueGenerator
+            operatorGenerator
+            valueGenerator
         )
-        [ FightStrategy.OpponentIsPlayer
-        , FightStrategy.OpponentIsNPC
+        [ Random.constant FightStrategy.OpponentIsPlayer
+        , Random.constant FightStrategy.OpponentIsNPC
+        , Random.map2 FightStrategy.Or self self
+        , Random.map2 FightStrategy.And self self
+        ]
+        |> Random.andThen identity
+
+
+valueGenerator : Generator FightStrategy.Value
+valueGenerator =
+    Random.uniform
+        (Random.constant FightStrategy.MyHP)
+        [ Random.constant FightStrategy.MyMaxHP
+        , Random.constant FightStrategy.MyAP
+        , Random.map FightStrategy.MyItemCount itemKindGenerator
+        , Random.map FightStrategy.ItemsUsed itemKindGenerator
+        , Random.map FightStrategy.ChanceToHit shotTypeGenerator
+        , Random.constant FightStrategy.Distance
+        , Random.map FightStrategy.Number (Random.int -50 300)
+        ]
+        |> Random.andThen identity
+
+
+operatorGenerator : Generator FightStrategy.Operator
+operatorGenerator =
+    Random.uniform FightStrategy.LT_
+        [ FightStrategy.LTE
+        , FightStrategy.EQ_
+        , FightStrategy.NE
+        , FightStrategy.GTE
+        , FightStrategy.GT_
         ]
 
 
@@ -130,9 +178,9 @@ moveForwardIfNeeded strategy =
     FightStrategy.If
         { condition =
             FightStrategy.Operator
-                { value = FightStrategy.Distance
+                { lhs = FightStrategy.Distance
                 , op = FightStrategy.GT_
-                , number_ = 0
+                , rhs = FightStrategy.Number 0
                 }
         , then_ = FightStrategy.Command FightStrategy.MoveForward
         , else_ = strategy
@@ -477,6 +525,9 @@ mutateFightStrategy str =
                 FightStrategy.MoveForward ->
                     Random.constant FightStrategy.MoveForward
 
+                FightStrategy.SkipTurn ->
+                    Random.constant FightStrategy.SkipTurn
+
                 FightStrategy.DoWhatever ->
                     Random.constant FightStrategy.DoWhatever
 

diff --git a/src/Data/Auth.elm b/src/Data/Auth.elm
@@ -72,21 +72,12 @@ encodePassword password =
 verifiedDecoder : Decoder (Auth Verified)
 verifiedDecoder =
     JD.oneOf
-        [ verifiedDecoderV2
-        , verifiedDecoderV1
+        [ verifiedDecoderV1
         ]
 
 
 verifiedDecoderV1 : Decoder (Auth Verified)
 verifiedDecoderV1 =
-    JD.succeed Auth
-        |> JD.andMap (JD.field "name" JD.string)
-        |> JD.andMap (JD.field "password" verifiedPasswordDecoder)
-        |> JD.andMap (JD.succeed Logic.mainWorldName)
-
-
-verifiedDecoderV2 : Decoder (Auth Verified)
-verifiedDecoderV2 =
     JD.succeed Auth
         |> JD.andMap (JD.field "name" JD.string)
         |> JD.andMap (JD.field "password" verifiedPasswordDecoder)