Seeking AI behaviour

lib/entice/logic/ai/seek.ex

@@ -0,0 +1,68 @@
+defmodule Entice.Logic.Seek do
+  alias Entice.Entity
+  alias Entice.Logic.{Seek, Player.Position, Npc, Movement}
+  alias Entice.Utils.Geom.Coord
+
+  defstruct target: nil, aggro_distance: 10, escape_distance: 20
+
+  def register(entity),
+  do: Entity.put_behaviour(entity, Seek.Behaviour, [])
+
+  def register(entity, aggro_distance, escape_distance)
+  when is_integer(aggro_distance) and is_integer(escape_distance),
+  do: Entity.put_behaviour(entity, Seek.Behaviour, %{aggro_distance: aggro_distance, escape_distance: escape_distance})
+
+  def unregister(entity),
+  do: Entity.remove_behaviour(entity, Seek.Behaviour)
+
+  #TODO: Add team attr to determine who should be attacked by whom
+  defmodule Behaviour do
+    use Entice.Entity.Behaviour
+
+    def init(entity, %{aggro_distance: aggro_distance, escape_distance: escape_distance}),
+    do: {:ok, entity |> put_attribute(%Seek{aggro_distance: aggro_distance, escape_distance: escape_distance})}
+
+    def init(entity, _args),
+    do: {:ok, entity |> put_attribute(%Seek{})}
+
+    #No introspection for npcs ;)
+    def handle_event({:entity_change, %{entity_id: eid}}, %Entity{id: eid} = entity),
+    do: {:ok, entity}
+
+    def handle_event({:entity_change, %{changed: %{Position => %Position{coord: mover_coord}}, entity_id: moving_entity_id}}, 
+      %Entity{attributes: %{Position => %Position{coord: my_coord},
+                            Movement => _,
+                            Npc      => %Npc{init_coord: init_coord},
+                            Seek     => %Seek{aggro_distance: aggro_distance, escape_distance: escape_distance, target: target}}} = entity) do
+      case target do
+        nil ->
+          if calc_distance(my_coord, mover_coord) < aggro_distance do
+            {:ok, entity |> update_attribute(Seek, fn(s) -> %Seek{s | target: moving_entity_id} end)
+                         |> update_attribute(Movement, fn(m) -> %Movement{m | goal: mover_coord} end)}
+          else
+            {:ok, entity}
+          end            
+
+        ^moving_entity_id ->
+          if calc_distance(init_coord, mover_coord) >= escape_distance do
+            {:ok, entity 
+                  |> update_attribute(Seek, fn(s) -> %Seek{s | target: nil} end)
+                  |> update_attribute(Movement, fn(m) -> %Movement{m | goal: init_coord} end)}
+          else
+            {:ok, entity
+                  |> update_attribute(Movement, fn(m) -> %Movement{m | goal: mover_coord} end)}
+          end
+
+        _ -> {:ok, entity}
+      end 
+    end
+
+    def terminate(_reason, entity),
+    do: {:ok, entity |> remove_attribute(Seek)}
+
+    #TODO: Should probably move to Coord in Utils
+    defp calc_distance(%Coord{x: x1, y: y1}, %Coord{x: x2, y: y2}) do
+      :math.sqrt(:math.pow((x2-x1), 2) + :math.pow((y2-y1), 2))
+    end
+  end
+end

lib/entice/logic/movement.ex

