Seeking AI behaviour

lib/entice/logic/ai/seek.ex

@@ -22,36 +22,35 @@ defmodule Entice.Logic.Seek do
     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),
+    def init(entity, _args), 
     do: {:ok, entity |> put_attribute(%Seek{})}
 
     #No introspection for npcs ;)
-    def handle_event({:movement_agent_updated,  %Position{pos: _}, moving_entity_id}, %Entity{id: my_id} = entity)
-    when moving_entity_id == my_id,
+    def handle_event({:entity_change, %{entity_id: eid}}, %Entity{id: eid} = entity),
     do: {:ok, entity}
 
-    def handle_event({:movement_agent_updated,  %Position{pos: mover_pos}, moving_entity_id}, 
-      %Entity{attributes: %{Position => %Position{pos: my_pos}, 
+    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_pos: init_pos},
+                            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_pos, mover_pos) < aggro_distance do
+          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_pos} end)}
+                         |> update_attribute(Movement, fn(m) -> %Movement{m | goal: mover_coord} end)}
           else
             {:ok, entity}
           end            
 
         ^moving_entity_id ->
-          if calc_distance(init_pos, mover_pos) >= escape_distance do
+          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_pos} end)}
+                  |> update_attribute(Movement, fn(m) -> %Movement{m | goal: init_coord} end)}
           else
             {:ok, entity
-                  |> update_attribute(Movement, fn(m) -> %Movement{m | goal: mover_pos} end)}
+                  |> update_attribute(Movement, fn(m) -> %Movement{m | goal: mover_coord} end)}
           end
 
         _ -> {:ok, entity}

lib/entice/logic/map_instance.ex

@@ -44,7 +44,6 @@ defmodule Entice.Logic.MapInstance do
     def handle_event(
         {:map_instance_player_add, player_entity},
         %Entity{attributes: %{MapInstance => %MapInstance{map: map, players: players}}} = entity) do
-      player_entity |> Entity.attribute_transaction(fn attrs -> attrs |> Map.put(MapInstance, %MapInstance{map: map}) end)
       Coordination.register(player_entity, map) # TODO change map to something else if we have multiple instances
       {:ok, entity |> update_attribute(MapInstance, fn(m) -> %MapInstance{m | players: players+1} end)}
     end
@@ -53,7 +52,6 @@ defmodule Entice.Logic.MapInstance do
         {:map_instance_npc_add, %{name: name, model: model, position: position}},
         %Entity{attributes: %{MapInstance => %MapInstance{map: map}}} = entity) do
       {:ok, eid, _pid} = Npc.spawn(name, model, position)      
-      eid |> Entity.attribute_transaction(fn attrs -> attrs |> Map.put(MapInstance, %MapInstance{map: map}) end)
       Coordination.register(eid, map) # TODO change map to something else if we have multiple instances
       {:ok, entity}
     end

lib/entice/logic/movement.ex

@@ -1,8 +1,7 @@
 defmodule Entice.Logic.Movement do
   alias Entice.Entity
-  alias Entice.Entity.Coordination
   alias Entice.Utils.Geom.Coord
