[GH-580] Fake Item and Traps

apps/arena/lib/arena/entities.ex

@@ -178,8 +178,9 @@ defmodule Arena.Entities do
       is_moving: false,
       aditional_info: %{
         name: config.name,
-        pull_immunity: true,
-        effects: config.effects
+        effects: config.effects,
+        mechanics: config.mechanics,
+        pull_immunity: true
       }
     }
   end
@@ -253,6 +254,35 @@ defmodule Arena.Entities do
     }
   end
 
+  def new_trap(
+        id,
+        owner_id,
+        position,
+        config
+      ) do
+    %{
+      id: id,
+      category: :trap,
+      shape: :circle,
+      name: "Trap" <> Integer.to_string(id),
+      position: position,
+      radius: config.radius,
+      vertices: config.vertices,
+      speed: 0.0,
+      direction: %{x: 0.0, y: 0.0},
+      is_moving: false,
+      aditional_info: %{
+        name: config.name,
+        mechanics: config.mechanics,
+        preparation_delay_ms: config.preparation_delay_ms,
+        activation_delay_ms: config.activation_delay_ms,
+        owner_id: owner_id,
+        activate_on_proximity: config.activate_on_proximity,
+        status: :PENDING
+      }
+    }
+  end
+
   def make_circular_area(id, position, range) do
     %{
       id: id,

apps/arena/lib/arena/game/item.ex

@@ -0,0 +1,33 @@
+defmodule Arena.Game.Item do
+  @moduledoc """
+  Module to handle items logic
+  """
+
+  alias Arena.Entities
+
+  @doc """
+  Apply all item mechanics to an entity
+  """
+  def do_mechanics(game_state, entity, mechanics) do
+    Enum.reduce(mechanics, game_state, fn mechanic, game_state_acc ->
+      do_mechanic(game_state_acc, entity, mechanic)
+    end)
+  end
+
+  @doc """
+  Apply an item mechanic to an entity, depending on the mechanic type.
+  """
+  def do_mechanic(game_state, entity, {:spawn_bomb, bomb_params}) do
+    last_id = game_state.last_id + 1
+
+    now = System.monotonic_time(:millisecond)
+
+    new_trap =
+      Entities.new_trap(last_id, entity.id, entity.position, bomb_params)
+      |> Map.put(:prepare_at, now + bomb_params.preparation_delay_ms)
+
+    game_state
+    |> put_in([:last_id], last_id)
+    |> put_in([:traps, new_trap.id], new_trap)
+  end
+end

apps/arena/lib/arena/game/player.ex

@@ -7,6 +7,7 @@ defmodule Arena.Game.Player do
   alias Arena.Utils
   alias Arena.Game.Effect
   alias Arena.Game.Skill
+  alias Arena.Game.Item
 
   def add_action(player, action) do
     Process.send_after(self(), {:remove_skill_action, player.id, action.action}, action.duration)
@@ -277,11 +278,14 @@ defmodule Arena.Game.Player do
         game_state
 
       item ->
-        Enum.reduce(item.effects, game_state, fn effect_name, game_state_acc ->
-          effect = Enum.find(game_config.effects, fn %{name: name} -> name == effect_name end)
-          Effect.put_effect_to_entity(game_state_acc, player, player.id, effect)
-        end)
-        |> put_in([:players, player.id, :aditional_info, :inventory], nil)
+        game_state =
+          Enum.reduce(item.effects, game_state, fn effect_name, game_state_acc ->
+            effect = Enum.find(game_config.effects, fn %{name: name} -> name == effect_name end)
+            Effect.put_effect_to_entity(game_state_acc, player, player.id, effect)
+          end)
+          |> put_in([:players, player.id, :aditional_info, :inventory], nil)
+
+        Item.do_mechanics(game_state, player, item.mechanics)
     end
   end
 

apps/arena/lib/arena/game/skill.ex

@@ -399,6 +399,12 @@ defmodule Arena.Game.Skill do
        }),
        do: get_in(game_state, [:players, owner_id])
 
+  defp get_entity_player_owner(game_state, %{
+         category: :trap,
+         aditional_info: %{owner_id: owner_id}
+       }),
+       do: get_in(game_state, [:players, owner_id])
+
   defp maybe_move_player(game_state, %{category: :player} = player, move_by)
        when not is_nil(move_by) do
     player_for_moving = %{player | is_moving: true, speed: move_by}

apps/arena/lib/arena/game/trap.ex

