Players can have items and see what those items are.

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

Author: Havvy

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

@@ -3,11 +3,13 @@ defmodule Gald.Player.Controller do
   You should never call the functions on this module directly - instead, use the proper functions on Gald.Player.
   """
 
+  #TODO(Havvy): Remove dependence upon Gald.Race
+
   use GenServer
   import Destructure
   require Logger
   alias Gald.{Race, Player}
-  alias Gald.Player.Stats
+  alias Gald.Player.{Inventory, Stats}
 
   @typep state :: %{
     required(:race) => Race.t,
@@ -28,8 +30,12 @@ defmodule Gald.Player.Controller do
   end
 
   def handle_cast(:emit_stats, state = d%{player}) do
-    Stats.emit(Player.stats(player), Player.output(player))
+    stats = Stats.display_info(Player.stats(player))
+    inventory = Inventory.display_info(Player.inventory(player))
+
+    display_info = Map.put(stats, :inventory, inventory)
 
+    GenEvent.notify(Player.output(player), {:stats, display_info})
     {:noreply, state}
   end
 
@@ -38,6 +44,11 @@ defmodule Gald.Player.Controller do
     {:noreply, state}
   end
 
+  def handle_cast({:put_usable, usable}, state = d%{player}) do
+    Player.Inventory.put_usable(Player.inventory(player), usable)
+    {:noreply, state}
+  end
+
   def handle_call(:name, _from, state) do
     {:reply, state.name, state}
   end

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

@@ -0,0 +1,35 @@
+defmodule Gald.Player.Inventory do
+  @moduledoc false
+  
+  use GenServer
+
+  def start_link(state, opts) do
+    GenServer.start_link(__MODULE__, state, opts)
+  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)
+  end
+
+  def init(_opts) do
+    {:ok, []}
+  end
+
+  def handle_call(:display_info, _from, inventory) do
+    reply = inventory
+    |> Enum.map(&Gald.Usable.name/1)
+    |> Enum.reverse()
+
+    {:reply, reply, inventory}
+  end
+
+  def handle_cast({:put_usable, usable}, inventory) do
+    {:noreply, [usable | inventory]}
+  end
+end

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

@@ -5,9 +5,7 @@ defmodule Gald.Player do
 
   use Supervisor
   import Destructure
-  alias Gald.Player.Controller
-  alias Gald.Player.Input
-  alias Gald.Player.Stats
+  alias Gald.Player.{Controller, Input, Stats, Inventory}
   alias Gald.Race
 
   @type name :: String.t
@@ -26,6 +24,8 @@ defmodule Gald.Player do
   def output(race, player) when is_binary(player), do: who(race, player, :output)
   def stats(player) when is_pid(player), do: who(player, :stats)
   def stats(race, player) when is_binary(player), do: who(race, player, :stats)
+  def inventory(player) when is_pid(player), do: who(player, :inventory)
+  def inventory(race, player) when is_binary(player), do: who(race, player, :inventory)
 
   @spec io(Player.t) :: {Input.t, GenEvent.t}
   @doc "Returns a tuple of the player input and output."
@@ -104,15 +104,21 @@ defmodule Gald.Player do
     GenServer.call(controller(player), :on_turn_start)
   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
+
   # Server
   def init(d%{race, name}) do
-    base_args = %{race: 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)]])
     ]
 
     supervise(children, [strategy: :one_for_all, max_restarts: 0])

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

@@ -13,6 +13,8 @@ defmodule Gald.Player.Stats do
   that implement a protocol or behaviour. Probably a protocol...
   """
 
+  # TODO(Havvy): Move status effects out?
+
   import Destructure
   alias Gald.Status
   alias Gald.Status.List, as: StatusEffects
@@ -67,10 +69,12 @@ defmodule Gald.Player.Stats do
     Agent.start_link(fn -> %Gald.Player.Stats{} end, otp_opts)
   end
 
-  @spec emit(Agent.agent, GenEvent.manager) :: :ok
-  def emit(stats, event_emitter) do
-    stats = Agent.get(stats, &(&1))
-    GenEvent.notify(event_emitter, {:stats, stats})
+  @spec display_info(Agent.agent) :: Map.t
+  @doc "Returns the info needed to be displayed to the player."
+  def display_info(stats) do
+    Agent.get(stats, fn (stats) ->
+      %{stats | status_effects: Enum.map(stats.status_effects, &Gald.Status.name/1)}
+    end)
   end
 
   @spec battle_card(Agent.agent) :: battle_card

Diff for: apps/gald/lib/gald/screen/test/give_item.ex

@@ -0,0 +1,62 @@
+defmodule Gald.Screen.Test.GiveItem do
+  @moduledoc """
+  Test screen (not to be used in the main game)
+
+  Let's the player choose which item they want.
+  """
+
+  use Gald.Screen
+  import Destructure
+  alias Gald.{Player}
+  alias Gald.Usable.{RedPotion}
+
+  def init(d%{player}), do: d%{player}
+
+  def get_display(_data) do
+    %StandardDisplay{
+      title: "Get Item",
+      body: "What item do you want?",
+      options: ["Red Potion"]
+    }
+  end
+
+  def handle_player_option(name, d%{player}) do
+    item = item_from_name(name)
+    Player.put_usable(player, item)
+    Player.emit_stats(player)
+    {:next, Test.GiveItemResult, %{item_name: name}}
+  end
+
+  defp item_from_name(name) do
+    case name do
+      "Red Potion" -> %RedPotion{}
+    end
+  end
+end
+
+defmodule Gald.Screen.Test.GiveItemResult do
+  @moduledoc """
+  Test screen (not to be used in the main game)
+
+  Result screen of `Gald.Screen.Test.GiveItem.
+
+  Exists as a buffer between giving the item and the
+  end of the turn, in case the tester wants to use the
+  item before the end of their current turn.
+  """
+
+  import Destructure
+  use Gald.Screen
+
+  def init(d%{player_name, item_name}) do
+    d%{player_name, item_name}
+  end
+
+  def get_display(d%{player_name, item_name}) do
+    %StandardDisplay{
+      title: "Item Given",
+      body: "#{player_name} received a '#{item_name}'.",
+      log: "#{player_name} received a '#{item_name}'."
+    }
+  end
+end