-  alias Entice.Logic.{Movement, MapInstance, Player.Position}
+  alias Entice.Logic.{Movement, Player.Position}
 
 
   @doc """
@@ -29,9 +28,6 @@ defmodule Entice.Logic.Movement do
         |> Map.put(Position, new_pos)
         |> Map.put(Movement, new_movement)
       end)
-    {:ok, %MapInstance{map: map, players: _}} = Entity.fetch_attribute(entity, MapInstance)    
-    #Can't figure out how to get eid from pid
-    Coordination.notify_all(map, {:movement_agent_updated, new_pos, entity}) #TODO: Change to use eid instead of pid for self seeking guard in seek l30
   end
 
 
@@ -41,8 +37,8 @@ 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{})}

lib/entice/logic/npc.ex

@@ -4,16 +4,16 @@ defmodule Entice.Logic.Npc do
   alias Entice.Logic.{Npc, Vitals, Movement, Seek}
   alias Entice.Logic.Player.{Name, Position, Level}
 
-  defstruct npc_model_id: :dhuum, init_pos: %Position{}
+  defstruct npc_model_id: :dhuum, init_coord: %Position{}
 
 
-  def spawn(name, model, %Position{} = position, %{seeks: seeks} \\ %{seeks: true})
+  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 seeks, do: Seek.register(id)
+    if opts[:seeks] || true, do: Seek.register(id)
     {:ok, id, pid}
   end
 
@@ -24,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, init_pos: position.pos})
+      |> 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

@@ -9,9 +9,8 @@ defmodule Entice.Logic.Player do
   defmodule Name, do: defstruct(
     name: "Unknown Entity")
 
-  #TODO: rename :pos to :coord ? Confusing sometimes
   defmodule Position, do: defstruct(
-    pos: %Coord{},
+    coord: %Coord{},
     plane: 1)
 
   defmodule Appearance, do: defstruct(
@@ -32,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

@@ -6,69 +6,90 @@ defmodule Entice.Logic.SeekTest do
   alias Entice.Logic.{Player, Seek}
   alias Entice.Logic.Player.Position
   alias Entice.Entity.Coordination
+  use Entice.Logic.Map
 
+  defmap TestMap
 
   setup do
-    {:ok, npc_eid, npc_pid} = Npc.spawn("Dhuum", :dhuum, %Position{pos: %Coord{x: 10, y: 10}})
+    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
-    Player.register(player_pid, HeroesAscent)
-    {:ok, [npc_entity: npc_pid, npc_eid: npc_eid, player_eid: player_eid, player_entity: player_pid]}
+    #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, npc_eid: eid} do
-    Coordination.notify(pid, {:movement_agent_updated, %Position{pos: %Coord{x: 1, y: 2}}, eid})
+  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} do
+  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_pos = %Coord{x: 14, y: 10}
-    Coordination.notify(npc_pid, {:movement_agent_updated, %Position{pos: mover_pos}, player_eid})
+    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_pos}} = Entity.fetch_attribute(npc_pid, Movement)
+    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_eid: player_eid} do
-    Coordination.notify(npc_pid, {:movement_agent_updated, %Position{pos: %Coord{x: 19, y: 15}}, player_eid})
+  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
-    {:ok, unknown_eid, _} = Entity.start
+    #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)
 
-    Coordination.notify(npc_pid, {:movement_agent_updated, %Position{pos: %Coord{x: 11, y: 11}}, unknown_eid})
+    #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} do
-    init_pos = %Coord{x: 10, y: 10}
-
+  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})
 
-    #Notify of new position outside escape range (dist = 20.6 > 20)
-    Coordination.notify(npc_pid, {:movement_agent_updated, %Position{pos: %Coord{x: 30, y: 15}}, player_eid})
+    #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: ^init_pos}} = Entity.fetch_attribute(npc_pid, Movement)
+    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} do
+  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})
 
-    #Notify of new position outside escape range (dist = 20.6 > 20)
-    new_player_pos = %Coord{x: 14, y: 15}
-    Coordination.notify(npc_pid, {:movement_agent_updated, %Position{pos: new_player_pos}, player_eid})
+    #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_pos}} = Entity.fetch_attribute(npc_pid, Movement)
+    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

@@ -1,13 +1,10 @@
 defmodule Entice.Logic.MovementTest do
   use ExUnit.Case, async: true
   alias Entice.Entity
-  alias Entice.Entity.Coordination
   alias Entice.Utils.Geom.Coord
-  alias Entice.Logic.{Movement, MapInstance}
+  alias Entice.Logic.Movement
   alias Entice.Logic.Player.Position
-  use Entice.Logic.Map
 
-  defmap TestMap1
 
   setup do
     {:ok, _id, pid} = Entity.start
@@ -24,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)
@@ -41,16 +38,11 @@ defmodule Entice.Logic.MovementTest do
 
 
   test "update", %{entity: pid} do
-    Entity.put_attribute(pid, %MapInstance{map: TestMap1})
-    Coordination.register_observer(self, TestMap1)
-
-    new_pos = %Position{pos: %Coord{x: 42, y: 1337}, plane: 7}
     Movement.update(pid,
-      new_pos,
+      %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)    
-    assert_receive {:movement_agent_updated, ^new_pos, ^pid} #TODO: update to use eid
+    assert {:ok, %Movement{move_type: 5}} = Entity.fetch_attribute(pid, Movement)
   end