Fixing tick logic. Instead of having the ticker genserver send tick messages to itself, have this be handled by the EventConsumer such that it starts ticking when it receives the attach event, then continuously sends tick messages to the ticker as it receives update events. This would be problematic however if there are several systems updating the same component (the ticker would get more update messages). However, it does also fix the issue of letting a system tick 'as fast as possible' in that it ensures a complete event propagation before the next tick...

Author: sikanrong

lib/ecstatic/event_consumer.ex

@@ -52,7 +52,20 @@ defmodule Ecstatic.EventConsumer do
           w.system.process(new_entity, changes)
         opts when is_list(opts) ->
           comp = Ecstatic.Entity.find_component(new_entity, w.component)
-          Kernel.send(ticker_pid, {:start_tick, comp.id, w.system, new_entity.id, opts})
+          case w.component_lifecycle_hook do 
+            :updated ->
+              case opts[:every] do 
+                :continuous -> send(state.ticker, {:tick, comp.id, new_entity.id, w.system})
+                t when is_number(t) -> 
+                  Process.send_after(
+                    state.ticker, 
+                    {:tick, comp.id, new_entity.id, w.system}, 
+                    t
+                  )
+              end
+            :attached -> send(state.ticker, {:start_tick, comp.id, new_entity.id, w.system, opts})
+            :removed -> send(state.ticker, {:stop_tick, comp.id})
+          end
       end
     end)
 

lib/ecstatic/ticker.ex

@@ -1,7 +1,6 @@
 defmodule Ecstatic.Ticker do
   defstruct [
-    ticks: %{},
-    entity_id: nil
+    ticks: %{}
   ]
   use GenServer
 
@@ -19,43 +18,29 @@ defmodule Ecstatic.Ticker do
     Map.put(state, :ticks, new_ticks)
   end
 
-  def handle_info({:tick, c_id, system, interval} = tick_args, state) do
+  def handle_info({:tick, c_id, e_id, system}, state) do
     case Map.get(state.ticks, c_id, nil) do
       t_left 
         when t_left == :infinity 
         when (is_number(t_left) and t_left > 0) ->
 
-          {:ok, entity} = Ecstatic.Store.Ets.get_entity(state.entity_id)
+          {:ok, entity} = Ecstatic.Store.Ets.get_entity(e_id)
           system.process(entity)
 
-          case interval do 
-            ms when is_number(ms) -> Process.send_after(self(), tick_args, ms)
-            :continuous -> Kernel.send(self(), tick_args)
-          end
-
           case t_left do 
             :infinity -> {:noreply, state}
             _ -> {:noreply, update_ticks(state, c_id, (t_left - 1))}
           end
-
       0 ->
         {:noreply, update_ticks(state, c_id, :stopped)}
       :stopped -> 
         {:noreply, state}
     end
   end
 
-  def handle_info({:start_tick, c_id, system, entity_id, [every: interval, for: ticks]}, state) do
-    case Map.get(state.ticks, c_id) do 
-      ^ticks -> {:noreply, state}
-      t when t < ticks -> {:noreply, state}
-      _ -> 
-        send(self(), {:tick, c_id, system, interval})
-        new_state = state |>
-          update_ticks(c_id, ticks) |>
-          Map.put(:entity_id, entity_id)    
-        {:noreply, new_state}
-    end
+  def handle_info({:start_tick, c_id, e_id, system, [every: _interval, for: ticks]}, state) do
+    send(self(), {:tick, c_id, e_id, system})
+    {:noreply, update_ticks(state, c_id, ticks)}
   end
 
   def handle_info({:stop_tick, c_id}, state) do

lib/ecstatic/watcher.ex

@@ -32,31 +32,36 @@ defmodule Ecstatic.Watcher do
 
   defp run_ticker(system, [every: interval, for: ticks] = ticker_opts) 
     when is_tick(ticks) and is_interval(interval) do
-    attached = 
+
+    base = 
       quote location: :keep do
         component = Module.get_attribute(__MODULE__, :current_component)
         %{
           component: component,
-          component_lifecycle_hook: :attached,
           system: unquote(system),
           ticker: unquote(ticker_opts)
         }
       end
 
+    attached = 
+      quote location: :keep do
+        unquote(base) |> Map.put(:component_lifecycle_hook, :attached)
+      end
+
+    updated = 
+      quote location: :keep do
+        unquote(base) |> Map.put(:component_lifecycle_hook, :updated)
+      end
+  
     removed = 
-      quote location: :keep do 
-        component = Module.get_attribute(__MODULE__, :current_component)
-        %{
-          component: component,
-          component_lifecycle_hook: :removed,
-          system: unquote(system),
-          ticker: unquote(ticker_opts)
-        }
+      quote location: :keep do
+        unquote(base) |> Map.put(:component_lifecycle_hook, :removed)
       end
 
-    quote location: :keep, bind_quoted: [attached: attached, removed: removed] do
+    quote location: :keep, bind_quoted: [attached: attached, removed: removed, updated: updated] do
       @watchers Macro.escape(attached)
       @watchers Macro.escape(removed)
+      @watchers Macro.escape(updated)
     end
   end