Adding a traffic jam simulation.

Author: JEG2

traffic_jam/.gitignore

@@ -0,0 +1,5 @@
+/_build
+/cover
+/deps
+erl_crash.dump
+*.ez

traffic_jam/README.md

@@ -0,0 +1,20 @@
+# TrafficJam
+
+**TODO: Add description**
+
+## Installation
+
+If [available in Hex](https://hex.pm/docs/publish), the package can be installed as:
+
+  1. Add traffic_jam to your list of dependencies in `mix.exs`:
+
+        def deps do
+          [{:traffic_jam, "~> 0.0.1"}]
+        end
+
+  2. Ensure traffic_jam is started before your application:
+
+        def application do
+          [applications: [:traffic_jam]]
+        end
+

traffic_jam/config/config.exs

@@ -0,0 +1,39 @@
+# This file is responsible for configuring your application
+# and its dependencies with the aid of the Mix.Config module.
+use Mix.Config
+
+# This configuration is loaded before any dependency and is restricted
+# to this project. If another project depends on this project, this
+# file won't be loaded nor affect the parent project. For this reason,
+# if you want to provide default values for your application for
+# 3rd-party users, it should be done in your "mix.exs" file.
+
+# You can configure for your application as:
+#
+#     config :traffic_jam, key: :value
+#
+# And access this configuration in your application as:
+#
+#     Application.get_env(:traffic_jam, :key)
+#
+# Or configure a 3rd-party app:
+#
+#     config :logger, level: :info
+#
+
+config :traffic_jam, road_width: 1_000
+config :traffic_jam, road_height: 100
+config :traffic_jam, car_width: 5
+
+config :traffic_jam, paint_delay: 100
+config :traffic_jam, car_delay: 250
+
+config :traffic_jam, cars: 50
+
+# It is also possible to import configuration files, relative to this
+# directory. For example, you can emulate configuration per environment
+# by uncommenting the line below and defining dev.exs, test.exs and such.
+# Configuration from the imported file will override the ones defined
+# here (which is why it is important to import them last).
+#
+#     import_config "#{Mix.env}.exs"

traffic_jam/lib/traffic_jam.ex

@@ -0,0 +1,30 @@
+defmodule TrafficJam do
+  use Application
+
+  # See http://elixir-lang.org/docs/stable/elixir/Application.html
+  # for more information on OTP Applications
+  def start(_type, _args) do
+    import Supervisor.Spec, warn: false
+
+    road_width = Application.fetch_env!(:traffic_jam, :road_width)
+    road_height = Application.fetch_env!(:traffic_jam, :road_height)
+    car_width = Application.fetch_env!(:traffic_jam, :car_width)
+    paint_delay = Application.fetch_env!(:traffic_jam, :paint_delay)
+    cars = Application.fetch_env!(:traffic_jam, :cars)
+
+    children = [
+      # Define workers and child supervisors to be supervised
+      supervisor(TrafficJam.CarSupervisor, [ ]),
+      worker(TrafficJam.Road, [road_width, car_width, cars]),
+      worker(
+        TrafficJam.Window,
+        [paint_delay, {road_width, road_height}, car_width]
+      )
+    ]
+
+    # See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
+    # for other strategies and supported options
+    opts = [strategy: :one_for_all, name: TrafficJam.Supervisor]
+    Supervisor.start_link(children, opts)
+  end
+end

traffic_jam/lib/traffic_jam/canvas.ex

@@ -0,0 +1,128 @@
+defmodule TrafficJam.Canvas do
+  @behaviour :wx_object
+
+  @black {0, 0, 0, 255}
+  @white {255, 255, 255, 255}
+
+  defstruct ~w[panel car_width]a
+
+  require Logger
+  require Record
+  Record.defrecordp(
+    :wx, Record.extract(:wx, from_lib: "wx/include/wx.hrl")
+  )
+  Record.defrecordp(
+    :wxPaint, Record.extract(:wxPaint, from_lib: "wx/include/wx.hrl")
+  )
+  Record.defrecordp(
+    :wxKey, Record.extract(:wxKey, from_lib: "wx/include/wx.hrl")
+  )
+
+  # Client API
+
+  def start_link(parent, car_width) do
+    :wx_object.start_link(__MODULE__, [parent, car_width], [ ])
+  end
+
+  # Server API
+
+  def init(args) do
+    :wx.batch(fn -> do_init(args) end)
+  end
+
+  def handle_call(:shutdown, _from, state = %__MODULE__{panel: panel}) do
+    :wxPanel.destroy(panel)
+    {:reply, :ok, state}
+  end
+  def handle_call(message, _from, state) do
+    Logger.debug "Unhandled call:  #{inspect message}"
+    {:reply, :ok, state}
+  end
+
+  def handle_cast(message, state) do
+    Logger.debug "Unhandled cast:  #{inspect message}"
+    {:noreply, state}
+  end
+
+  def handle_sync_event(wx(event: wxPaint()), _paint_event, state) do
+    paint(state)
+    :ok
+  end
+
+  def handle_event(
+    wx(
+      event: wxKey(
+        keyCode: key,
+        controlDown: control,
+        shiftDown: shift,
+        metaDown: meta,
+        altDown: alt
+      )
+    ),
+    state
+  ) do
+    new_state = do_key_down(key, shift, alt, control, meta, state)
+    {:noreply, new_state}
+  end
+  def handle_event(wx, state) do
+    Logger.debug "Unhandled event:  #{inspect wx}"
+    {:noreply, state}
+  end
+
+  def handle_info(info, state) do
+    Logger.debug "Unhandled info:  #{inspect info}"
+    {:noreply, state}
+  end
+
+  def code_change(_old_vsn, _state, _extra) do
+    {:error, :not_implemented}
+  end
+
+  def terminate(_reason, _state) do
+    :ok
+  end
+
+  # Helpers
+
+  defp do_init([parent, car_width]) do
+    panel = :wxPanel.new(parent)
+
+    :wxFrame.connect(panel, :paint, [:callback])
+    :wxPanel.connect(panel, :key_down)
+
+    {panel, %__MODULE__{panel: panel, car_width: car_width}}
+  end
+
+  defp do_key_down(key, shift, alt, control, meta, state) do
+    case key do
+      ?Q when not (shift or alt or control or meta) -> System.halt(0)
+      _ -> :ok
+    end
+    state
+  end
+
+  defp paint(%__MODULE__{panel: panel, car_width: car_width}) do
+    {width, height} = :wxPanel.getClientSize(panel)
+    drawing_context = :wxPaintDC.new(panel)
+
+    paint_road(drawing_context, width, height)
+    paint_cars(drawing_context, car_width)
+
+    :wxPaintDC.destroy(drawing_context)
+  end
+
+  defp paint_road(context, width, height) do
+    :wxDC.setPen(context, :wxPen.new(@black))
+    :wxDC.setBrush(context, :wxBrush.new(@black))
+    :wxDC.drawRectangle(context, {0, 0}, {width, height})
+  end
+
+  defp paint_cars(context, car_width) do
+    TrafficJam.Road.get_cars
+    |> Enum.each(fn car ->
+      :wxDC.setPen(context, :wxPen.new(@white))
+      :wxDC.setBrush(context, :wxBrush.new(@white))
+      :wxDC.drawRectangle(context, {car, 49}, {car_width, 2})
+    end)
+  end
+end

traffic_jam/lib/traffic_jam/car.ex

@@ -0,0 +1,112 @@
+defmodule TrafficJam.Car do
+  defstruct ~w[position car_width road_width speed leader]a
+
+  @max_speed 3.0
+
+  use GenServer
+  require Logger
+
+  # Client API
+
+  def start_link(position, car_width, road_width, leader) do
+    GenServer.start_link(__MODULE__, [position, car_width, road_width, leader])
+  end
+
+  def assign_leader(car, leader) do
+    GenServer.cast(car, {:assign_leader, leader})
+  end
+
+  def get_lead(pid, position) do
+    GenServer.call(pid, {:get_lead, position})
+  end
+
+  # Server API
+
+  def init([position, car_width, road_width, leader]) do
+    GenServer.cast(self, :finish_init)
+    initial_state = %__MODULE__{
+      position: position,
+      car_width: car_width,
+      road_width: road_width,
+      speed: :rand.uniform * @max_speed,
+      leader: leader
+    }
+    {:ok, initial_state}
+  end
+
+  def handle_call(
+    {:get_lead, follower_position},
+    _from,
+    state = %__MODULE__{position: position, road_width: road_width}
+  ) do
+    adjusted_position =
+      if position < follower_position, do: position + road_width, else: position
+    {:reply, adjusted_position - follower_position, state}
+  end
+  def handle_call(message, _from, state) do
+    Logger.debug "Unhandled call:  #{inspect message}"
+    {:reply, :ok, state}
+  end
+
+  def handle_cast(:finish_init, state = %__MODULE__{position: position}) do
+    TrafficJam.Road.place_car(position)
+    :timer.send_interval(333, :move)
+    {:noreply, state}
+  end
+  def handle_cast({:assign_leader, leader}, state) do
+    {:noreply, %__MODULE__{state | leader: leader}}
+  end
+  def handle_cast(message, state) do
+    Logger.debug "Unhandled cast:  #{inspect message}"
+    {:noreply, state}
+  end
+
+  def handle_info(
+    :move,
+    state = %__MODULE__{
+      position: position,
+      car_width: car_width,
+      road_width: road_width,
+      speed: speed,
+      leader: leader
+    }
+  ) do
+    new_speed = adjust_speed(position, car_width, speed, leader)
+    new_position = move(position, road_width, new_speed)
+    update_position(position, new_position)
+    {:noreply, %__MODULE__{state | position: new_position}}
+  end
+  def handle_info(message, state) do
+    Logger.debug "Unhandled info:  #{inspect message}"
+    {:noreply, state}
+  end
+
+  # Helpers
+
+  defp adjust_speed(position, car_width, speed, leader) do
+    bumped = speed + 0.5
+    current_max =
+      case TrafficJam.Car.get_lead(leader, position) do
+        distance when distance < car_width + 1 + @max_speed ->
+          Enum.max([0, distance - (car_width + 1)])
+        _distance ->
+          @max_speed
+      end
+    if bumped > current_max, do: current_max, else: bumped
+  end
+
+  defp move(position, road_width, speed) do
+    case position + speed do
+      new_position when new_position >= road_width -> new_position
+      new_position -> new_position
+    end
+  end
+
+  defp update_position(old_position, new_position) do
+    trunced_old_position = trunc(old_position)
+    trunced_new_position = trunc(new_position)
+    if trunced_old_position != trunced_new_position do
+      TrafficJam.Road.move_car(trunced_old_position, trunced_new_position)
+    end
+  end
+end

traffic_jam/lib/traffic_jam/car_supervisor.ex

@@ -0,0 +1,15 @@
+defmodule TrafficJam.CarSupervisor do
+  def start_link do
+    import Supervisor.Spec
+
+    children = [
+      worker(TrafficJam.Car, [ ], restart: :transient)
+    ]
+
+    Supervisor.start_link(
+      children,
+      strategy: :simple_one_for_one,
+      name: __MODULE__
+    )
+  end
+end