@@ -8,7 +8,7 @@ defmodule Entice.Logic.Movement do
   Note that velocity is actually a coefficient for the real velocity thats used inside
   the client, but for simplicities sake we used velocity as a name.
   """
-  defstruct goal: %Coord{}, plane: 1, move_type: 9, velocity: 1.0
+  defstruct goal: %Coord{}, plane: 1, move_type: 9, velocity: 1.0, update_self: false, update_delay: 1
 
 
   def register(entity),
@@ -37,14 +37,28 @@ defmodule Entice.Logic.Movement do
     def init(%Entity{attributes: %{Movement => _}} = entity, _args),
     do: {:ok, entity}
 
-    def init(%Entity{attributes: %{Position => %Position{pos: pos, plane: plane}}} = entity, _args),
-    do: {:ok, entity |> put_attribute(%Movement{goal: pos, plane: plane})}
+    def init(%Entity{attributes: %{Position => %Position{coord: coord, plane: plane}}} = entity, _args),
+    do: {:ok, entity |> put_attribute(%Movement{goal: coord, plane: plane})}
 
     def init(entity, _args),
     do: {:ok, entity |> put_attribute(%Movement{})}
 
+    def handle_event({:movement_calculate_next},
+      %Entity{attributes: %{Movement => %Movement{update_self: update_self, update_delay: update_delay}}} = _entity) do
+      #TODO: implement once the whole collision business is handled
+      if update_self, do: start_update_trigger_timer(:movement_calculate_next, update_delay)
+    end
 
     def terminate(_reason, entity),
     do: {:ok, entity |> remove_attribute(Movement)}
+
+    defp start_update_trigger_timer(message, time) do
+      if time == 0 do
+        self |> send(message)
+        nil
+      else
+        self |> Process.send_after(message, time)
+      end
+    end
   end
 end

lib/entice/logic/npc.ex

@@ -1,18 +1,19 @@
 defmodule Entice.Logic.Npc do
   use Entice.Logic.Map
   alias Entice.Entity
-  alias Entice.Logic.{Npc, Vitals}
+  alias Entice.Logic.{Npc, Vitals, Movement, Seek}
   alias Entice.Logic.Player.{Name, Position, Level}
 
+  defstruct npc_model_id: :dhuum, init_coord: %Position{}
 
-  defstruct(npc_model_id: :dhuum)
 
-
-  def spawn(name, model, %Position{} = position)
+  def spawn(name, model, %Position{} = position, opts \\ [])
   when is_binary(name) and is_atom(model) do
     {:ok, id, pid} = Entity.start()
     Npc.register(id, name, model, position)
     Vitals.register(id)
+    Movement.register(id)    
+    if opts[:seeks] || true, do: Seek.register(id)
     {:ok, id, pid}
   end
 
@@ -23,7 +24,7 @@ defmodule Entice.Logic.Npc do
       attrs
       |> Map.put(Name,     %Name{name: name})
       |> Map.put(Position, position)
-      |> Map.put(Npc,      %Npc{npc_model_id: model})
+      |> Map.put(Npc,      %Npc{npc_model_id: model, init_coord: position.coord})
       |> Map.put(Level,    %Level{level: 20})
     end)
   end

lib/entice/logic/player.ex

@@ -10,7 +10,7 @@ defmodule Entice.Logic.Player do
     name: "Unknown Entity")
 
   defmodule Position, do: defstruct(
-    pos: %Coord{},
+    coord: %Coord{},
     plane: 1)
 
   defmodule Appearance, do: defstruct(
@@ -31,7 +31,7 @@ defmodule Entice.Logic.Player do
     entity |> Entity.attribute_transaction(fn (attrs) ->
       attrs
       |> Map.put(Name, %Name{name: name})
-      |> Map.put(Position, %Position{pos: map.spawn})
+      |> Map.put(Position, %Position{coord: map.spawn})
       |> Map.put(Appearance, appearance)
       |> Map.put(Level, %Level{level: 20})
     end)

test/entice/logic/ai/seek_test.exs

@@ -0,0 +1,95 @@
+defmodule Entice.Logic.SeekTest do
+  use ExUnit.Case, async: true
+  use Entice.Logic.Maps
+  use Entice.Logic.Attributes
+  alias Entice.Entity
+  alias Entice.Logic.{Player, Seek}
+  alias Entice.Logic.Player.Position
+  alias Entice.Entity.Coordination
+  use Entice.Logic.Map
+
+  defmap TestMap
+
+  setup do
+    npc_init_coord =  %Coord{x: 10, y: 10}
+    {:ok, npc_eid, npc_pid} = Npc.spawn("Dhuum", :dhuum, %Position{coord: npc_init_coord})
+    {:ok, player_eid, player_pid} = Entity.start
+    #Sets an initial pos for the player so the Position attr appears as changed and not added in the following tests
+    simulate_movement_update(player_pid, %Position{coord: %Coord{x: 1, y: 2}}, %Movement{goal: %Coord{x: 3, y: 4}})
+
+    Player.register(player_pid, TestMap)
+    Coordination.register(player_eid, TestMap)
+    Coordination.register(npc_eid, TestMap)
+    {:ok, [npc_entity: npc_pid, npc_eid: npc_eid, player_eid: player_eid, player_entity: player_pid, npc_init_coord: npc_init_coord]}
+  end
+
+  test "correct default register", %{npc_entity: pid} do
+    assert {:ok, %Seek{target: nil, aggro_distance: 10, escape_distance: 20}} = Entity.fetch_attribute(pid, Seek)
+  end
+
+  test "update same entity", %{npc_entity: pid} do
+    simulate_movement_update(pid, %Position{coord: %Coord{x: 1, y: 2}}, %Movement{goal: %Coord{x: 3, y: 4}})
+    assert {:ok, %Seek{target: nil}} = Entity.fetch_attribute(pid, Seek)
+  end
+
+  test "update no target, entity close enough to aggro", %{npc_entity: npc_pid, player_eid: player_eid, player_entity: player_pid} do
+    #Move player within 2 units of distance of npc with aggro distance of 10 (default)
+    mover_coord = %Coord{x: 14, y: 10}
+    simulate_movement_update(player_pid, %Position{coord: mover_coord}, %Movement{goal: mover_coord})
+
+
+    assert {:ok, %Seek{target: ^player_eid}} = Entity.fetch_attribute(npc_pid, Seek)
+    assert {:ok, %Movement{goal: ^mover_coord}} = Entity.fetch_attribute(npc_pid, Movement)
+  end
+
+  test "update no target, entity too far to aggro", %{npc_entity: npc_pid, player_entity: player_pid} do
+    simulate_movement_update(player_pid, %Position{coord: %Coord{x: 19, y: 15}}, %Movement{goal: %Coord{x: 0, y: 0}})
+    assert {:ok, %Seek{target: nil}} = Entity.fetch_attribute(npc_pid, Seek)
+  end
+
+  test "update has target, entity is not current target", %{npc_entity: npc_pid, player_eid: player_eid} do
+    #Set player as target
+    Entity.put_attribute(npc_pid, %Seek{target: player_eid, aggro_distance: 10, escape_distance: 20})
+
+    #Create unrelated entity at a random pos and add it to map channel
+    {:ok, other_player_eid, other_player_pid} = Entity.start
+    simulate_movement_update(other_player_pid, %Position{coord: %Coord{x: 1, y: 2}}, %Movement{goal: %Coord{x: 3, y: 4}})
+    Coordination.register(other_player_eid, TestMap)
+
+    #Move other player inside of aggro range and check that npc keeps initial target
+    simulate_movement_update(other_player_pid, %Position{coord: %Coord{x: 11, y: 11}}, %Movement{goal: %Coord{x: 0, y: 0}})
+    assert {:ok, %Seek{target: ^player_eid}} = Entity.fetch_attribute(npc_pid, Seek)
+  end
+
+  test "update has target, entity is current target, entity escapes", 
+  %{npc_entity: npc_pid, player_eid: player_eid, player_entity: player_pid, npc_init_coord: npc_init_coord} do
+    #Set player as target
+    Entity.put_attribute(npc_pid, %Seek{target: player_eid, aggro_distance: 10, escape_distance: 20})
+
+    #Move target player far enough to escape
+    simulate_movement_update(player_pid, %Position{coord: %Coord{x: 30, y: 15}}, %Movement{goal: %Coord{x: 0, y: 0}})
+    assert {:ok, %Seek{target: nil}} = Entity.fetch_attribute(npc_pid, Seek)
+    assert {:ok, %Movement{goal: ^npc_init_coord}} = Entity.fetch_attribute(npc_pid, Movement)
+  end
+
+  test "update has target, entity is current target, entity does not escape", %{npc_entity: npc_pid, player_eid: player_eid, player_entity: player_pid} do
+    #Set player as target
+    Entity.put_attribute(npc_pid, %Seek{target: player_eid, aggro_distance: 10, escape_distance: 20})
+
+    #Move target player but not far enough to escape
+    new_player_coord = %Coord{x: 14, y: 15}
+    simulate_movement_update(player_pid, %Position{coord: new_player_coord}, %Movement{goal: %Coord{x: 0, y: 0}})
+    assert {:ok, %Seek{target: ^player_eid}} = Entity.fetch_attribute(npc_pid, Seek)
+    assert {:ok, %Movement{goal: ^new_player_coord}} = Entity.fetch_attribute(npc_pid, Movement)
+  end
+
+
+  defp simulate_movement_update(entity_pid, new_coord, new_movement) do
+    entity_pid |> Entity.attribute_transaction(
+      fn attrs ->
+        attrs
+        |> Map.put(Position, new_coord)
+        |> Map.put(Movement, new_movement)
+      end)    
+  end
+end

test/entice/logic/movement_test.exs

@@ -21,7 +21,7 @@ defmodule Entice.Logic.MovementTest do
 
   test "register with position", %{entity: pid} do
     Movement.unregister(pid) # remove again, so we can add a new one
-    Entity.put_attribute(pid, %Position{pos: %Coord{x: 42, y: 1337}, plane: 7})
+    Entity.put_attribute(pid, %Position{coord: %Coord{x: 42, y: 1337}, plane: 7})
     Movement.register(pid)
     m = %Movement{goal: %Coord{x: 42, y: 1337}, plane: 7}
     assert {:ok, ^m} = Entity.fetch_attribute(pid, Movement)
@@ -39,7 +39,7 @@ defmodule Entice.Logic.MovementTest do
 
   test "update", %{entity: pid} do
     Movement.update(pid,
-      %Position{pos: %Coord{x: 42, y: 1337}, plane: 7},
+      %Position{coord: %Coord{x: 42, y: 1337}, plane: 7},
       %Movement{goal: %Coord{x: 1337, y: 42}, plane: 13, move_type: 5, velocity: 0.5})
     assert {:ok, %Position{plane: 7}} = Entity.fetch_attribute(pid, Position)
     assert {:ok, %Movement{move_type: 5}} = Entity.fetch_attribute(pid, Movement)

test/entice/logic/npc_test.exs

@@ -8,15 +8,15 @@ defmodule Entice.Logic.NpcTest do
 
 
   setup do
-    {:ok, _id, pid} = Npc.spawn("Dhuum", :dhuum, %Position{pos: %Coord{x: 1, y: 2}, plane: 3})
+    {:ok, _id, pid} = Npc.spawn("Dhuum", :dhuum, %Position{coord: %Coord{x: 1, y: 2}, plane: 3})
     {:ok, [entity: pid]}
   end
 
   test "correct spawn", %{entity: pid} do 
     assert {:ok, %Name{name: "Dhuum"}} = Entity.fetch_attribute(pid, Name)
     assert {:ok, %Npc{npc_model_id: :dhuum}} = Entity.fetch_attribute(pid, Npc)
     assert {:ok, %Level{level: 20}} = Entity.fetch_attribute(pid, Level)
-    assert {:ok, %Position{pos: %Coord{x: 1, y: 2}, plane: 3}} = Entity.fetch_attribute(pid, Position)
+    assert {:ok, %Position{coord: %Coord{x: 1, y: 2}, plane: 3}} = Entity.fetch_attribute(pid, Position)
   end
 
   test "correct unregister", %{entity: pid} do