Players can have items and see what those items are.

Also a test screen framework for testing without randomness. :D

They can also use the items they have.

Author: Havvy

Diff for: apps/gald/lib/gald/controller.ex

@@ -10,7 +10,7 @@ defmodule Gald.Controller do
   # TODO(Havvy): Change to a :gen_fsm?
   use GenServer
   use Gald.Race
-  import ShortMaps
+  import Destructure
   alias Gald.Race
   alias Gald.Config
   alias Gald.Players
@@ -23,15 +23,15 @@ defmodule Gald.Controller do
   @spec start_link(Race.t, %Config{}) :: {:ok, pid}
   @spec start_link(Race.t, %Config{}, GenServer.opts) :: {:ok, pid}
   def start_link(race, config, opts \\ []) do
-    GenServer.start_link(__MODULE__, ~m{race config}a, opts)
+    GenServer.start_link(__MODULE__, d(%{race, config}), opts)
   end
 
-  def init(~m{race config}a) do
+  def init(d%{race, config}) do
     status = :lobby
-    {:ok, ~m{race config status}a}
+    {:ok, d%{race, config, status}}
   end
 
-  def handle_call({:new_player, name}, _from, state = ~m{race status}a) do
+  def handle_call({:new_player, name}, _from, state = d%{race, status}) do
     reply = if status == :lobby do
       case Players.new_player(players(race), name) do
         {:ok, player} ->
@@ -52,7 +52,7 @@ defmodule Gald.Controller do
 
   def handle_call(:config, _from, state), do: {:reply, state.config, state}
 
-  def handle_cast(:begin, state = ~m{race config}a) do
+  def handle_cast(:begin, state = d%{race, config}) do
     require Logger
     state = %{state | status: :play}
     # Determine turn order
@@ -72,7 +72,7 @@ defmodule Gald.Controller do
     {:ok, _map} = Race.start_map(race, map_config)
 
     # Start the event choosing process.
-    event_manager_config = ~m{config}a
+    event_manager_config = d%{config}
     {:ok, _event_manager} = Race.start_event_manager(race, event_manager_config)
 
     snapshot = Snapshot.new(%{state | status: :beginning})
@@ -88,7 +88,7 @@ defmodule Gald.Controller do
     {:noreply, state}
   end
 
-  def handle_cast(:finish, state = ~m{race}a) do
+  def handle_cast(:finish, state = d%{race}) do
     state = %{state | status: :over}
     snapshot = Snapshot.new(state)
     GenEvent.notify(out(race), {:finish, snapshot.data})

Diff for: apps/gald/lib/gald/monsters.ex

