prevent stage from having multiple simultaneous straight segments

lib/group_b/components/stage_note.ex

@@ -1,65 +0,0 @@
-defmodule GroupB.StageNote do
-  require Logger
-
-  alias GroupB.Components.StageNote, as: StageNoteC
-
-  def print_stage_notes(player) do
-    notes = get_stage_notes(player)
-    Logger.info("Set up player #{player}, some notes:")
-
-    for note <- notes do
-      # Logger.info("#{inspect(note, pretty: true)}")
-      Logger.info(gen_pace_note(note))
-    end
-  end
-
-  def gen_pace_note(%{max_speed: 10, type: :left}), do: "flat left"
-  def gen_pace_note(%{max_speed: 10, type: :right}), do: "flat right"
-  def gen_pace_note(%{type: :right} = note), do: "#{maybe_to_int(note[:max_speed])} right"
-  def gen_pace_note(%{type: :left} = note), do: "#{maybe_to_int(note[:max_speed])} left"
-
-  def gen_pace_note(%{type: :straight} = note) do
-    cond do
-      note[:distance] <= 10 ->
-        "and short"
-
-      note[:distance] <= 20 ->
-        "into"
-
-      true ->
-        "#{maybe_to_int(note[:distance])}"
-    end
-  end
-
-  def gen_pace_note(%{type: :esses, req_focus: focus} = note) do
-    if focus > 5 do
-      "caution, winding"
-    else
-      "winding"
-    end
-  end
-
-  @doc "Get an ordered list of stage notes for a given player entity"
-  def get_stage_notes(player) do
-    stages = StageNoteC.Player.search(player)
-
-    unsorted =
-      for stage_id <- stages do
-        %{
-          idx: StageNoteC.OrderIndex.get_one(stage_id),
-          type: StageNoteC.Type.get_one(stage_id),
-          active: StageNoteC.Active.exists?(stage_id),
-          max_speed: StageNoteC.MaxSpeed.get_one(stage_id, 0),
-          distance: StageNoteC.Distance.get_one(stage_id, 0),
-          req_focus: StageNoteC.RequiredFocus.get_one(stage_id, 0)
-        }
-      end
-
-    unsorted |> Enum.sort_by(&Map.get(&1, :idx))
-  end
-
-  def maybe_to_int(float) do
-    truncated = trunc(float)
-    if truncated == float, do: truncated, else: float
-  end
-end

lib/group_b/seed_data.ex

@@ -1,5 +1,19 @@
 defmodule GroupB.SeedData do
-  def one_weighted_note_type, do: GroupB.WeightedChoice.select_one(weighted_note_types())
+  def one_weighted_note_type(last_type) do
+    GroupB.WeightedChoice.select_one(
+      case last_type do
+        :straight ->
+          Enum.reject(weighted_note_types(), &reject_straights(&1))
+
+        _ ->
+          weighted_note_types()
+      end
+    )
+  end
+
+  defp reject_straights({:straight, _weight}), do: true
+  defp reject_straights({_type, _weight}), do: false
+
   def weighted_note_types, do: [straight: 10, left: 20, right: 20, esses: 5]
 
   def one_weighted_speed, do: GroupB.WeightedChoice.select_one(weighted_speeds())

lib/group_b/stage_note.ex

@@ -1,30 +1,65 @@
 defmodule GroupB.StageNote do
   require Logger
 
+  alias GroupB.Components.StageNote, as: StageNoteC
+
   def print_stage_notes(player) do
     notes = get_stage_notes(player)
     Logger.info("Set up player #{player}, some notes:")
 
     for note <- notes do
-      Logger.info("#{inspect(note, pretty: true)}")
+      # Logger.info("#{inspect(note, pretty: true)}")
+      Logger.info(gen_pace_note(note))
+    end
+  end
+
+  def gen_pace_note(%{max_speed: 10, type: :left}), do: "flat left"
+  def gen_pace_note(%{max_speed: 10, type: :right}), do: "flat right"
+  def gen_pace_note(%{type: :right} = note), do: "#{maybe_to_int(note[:max_speed])} right"
+  def gen_pace_note(%{type: :left} = note), do: "#{maybe_to_int(note[:max_speed])} left"
+
+  def gen_pace_note(%{type: :straight} = note) do
+    cond do
+      note[:distance] <= 10 ->
+        "and short"
+
+      note[:distance] <= 20 ->
+        "into"
+
+      true ->
+        "#{maybe_to_int(note[:distance])}"
+    end
+  end
+
+  def gen_pace_note(%{type: :esses, req_focus: focus} = note) do
+    if focus > 5 do
+      "caution, winding"
+    else
+      "winding"
     end
   end
 
   @doc "Get an ordered list of stage notes for a given player entity"
   def get_stage_notes(player) do
-    stages = StageNote.Player.search(player)
+    stages = StageNoteC.Player.search(player)
 
     unsorted =
       for stage_id <- stages do
         %{
-          idx: StageNote.OrderIndex.get_one(stage_id),
-          type: StageNote.Type.get_one(stage_id),
-          active: StageNote.Active.exists?(stage_id),
-          max_speed: StageNote.MaxSpeed.get_one(stage_id),
-          req_focus: StageNote.RequiredFocus.get_one(stage_id)
+          idx: StageNoteC.OrderIndex.get_one(stage_id),
+          type: StageNoteC.Type.get_one(stage_id),
+          active: StageNoteC.Active.exists?(stage_id),
+          max_speed: StageNoteC.MaxSpeed.get_one(stage_id, 0),
+          distance: StageNoteC.Distance.get_one(stage_id, 0),
+          req_focus: StageNoteC.RequiredFocus.get_one(stage_id, 0)
         }
       end
 
     unsorted |> Enum.sort_by(&Map.get(&1, :idx))
   end
+
+  def maybe_to_int(float) do
+    truncated = trunc(float)
+    if truncated == float, do: truncated, else: float
+  end
 end

lib/group_b/systems/client_event_handler.ex

@@ -9,6 +9,8 @@ defmodule GroupB.Systems.ClientEventHandler do
 
   require Logger
 
+  def num_stages, do: 10
+
   @impl ECSx.System
   def run do
     client_events = ECSx.ClientEvents.get_and_clear()
@@ -31,18 +33,22 @@ defmodule GroupB.Systems.ClientEventHandler do
   end
 
   defp setup_stage(player) do
-    for idx <- 1..10 do
-      setup_one_stage_note(player, idx)
-    end
+    Enum.reduce(
+      1..num_stages(),
+      {nil, :straight},
+      fn idx, {_note_id, last_type} ->
+        setup_one_stage_note(player, idx, last_type)
+      end
+    )
   end
 
-  defp setup_one_stage_note(player, idx) do
+  defp setup_one_stage_note(player, idx, last_type) do
     note_id = "#{player}/sn/#{idx}"
 
     StageNote.OrderIndex.add(note_id, idx)
     StageNote.Player.add(note_id, player)
 
-    type = GroupB.SeedData.one_weighted_note_type()
+    type = GroupB.SeedData.one_weighted_note_type(last_type)
     StageNote.Type.add(note_id, type)
 
     case type do
@@ -60,11 +66,13 @@ defmodule GroupB.Systems.ClientEventHandler do
         StageNote.MaxSpeed.add(note_id, max_speed)
         StageNote.RequiredFocus.add(note_id, 10 - max_speed)
     end
+
+    {note_id, type}
   end
 
   defp setup_actions(player) do
   end
 
-  defp process_one({_player, _event}) do
-  end
+  # defp process_one({_player, _event}) do
+  # end
 end