@@ -0,0 +1,23 @@
+defmodule Arena.Game.Trap do
+  @moduledoc """
+  Module to handle traps logic
+  """
+  alias Arena.Game.Skill
+
+  @doc """
+  Apply all trap mechanics to an entity
+  """
+  def do_mechanics(game_state, entity, mechanics) do
+    Enum.reduce(mechanics, game_state, fn mechanic, game_state_acc ->
+      do_mechanic(game_state_acc, entity, mechanic)
+    end)
+  end
+
+  @doc """
+  Apply a trap mechanic to an entity, depending on the mechanic type.
+  """
+  def do_mechanic(game_state, entity, {:circle_hit, circle_hit}) do
+    # We will be using the skill mechanic here until we abstract the attacks
+    Skill.do_mechanic(game_state, entity, {:circle_hit, circle_hit}, %{})
+  end
+end

apps/arena/lib/arena/game_updater.ex

@@ -13,6 +13,7 @@ defmodule Arena.GameUpdater do
   alias Arena.Serialization.{GameEvent, GameState, GameFinished}
   alias Phoenix.PubSub
   alias Arena.Utils
+  alias Arena.Game.Trap
 
   ##########################
   # API
@@ -151,6 +152,11 @@ defmodule Arena.GameUpdater do
       # Crates
       |> handle_destroyed_crates(state.game_config)
       |> Map.put(:server_timestamp, now)
+      # Traps
+      |> remove_activated_traps()
+      |> prepare_traps()
+      |> handle_trap_collisions()
+      |> activate_trap_mechanics()
 
     broadcast_game_update(game_state)
     game_state = %{game_state | killfeed: [], damage_taken: %{}, damage_done: %{}}
@@ -490,7 +496,8 @@ defmodule Arena.GameUpdater do
              status: state.status,
              start_game_timestamp: state.start_game_timestamp,
              obstacles: complete_entities(state.obstacles),
-             crates: complete_entities(state.crates)
+             crates: complete_entities(state.crates),
+             traps: complete_entities(state.traps)
            }}
       })
 
@@ -562,6 +569,7 @@ defmodule Arena.GameUpdater do
       |> Map.put(:status, :PREPARING)
       |> Map.put(:start_game_timestamp, initial_timestamp + config.game.start_game_time_ms)
       |> Map.put(:positions, %{})
