     super(request, from, state)
   end
 
-  # Casts
-
   def handle_cast(request, state) do
     super(request, state)
   end
 
-  # Everything Else
+  def handle_info(:get_state, {_, state} = s) do
+    {:reply, state, s}
+  end
 
   def handle_info(:tick, {:cont, state}) do
     state = step(state)
-
     if State.done?(state) do
       state = State.on_done(state)
       {:noreply, {:halted, state}}

  end

  def step_back(%{hist: []} = s), do: s
  def step_back(state) do
    state
    |> prev_turn
    |> State.change()
  end

  def prev_turn(state) do
    [h|t] = state.hist
    state = put_in state.world, h
    put_in(state.hist, t)
  end

  def save_history(%{world: h} = state) do
    update_in state.hist, fn t ->
      [h |Enum.take(t, @max_history)]
    end
  end

  def apply_reducer(%{world: w, reducer: f} = state) do
    %{state| world: f.(w)}
  end

  # Private

  defp delay(state) do
    opts = state.opts
    Keyword.fetch!(opts, :delay)
  end

  defp tick(state) do
    Process.send_after(self(), :tick, delay(state))
  end

    end
  end

  def handle_info(:tick, {:halted, state}) do
    {:noreply, {:halted, state}}
  end

  def handle_info(:tick, {:suspend, state}) do
    {:noreply, {:suspend, state}}
  end

  def next(pid) do
    GenServer.call(pid, :next)
  end

  def on_change(pid), do: GenServer.call(pid, :on_change)

  def on_done(pid), do: GenServer.call(pid, :on_done)

  def on_start(pid), do: GenServer.call(pid, :on_start)

  def pause(pid) do
    GenServer.call(pid, :pause)
  end

  def prev(pid) do
    GenServer.call(pid, :prev)
  end

  def resume(pid) do
    GenServer.call(pid, :resume)
  end

  def step(state) do