Diff for: apps/gald/lib/gald/screen/test/give_status.ex

@@ -58,8 +58,4 @@ defmodule Gald.Screen.Test.GiveStatusResult do
       log: "#{player_name} gains the '#{status}' status."
     }
   end
-
-  def handle_player_option(_option, _screen) do
-    :end_sequence
-  end
 end

Diff for: apps/gald/lib/gald/screen/test/mod.ex

@@ -0,0 +1,33 @@
+defmodule Gald.Screen.Test do
+  @moduledoc """
+  Test screen (not to be used in the main game)
+
+  This screen lets the player delegate to other Test screens.
+  """
+
+  use Gald.Screen
+
+  def init(_init_arg) do
+    nil
+  end
+
+  def handle_player_option(option, _data), do: handle_player_option(option)
+
+  defp handle_player_option("Give Item"), do: {:next, Test.GiveItem, %{}}
+  defp handle_player_option("Give Status"), do: {:next, Test.GiveStatus, %{}}
+  defp handle_player_option("Set Health"), do: {:next, Test.SetHealth, %{}}
+  defp handle_player_option("End Turn"), do: :end_sequence
+
+  def get_display(_data) do
+    %StandardDisplay{
+      title: "!!TEST!!",
+      body: "What do you want to do?",
+      options: [
+        "Give Item",
+        "Give Status",
+        "Set Health",
+        "End Turn"
+      ]
+    }
+  end
+end

Diff for: apps/gald/lib/gald/screen/test/non_event.ex

@@ -1,20 +1,16 @@
 defmodule Gald.Screen.Test.NonEvent do
-  use Gald.Screen
-
   @moduledoc """
   The screen is for testing purposes.
 
   It literally does nothing for the event phase.
   """
 
+  use Gald.Screen
+
   def init(_init_arg) do
     nil
   end
 
-  def handle_player_option(_option, _data) do
-    :end_sequence
-  end
-
   def get_display(_data) do
     %StandardDisplay{
       title: "Nothing Happened",

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

@@ -0,0 +1,8 @@
+defprotocol Gald.Usable do
+  @moduledoc """
+  Usables are things that can show up in the inventory - consumables, abilities, equipment, etc.
+  """
+
+  @spec name(Gald.Usable.t) :: String.t
+  def name(self)
+end

Diff for: apps/gald/lib/gald/usable/red_potion.ex

@@ -0,0 +1,9 @@
+defmodule Gald.Usable.RedPotion do
+  @moduledoc false
+
+  defstruct []
+
+  defimpl Gald.Usable, for: __MODULE__ do
+    def name(_self), do: "Red Potion"
+  end
+end

Diff for: apps/gald_site/web/race/lobby_channel.ex

@@ -1,16 +1,16 @@
 defmodule GaldSite.LobbyChannel do
   use Phoenix.Channel
-  import ShortMaps
+  import Destructure
 
   def join("lobby", _auth_msg, socket) do
     {:ok, %{races: GaldSite.RaceManager.all()}, socket}
   end
 
-  def broadcast_put(~m{internal_name visible_name}a) do
-    GaldSite.Endpoint.broadcast!("lobby", "public:put", ~m{internal_name visible_name}a)
+  def broadcast_put(d%{internal_name, visible_name}) do
+    GaldSite.Endpoint.broadcast!("lobby", "public:put", d%{internal_name, visible_name})
   end
 
-  def broadcast_delete(~m{internal_name}a) do
-    GaldSite.Endpoint.broadcast!("lobby", "public:delete", ~m{internal_name}a)
+  def broadcast_delete(d%{internal_name}) do
+    GaldSite.Endpoint.broadcast!("lobby", "public:delete", d%{internal_name})
   end
 end

Diff for: apps/gald_site/web/race/player_out_to_socket_handler.ex

@@ -27,10 +27,10 @@ defmodule GaldSite.PlayerOutToSocketHandler do
     {:ok, d%{socket}}
   end
 
-  defp serialize_payload(:stats, stats = d%{damage, status_effects}) do
+  # TODO(Havvy): Rename to something else.
+  defp serialize_payload(:stats, stats = d%{damage}) do
     damage = Enum.into(damage, %{})
-    status_effects = Enum.map(status_effects, &Gald.Status.name/1)
-    %{ stats | damage: damage, status_effects: status_effects }
+    %{ stats | damage: damage }
   end
   defp serialize_payload(topic, _payload), do: raise "Unknown event '#{inspect topic}'."
 end

Diff for: apps/gald_site/web/race/race_controller.ex

@@ -24,6 +24,11 @@ defmodule GaldSite.RaceController do
         manager: Gald.EventManager.Singular,
         manager_config: %{event: CrashGame.Index},
       }
+      "test" -> %Gald.Config{
+        name: visible_name,
+        manager: Gald.EventManager.Singular,
+        manager_config: %{event: Test}
+      }
     end
     Logger.debug(inspect config)
     internal_race_name = GaldSite.RaceManager.start_race(config)