+      |> Map.put(:traps, %{})
 
     {game, _} =
       Enum.reduce(clients, {new_game, config.map.initial_positions}, fn {client_id, character_name, player_name,
@@ -670,6 +678,74 @@ defmodule Arena.GameUpdater do
     %{game_state | players: players}
   end
 
+  defp activate_trap_mechanics(game_state) do
+    now = System.monotonic_time(:millisecond)
+
+    activated_traps =
+      Enum.filter(game_state.traps, fn {_trap_id, trap} ->
+        trap_activated?(trap, now)
+      end)
+
+    Enum.reduce(activated_traps, game_state, fn {_trap_id, trap}, game_state_acc ->
+      game_state = Trap.do_mechanics(game_state_acc, trap, trap.aditional_info.mechanics)
+      trap = put_in(trap, [:aditional_info, :status], :USED)
+      update_entity_in_game_state(game_state, trap)
+    end)
+  end
+
+  defp remove_activated_traps(game_state) do
+    remaining_traps =
+      Enum.filter(game_state.traps, fn {_trap_id, trap} ->
+        trap.aditional_info.status != :USED
+      end)
+      |> Map.new()
+
+    put_in(game_state, [:traps], remaining_traps)
+  end
+
+  def handle_trap_collisions(game_state) do
+    players = game_state.players
+    traps = game_state.traps |> Enum.filter(fn {_trap_id, trap} -> trap.aditional_info.status == :PREPARED end)
+
+    Enum.reduce(players, game_state, fn {_player_id, player}, game_state_acc ->
+      Enum.reduce(traps, game_state_acc, fn {trap_id, trap}, game_state_acc ->
+        if trap_id in player.collides_with && trap.aditional_info.activate_on_proximity do
+          now = System.monotonic_time(:millisecond)
+
+          trap =
+            trap
+            |> put_in([:aditional_info, :status], :TRIGGERED)
+            |> Map.put(:activate_at, now + trap.aditional_info.activation_delay_ms)
+
+          update_entity_in_game_state(game_state_acc, trap)
+        else
+          game_state_acc
+        end
+      end)
+    end)
+  end
+
+  def prepare_traps(game_state) do
+    now = System.monotonic_time(:millisecond)
+
+    Enum.reduce(game_state.traps, game_state, fn {_trap_id, trap}, game_state_acc ->
+      if trap_ready?(trap, now) do
+        trap = put_in(trap, [:aditional_info, :status], :PREPARED)
+        update_entity_in_game_state(game_state_acc, trap)
+      else
+        game_state_acc
+      end
+    end)
+  end
+
+  defp trap_activated?(trap, now) do
+    Map.has_key?(trap, :activate_at) && trap.activate_at < now && trap.aditional_info.status == :TRIGGERED
+  end
+
+  defp trap_ready?(trap, now) do
+    trap.aditional_info.status == :PENDING && trap.prepare_at < now
+  end
+
   defp remove_effects_on_action(game_state) do
     players =
       Map.new(game_state.players, fn {player_id, player} ->
@@ -716,10 +792,12 @@ defmodule Arena.GameUpdater do
            power_ups: power_ups,
            pools: pools,
            items: items,
+           traps: traps,
            crates: crates
          } = game_state
        ) do
-    entities_to_collide = Map.merge(power_ups, pools) |> Map.merge(items) |> Map.merge(bushes) |> Map.merge(crates)
+    entities_to_collide =
+      Map.merge(power_ups, pools) |> Map.merge(items) |> Map.merge(bushes) |> Map.merge(crates) |> Map.merge(traps)
 
     moved_players =
       players
@@ -1408,6 +1486,7 @@ defmodule Arena.GameUpdater do
   defp get_entity_path(%{category: :power_up}), do: :power_ups
   defp get_entity_path(%{category: :projectile}), do: :projectiles
   defp get_entity_path(%{category: :obstacle}), do: :obstacles
+  defp get_entity_path(%{category: :trap}), do: :traps
   defp get_entity_path(%{category: :crate}), do: :crates
 
   def get_effects_from_config([], _game_config), do: []

apps/arena/lib/arena/serialization/messages.pb.ex

@@ -49,6 +49,17 @@ defmodule Arena.Serialization.PlayerActionType do
   field(:EXECUTING_SKILL_3, 5)
 end
 
+defmodule Arena.Serialization.TrapStatus do
+  @moduledoc false
+
+  use Protobuf, enum: true, syntax: :proto3, protoc_gen_elixir_version: "0.12.0"
+
+  field(:PENDING, 0)
+  field(:PREPARED, 1)
+  field(:TRIGGERED, 2)
+  field(:USED, 3)
+end
+
 defmodule Arena.Serialization.Direction do
   @moduledoc false
 
@@ -318,6 +329,15 @@ defmodule Arena.Serialization.GameState.BushesEntry do
   field(:value, 2, type: Arena.Serialization.Entity)
 end
 
+defmodule Arena.Serialization.GameState.TrapsEntry do
+  @moduledoc false
+
+  use Protobuf, map: true, syntax: :proto3, protoc_gen_elixir_version: "0.12.0"
+
+  field(:key, 1, type: :uint64)
+  field(:value, 2, type: Arena.Serialization.Entity)
+end
+
 defmodule Arena.Serialization.GameState do
   @moduledoc false
 
@@ -377,6 +397,7 @@ defmodule Arena.Serialization.GameState do
   field(:pools, 15, repeated: true, type: Arena.Serialization.GameState.PoolsEntry, map: true)
   field(:crates, 16, repeated: true, type: Arena.Serialization.GameState.CratesEntry, map: true)
   field(:bushes, 17, repeated: true, type: Arena.Serialization.GameState.BushesEntry, map: true)
+  field(:traps, 18, repeated: true, type: Arena.Serialization.GameState.TrapsEntry, map: true)
 end
 
 defmodule Arena.Serialization.Entity do
@@ -405,6 +426,7 @@ defmodule Arena.Serialization.Entity do
   field(:pool, 17, type: Arena.Serialization.Pool, oneof: 0)
   field(:crate, 18, type: Arena.Serialization.Crate, oneof: 0)
   field(:bush, 19, type: Arena.Serialization.Bush, oneof: 0)
+  field(:trap, 20, type: Arena.Serialization.Trap, oneof: 0)
 end
 
 defmodule Arena.Serialization.Player.CooldownsEntry do
@@ -512,6 +534,16 @@ defmodule Arena.Serialization.Bush do
   use Protobuf, syntax: :proto3, protoc_gen_elixir_version: "0.12.0"
 end
 
+defmodule Arena.Serialization.Trap do
+  @moduledoc false
+
+  use Protobuf, syntax: :proto3, protoc_gen_elixir_version: "0.12.0"
+
+  field(:owner_id, 1, type: :uint64, json_name: "ownerId")
+  field(:name, 2, type: :string)
+  field(:status, 3, type: Arena.Serialization.TrapStatus, enum: true)
+end
+
 defmodule Arena.Serialization.PlayerAction do
   @moduledoc false
 

apps/arena/native/physics/src/map.rs

@@ -57,6 +57,7 @@ pub enum Category {
     Item,
     Bush,
     Crate,
+    Trap,
 }
 
 impl Position {