@@ -6,16 +6,16 @@ defmodule Gald.Monsters do
   """
 
   use Supervisor
-  import ShortMaps
+  import Destructure
   alias Gald.Monster
 
   # Client
   def start_link(init_map, otp_opts \\ []) do
     Supervisor.start_link(__MODULE__, init_map, otp_opts)
   end
 
-  def start_monster(monsters, ~m{monster_module}a) do
-    Supervisor.start_child(monsters, [~m{monster_module}a])
+  def start_monster(monsters, d%{monster_module}) do
+    Supervisor.start_child(monsters, [d%{monster_module}])
   end
 
   # Server

Diff for: apps/gald/lib/gald/player/controller.ex

@@ -49,6 +49,21 @@ defmodule Gald.Player.Controller do
     {:noreply, state}
   end
 
+  def handle_cast({:update_health, updater}, state = d%{player}) do
+    Stats.update_health(Player.stats(player), updater)
+    {:noreply, state}
+  end
+
+  def handle_cast({:unborrow_usable, use_result}, state=d%{player}) do
+    Player.Inventory.unborrow_usable(Player.inventory(player), use_result)
+    {:noreply, state}
+  end
+
+  def handle_call({:borrow_usable, usable_name}, _from, state = d%{player}) do
+    reply = Player.Inventory.borrow_usable(Player.inventory(player), usable_name)
+    {:reply, reply, state}
+  end
+
   def handle_call(:name, _from, state) do
     {:reply, state.name, state}
   end

Diff for: apps/gald/lib/gald/player/input.ex

@@ -1,28 +1,59 @@
+# TODO(Havvy): Rename to Gald.PlayerInput
+#              Because it connects the player to the game, it's
+#              not actually actually a component to being a player,
+#              but rather an interface in the game predicated on
+#              what the player has access to.
+#              This is a prestep for removing the Race dependency
+#              on Player.
 defmodule Gald.Player.Input do
   use GenServer
-  import ShortMaps
-  alias Gald.Race
-  alias Gald.Turn
+  import Destructure
+  alias Gald.{Race, Turn, Player, Usable}
   require Logger
 
+  @type player_option_result :: Turn.player_option_result
+  @type player_usable_result :: :ok | {:error, :no_such_item}
+
   # Client
   def start_link(init_arg, opts \\ []) do
     GenServer.start_link(__MODULE__, init_arg, opts)
   end
 
+  @spec select_option(GenServer.server, String.t) :: player_option_result
   def select_option(player_in, option) do
     GenServer.call(player_in, {:option, option})
   end
 
+  @spec use_usable(GenServer.server, String.t) :: player_usable_result
+  def use_usable(player_in, usable) do
+    GenServer.call(player_in, {:usable, usable})
+  end
+
   # Server
-  def init(~m{race player}a) do
-    {:ok, ~m{race player}a}
+  def init(d%{race, player}) do
+    {:ok, d%{race, player}}
   end
 
-  def handle_call({:option, option}, _from, state = ~m{player race}a) do
-    player_name = Gald.Player.name(player)
+  def handle_call({:option, option}, _from, state = d%{player, race}) do
+    player_name = Player.name(player)
     Logger.debug("Player #{player_name} selects #{option}.")
     reply = Turn.player_option(Race.turn(race), player_name, option)
     {:reply, reply, state}
   end
+
+  def handle_call({:usable, usable_name}, _from, state = d%{player}) do
+    player_name = Player.name(player)
+    Logger.debug("Player #{player_name} using #{usable_name}.")
+    reply = do_use_usable(usable_name, player)
+    {:reply, reply, state}
+  end
+
+  defp do_use_usable(usable_name, player) do
+    with {:ok, usable} <- Player.borrow_usable(player, usable_name),
+      usable_result <- Usable.use(usable, player) do
+        Player.unborrow_usable(player, usable_result)
+        Player.emit_stats(player)
+        :ok
+      end
+  end
 end

Diff for: apps/gald/lib/gald/player/inventory.ex

@@ -1,35 +1,60 @@
 defmodule Gald.Player.Inventory do
-  @moduledoc false
+  @moduledoc """
+  Player's inventory. Responsible for storing usables and firing off their usables affects.
+  """
 
   use GenServer
+  alias Gald.{Usable}
+  alias Gald.Usable.List, as: Inventory
+
+  @type use_usable_result :: :ok | {:error, :no_such_usable}
+  @type inventory :: [Usable.t]
 
   def start_link(state, opts) do
     GenServer.start_link(__MODULE__, state, opts)
   end
 
+  @spec display_info(GenServer.server) :: [String.t]
+  def display_info(inventory) do
+    GenServer.call(inventory, :display_info)
+  end
+
   @spec put_usable(GenServer.server, Gald.Usable.t) :: :ok
   def put_usable(inventory, usable) do
     GenServer.cast(inventory, {:put_usable, usable})
   end
 
-  @spec display_info(GenServer.info) :: [String.t]
-  def display_info(inventory) do
-    GenServer.call(inventory, :display_info)
+  @spec borrow_usable(GenServer.server, String.t) :: {:ok, Usable.t} | {:error, :no_such_usable}
+  def borrow_usable(inventory, usable_name) do
+    GenServer.call(inventory, {:borrow_usable, usable_name})
   end
 
+  @spec unborrow_usable(GenServer.server, Usable.use_result) :: :ok
+  def unborrow_usable(inventory, use_result) do
+    GenServer.cast(inventory, {:unborrow_usable, use_result})
+  end
+
+  @spec can_use(Usable.t) :: :ok | {:error, :cannot_use_when_dead}
+  def can_use(_usable), do: :ok
+
   def init(_opts) do
     {:ok, []}
   end
 
-  def handle_call(:display_info, _from, inventory) do
-    reply = inventory
-    |> Enum.map(&Gald.Usable.name/1)
-    |> Enum.reverse()
+  def handle_cast({:put_usable, usable}, inventory) do
+    {:noreply, Inventory.put_usable(inventory, usable)}
+  end
 
-    {:reply, reply, inventory}
+  def handle_cast({:unborrow_usable, use_result}, inventory) do
+    {:noreply, Inventory.unborrow_usable(inventory, use_result)}
   end
 
-  def handle_cast({:put_usable, usable}, inventory) do
-    {:noreply, [usable | inventory]}
+  def handle_call(:display_info, _from, inventory) do
+    {:reply, Inventory.display_info(inventory), inventory}
+  end
+
+  def handle_call({:borrow_usable, usable_name}, _from, inventory) do
+    {reply, inventory} = Inventory.borrow_usable(inventory, usable_name)
+    {:reply, reply, inventory}
   end
 end

Diff for: apps/gald/lib/gald/player/mod.ex

@@ -104,21 +104,36 @@ defmodule Gald.Player do
     GenServer.call(controller(player), :on_turn_start)
   end
 
+  def update_health(player, updater) when is_pid(player) do
+    GenServer.cast(controller(player), {:update_health, updater})
+  end
+
   @spec put_usable(Supervisor.supervisor, Gald.Usable.t) :: :ok
   def put_usable(player, usable) when is_pid(player) do
     GenServer.cast(controller(player), {:put_usable, usable})
   end
 
+  # TODO(Havvy): Return a ref with the usable for the spot the usable was at.
+  @spec borrow_usable(Supervisor.supervisor, String.t) :: {:ok, Usable.t} | {:error, :no_such_item}
+  def borrow_usable(player, usable_name) do
+    GenServer.call(controller(player), {:borrow_usable, usable_name})
+  end
+
+  @spec unborrow_usable(Supervisor.supervisor, Usable.use_result) :: :ok
+  def unborrow_usable(player, usable_result) do
+    GenServer.cast(controller(player), {:unborrow_usable, usable_result})
+  end
+
   # Server
   def init(d%{race, name}) do
-    base_args = d%{race, player: self}
+    base_args = d%{race, player: self()}
     controller_args = Map.put(base_args, :name, name)
     children = [
-      worker(Controller, [controller_args, [name: controller(self)]]),
-      worker(Input, [base_args, [name: input(self)]]),
-      worker(GenEvent, [[name: output(self)]]),
-      worker(Stats, [base_args, [name: stats(self)]]),
-      worker(Inventory, [base_args, [name: inventory(self)]])
+      worker(Controller, [controller_args, [name: controller(self())]]),
+      worker(Input, [base_args, [name: input(self())]]),
+      worker(GenEvent, [[name: output(self())]]),
+      worker(Stats, [base_args, [name: stats(self())]]),
+      worker(Inventory, [base_args, [name: inventory(self())]])
     ]
 
     supervise(children, [strategy: :one_for_all, max_restarts: 0])

Diff for: apps/gald/lib/gald/player/stats.ex

@@ -18,6 +18,7 @@ defmodule Gald.Player.Stats do
   import Destructure
   alias Gald.Status
   alias Gald.Status.List, as: StatusEffects
+  alias Gald.Status.Respawning
 
   @type life :: :alive | Gald.Death.t
   @type health :: non_neg_integer
@@ -155,7 +156,7 @@ defmodule Gald.Player.Stats do
     Agent.update(stats, &%Gald.Player.Stats{ &1 |
       life: %Gald.Death{},
       health: 0,
-      status_effects: StatusEffects.filter_category(&1.status_effects, :soulbound)
+      status_effects: &1.status_effects |> StatusEffects.filter_category(:soulbound) |> StatusEffects.put(%Respawning{})
     })
   end
 
@@ -164,9 +165,14 @@ defmodule Gald.Player.Stats do
   def respawn_tick(stats) do
     Agent.get_and_update(stats, &respawn_tick_impl/1)
   end
-  defp respawn_tick_impl(stats = %Gald.Player.Stats{life: life, max_health: max_health}) do
+  defp respawn_tick_impl(stats = d%Gald.Player.Stats{life, max_health, status_effects}) do
     {new_life, respawned} = Gald.RespawnTick.respawn_tick(life)
     health = if respawned do max_health else 0 end
-    {respawned, %{stats | life: new_life, health: health}}
+    status_effects = if respawned do
+      StatusEffects.delete(status_effects, Gald.Status.Respawning)
+    else
+      status_effects
+    end
+    {respawned, %{stats | life: new_life, health: health, status_effects: status_effects}}
   end
 end

Diff for: apps/gald/lib/gald/players.ex

@@ -25,7 +25,7 @@ defmodule Gald.Players do
   # Server
   def init(race) do
     player_spec = Supervisor.Spec.worker(Player, [])
-    {:ok, sup} = Supervisor.start_link([player_spec], strategy: :simple_one_for_one)
+    {:ok, sup} = Supervisor.start_link([player_spec], [strategy: :simple_one_for_one, max_restarts: 0])
     names_to_pids = %{}
     join_ix = 0
     {:ok, d%{sup, names_to_pids, join_ix, race}}

Diff for: apps/gald/lib/gald/race.ex

@@ -37,12 +37,12 @@ defmodule Gald.Race do
   # Server
   def init(config = %Config{}) do
     children = [
-      worker(GenEvent, [[name: out(self)]]),
-      worker(Gald.Controller, [self, config, [name: controller(self)]]),
-      worker(Gald.Players, [self, [name: players(self)]]),
-      worker(Gald.Rng, [%{module: config.rng, config: config.rng_config}, [name: rng(self)]]),
-      worker(Gald.Display, [%{race: self}, [name: display(self)]]),
-      worker(Gald.Monsters, [nil, [name: monsters(self)]]),
+      worker(GenEvent, [[name: out(self())]]),
+      worker(Gald.Controller, [self(), config, [name: controller(self())]]),
+      worker(Gald.Players, [self(), [name: players(self())]]),
+      worker(Gald.Rng, [%{module: config.rng, config: config.rng_config}, [name: rng(self())]]),
+      worker(Gald.Display, [%{race: self()}, [name: display(self())]]),
+      worker(Gald.Monsters, [nil, [name: monsters(self())]]),
       # Other children started dynamically.
     ]
 

Diff for: apps/gald/lib/gald/round.ex

@@ -20,7 +20,7 @@ defmodule Gald.Round do
 
   # Server
   def init(d%{turn_order, race}) do
-    GenServer.cast(self, :next)
+    GenServer.cast(self(), :next)
 
     {:ok, %{
       new_turn_order: turn_order,
@@ -56,7 +56,7 @@ defmodule Gald.Round do
     Gald.Race.delete_turn(race)
 
     if !Gald.Victory.check(victory(race)) do
-      GenServer.cast(self, :next)
+      GenServer.cast(self(), :next)
     end
 
     {:noreply, %{state | turn: nil, turn_player: nil}}