Splits client and server into two repositories.

4 files changed, 266 insertions, 0 deletions

diff --git a/elm/battlemap/src/Update/DirectionRequest.elm b/elm/battlemap/src/Update/DirectionRequest.elm
new file mode 100644
index 0000000..da32240
--- /dev/null
+++ b/elm/battlemap/src/Update/DirectionRequest.elm
@@ -0,0 +1,37 @@
+module Update.DirectionRequest exposing (apply_to)
+
+import Dict
+
+import Battlemap.Direction
+import Battlemap.Navigator.Move
+
+import Model
+import Error
+
+make_it_so : Model.Type -> Battlemap.Direction.Type -> Model.Type
+make_it_so model dir =
+   case model.selection of
+      Nothing -> {model | state = (Model.Error Error.Programming)}
+      (Just selection) ->
+         let
+            (new_bmap, new_nav) =
+               (Battlemap.Navigator.Move.to
+                  model.battlemap
+                  selection.navigator
+                  dir
+                  (Dict.values model.characters)
+               )
+         in
+            {model |
+               state = Model.MovingCharacterWithButtons,
+               battlemap = new_bmap,
+               selection = (Just {selection | navigator = new_nav})
+            }
+
+
+apply_to : Model.Type -> Battlemap.Direction.Type -> Model.Type
+apply_to model dir =
+   case model.state of
+      Model.MovingCharacterWithButtons -> (make_it_so model dir)
+      Model.MovingCharacterWithClick -> (make_it_so model dir)
+      _ -> {model | state = (Model.Error Error.IllegalAction)}
diff --git a/elm/battlemap/src/Update/EndTurn.elm b/elm/battlemap/src/Update/EndTurn.elm
new file mode 100644
index 0000000..7172b2f
--- /dev/null
+++ b/elm/battlemap/src/Update/EndTurn.elm
@@ -0,0 +1,61 @@
+module Update.EndTurn exposing (apply_to)
+
+import Dict
+
+import Battlemap
+import Battlemap.Direction
+import Battlemap.Navigator
+import Battlemap.Tile
+
+import Model
+
+import Error
+
+make_it_so : Model.Type -> Model.Type
+make_it_so model =
+   case model.selection of
+      Nothing -> {model | state = (Model.Error Error.Programming)}
+      (Just selection) ->
+         case (Dict.get selection.character model.characters) of
+            Nothing -> {model | state = (Model.Error Error.Programming)}
+            (Just char) ->
+               {model |
+                  state = Model.Default,
+                  selection = Nothing,
+                  battlemap =
+                     (Battlemap.apply_to_all_tiles
+                        (Battlemap.apply_to_tile_unsafe
+                           (Battlemap.apply_to_tile_unsafe
+                              model.battlemap
+                              char.location
+                              (\t -> {t | char_level = Nothing})
+                           )
+                           selection.navigator.current_location
+                           (\t -> {t | char_level = (Just selection.character)})
+                        )
+                        (Battlemap.Tile.reset_tile)
+                     ),
+                  characters =
+                     (Dict.update
+                        selection.character
+                        (\mc ->
+                           case mc of
+                              Nothing -> Nothing
+                              (Just c) ->
+                                 (Just
+                                    {c |
+                                       location = selection.navigator.current_location
+                                    }
+                                 )
+                        )
+                        model.characters
+                     )
+               }
+
+apply_to : Model.Type -> Model.Type
+apply_to model =
+   case model.state of
+      Model.MovingCharacterWithButtons -> (make_it_so model)
+      Model.MovingCharacterWithClick -> (make_it_so model)
+      _ -> {model | state = (Model.Error Error.IllegalAction)}
+
diff --git a/elm/battlemap/src/Update/SelectCharacter.elm b/elm/battlemap/src/Update/SelectCharacter.elm
new file mode 100644
index 0000000..0e7b1c4
--- /dev/null
+++ b/elm/battlemap/src/Update/SelectCharacter.elm
@@ -0,0 +1,88 @@
+module Update.SelectCharacter exposing (apply_to)
+
+import Dict
+
+import Character
+
+import Battlemap
+import Battlemap.Direction
+import Battlemap.Location
+import Battlemap.Navigator
+import Battlemap.Tile
+import Battlemap.RangeIndicator
+
+import Model
+import Event
+import Error
+
+display_range : (
+      Int ->
+      Battlemap.Location.Ref ->
+      Battlemap.RangeIndicator.Type ->
+      Battlemap.Type ->
+      Battlemap.Type
+   )
+display_range dist loc_ref indicator bmap =
+   (Battlemap.apply_to_tile_unsafe
+      bmap
+      (Battlemap.Location.from_ref loc_ref)
+      (\e ->
+         {e |
+            mod_level =
+               (
+                  if (indicator.distance <= dist)
+                  then
+                     (Just Battlemap.Tile.CanBeReached)
+                  else
+                     (Just Battlemap.Tile.CanBeAttacked)
+               )
+         }
+      )
+   )
+
+
+make_it_so : Model.Type -> Character.Ref -> Model.Type
+make_it_so model char_id =
+   case (Dict.get char_id model.characters) of
+      Nothing -> {model | state = (Model.Error Error.Programming)}
+      (Just char) ->
+         let
+            new_range_indicator =
+               (Battlemap.RangeIndicator.generate
+                  model.battlemap
+                  char.location
+                  char.movement_points
+                  (char.movement_points + char.atk_dist)
+               )
+         in
+            {model |
+               state = Model.MovingCharacterWithClick,
+               battlemap =
+                  (
+                     (Dict.foldl
+                        (display_range char.movement_points)
+                        (Battlemap.apply_to_all_tiles
+                           model.battlemap
+                           (Battlemap.Tile.reset_tile)
+                        )
+                        new_range_indicator
+                     )
+                  ),
+               selection =
+                  (Just
+                     {
+                        character = char_id,
+                        navigator =
+                           (Battlemap.Navigator.new
+                              char.location
+                              char.movement_points
+                           ),
+                        range_indicator = new_range_indicator
+                     }
+                  )
+            }
+
+apply_to : Model.Type -> Character.Ref -> Model.Type
+apply_to model char_id =
+   case model.state of
+      _ -> (make_it_so model char_id)
diff --git a/elm/battlemap/src/Update/SelectTile.elm b/elm/battlemap/src/Update/SelectTile.elm
new file mode 100644
index 0000000..aa89c30
--- /dev/null
+++ b/elm/battlemap/src/Update/SelectTile.elm
@@ -0,0 +1,80 @@
+module Update.SelectTile exposing (apply_to)
+
+import Dict
+
+import Character
+
+import Battlemap
+import Battlemap.Direction
+import Battlemap.Location
+import Battlemap.Navigator
+import Battlemap.Tile
+import Battlemap.RangeIndicator
+
+import Update.DirectionRequest
+import Update.EndTurn
+
+import Model
+import Error
+
+autopilot : Battlemap.Direction.Type -> Model.Type -> Model.Type
+autopilot dir model =
+   (Update.DirectionRequest.apply_to model dir)
+
+go_to_tile : Model.Type -> Battlemap.Location.Ref -> Model.Type
+go_to_tile model loc_ref =
+   case model.selection of
+      Nothing -> {model | state = (Model.Error Error.Programming)}
+      (Just selection) ->
+         case (Dict.get loc_ref selection.range_indicator) of
+            Nothing -> {model | state = Model.Default, selection = Nothing}
+            (Just indicator) ->
+               let
+                  new_model =
+                     (List.foldr
+                        (autopilot)
+                        {model |
+                           battlemap =
+                              (Battlemap.apply_to_all_tiles
+                                 model.battlemap
+                                 (Battlemap.Tile.set_direction
+                                    Battlemap.Direction.None
+                                 )
+                              ),
+                           selection =
+                              (Just
+                                 {
+                                    selection |
+                                    navigator =
+                                       (Battlemap.Navigator.reset
+                                          selection.navigator
+                                       )
+                                 }
+                              )
+                        }
+                        indicator.path
+                     )
+               in
+                  if
+                  (
+                     (model.state == Model.MovingCharacterWithClick)
+                     &&
+                     (
+                        (Battlemap.Location.get_ref
+                           selection.navigator.current_location
+                        )
+                        == loc_ref
+                     )
+                  )
+                  then
+                     (Update.EndTurn.apply_to new_model)
+                  else
+                     {new_model | state = model.state}
+
+
+apply_to : Model.Type -> Battlemap.Location.Ref -> Model.Type
+apply_to model loc_ref =
+   case model.state of
+      Model.MovingCharacterWithButtons -> (go_to_tile model loc_ref)
+      Model.MovingCharacterWithClick -> (go_to_tile model loc_ref)
+      _ -> {model | state = (Model.Error Error.IllegalAction)}