v1.0a

.dockerignore

@@ -0,0 +1,8 @@
+_build/
+deps/
+.git/
+.gitignore
+Dockerfile
+README.md
+test/
+priv/static/

.gitignore

@@ -0,0 +1,5 @@
+/_build/
+/deps/
+/priv/static/
+.elixir_ls/
+.env

Dockerfile

@@ -0,0 +1,36 @@
+FROM elixir:1.14-alpine
+
+# Install build dependencies
+RUN apk add --no-cache build-base npm git python3
+
+# Install hex and rebar
+RUN mix local.hex --force && \
+    mix local.rebar --force
+
+# Set working directory
+WORKDIR /app
+
+# Copy mix files
+COPY mix.exs mix.lock ./
+
+# Install mix dependencies
+RUN mix deps.get
+
+# Copy assets
+COPY assets assets
+COPY priv priv
+COPY config config
+COPY lib lib
+
+# Compile the project
+RUN mix do compile
+
+# Build assets
+RUN cd assets && npm install && npm run deploy
+RUN mix phx.digest
+
+ENV MIX_ENV=prod
+ENV PORT=7860
+
+# Run the Phoenix app
+CMD ["mix", "phx.server"]

Plan.md

@@ -0,0 +1,27 @@
+Hexalixir/
+├── .dockerignore
+├── .gitignore
+├── Dockerfile
+├── README.md
+├── config/
+│   ├── config.exs
+│   ├── dev.exs
+│   └── prod.exs
+├── lib/
+│   ├── hexalixir/
+│   │   ├── game.ex
+│   │   └── grid.ex
+│   ├── hexalixir_web/
+│   │   ├── channels/
+│   │   │   └── game_channel.ex
+│   │   ├── controllers/
+│   │   │   └── page_controller.ex
+│   │   ├── templates/
+│   │   │   └── game.html.heex
+│   │   └── assets/
+│   │       ├── css/
+│   │       │   └── app.css
+│   │       └── js/
+│   │           └── game.js
+├── mix.exs
+└── mix.lock

assets/css/app.css

@@ -0,0 +1,48 @@
+defmodule HexalixirWeb.GameLive do
+  use HexalixirWeb, :live_view
+  alias Hexalixir.{Game, Grid}
+
+  @impl true
+  def mount(_params, _session, socket) do
+    {:ok, assign(socket,
+      grid: Grid.new(),
+      saved_colors: %{1 => {nil, 6}, 2 => {nil, 6}},
+      game_won: false
+    )}
+  end
+
+  @impl true
+  def handle_event("click_tile", %{"x" => x, "y" => y}, socket) do
+    coords = {String.to_integer(x), String.to_integer(y)}
+
+    case Game.click_tile(coords) do
+      {:ok, new_grid, won} ->
+        {:noreply, assign(socket, grid: new_grid, game_won: won)}
+
+      {:error, _reason} ->
+        {:noreply, socket}
+    end
+  end
+
+  @impl true
+  def handle_event("save_color", %{"color" => color, "slot" => slot}, socket) do
+    slot = String.to_integer(slot)
+    Game.save_color(color, slot)
+
+    {:noreply, socket}
+  end
+
+  @impl true
+  def handle_event("use_saved_color", %{"x" => x, "y" => y, "slot" => slot}, socket) do
+    coords = {String.to_integer(x), String.to_integer(y)}
+    slot = String.to_integer(slot)
+
+    case Game.use_saved_color(coords, slot) do
+      {:ok, new_grid, won} ->
+        {:noreply, assign(socket, grid: new_grid, game_won: won)}
+
+      {:error, _reason} ->
+        {:noreply, socket}
+    end
+  end
+end

assets/js/app.js

@@ -0,0 +1,35 @@
+import "phoenix_html"
+import {Socket} from "phoenix"
+import {LiveSocket} from "phoenix_live_view"
+
+let csrfToken = document.querySelector("meta[name='csrf-token']").getAttribute("content")
+let liveSocket = new LiveSocket("/live", Socket, {params: {_csrf_token: csrfToken}})
+
+liveSocket.connect()
+window.liveSocket = liveSocket
+```
+
+10. lib/hexalixir/application.ex:
+```elixir
+defmodule Hexalixir.Application do
+  use Application
+
+  @impl true
+  def start(_type, _args) do
+    children = [
+      HexalixirWeb.Telemetry,
+      {Phoenix.PubSub, name: Hexalixir.PubSub},
+      HexalixirWeb.Endpoint,
+      Hexalixir.Game
+    ]
+
+    opts = [strategy: :one_for_one, name: Hexalixir.Supervisor]
+    Supervisor.start_link(children, opts)
+  end
+
+  @impl true
+  def config_change(changed, _new, removed) do
+    HexalixirWeb.Endpoint.config_change(changed, removed)
+    :ok
+  end
+end

config/config.exs

@@ -0,0 +1,34 @@
+import Config
+
+config :hexalixir, HexalixirWeb.Endpoint,
+  url: [host: "localhost"],
+  render_errors: [
+    formats: [html: HexalixirWeb.ErrorHTML, json: HexalixirWeb.ErrorJSON],
+    layout: false
+  ],
+  pubsub_server: Hexalixir.PubSub,
+  live_view: [signing_salt: "YOUR_SECRET_SALT"]
+
+config :esbuild,
+  version: "0.14.41",
+  default: [
+    args: ~w(js/app.js --bundle --target=es2017 --outdir=../priv/static/assets
+    --external:/fonts/* --external:/images/*),
+    cd: Path.expand("../assets", __DIR__),
+    env: %{"NODE_PATH" => Path.expand("../deps", __DIR__)}
+  ]
+
+config :tailwind,
+  version: "3.2.4",
+  default: [
+    args: ~w(
+      --config=tailwind.config.js
+      --input=css/app.css
+      --output=../priv/static/assets/app.css
+    ),
+    cd: Path.expand("../assets", __DIR__)
+  ]
+
+config :phoenix, :json_library, Jason
+
+import_config "#{config_env()}.exs"

config/prod.exs

@@ -0,0 +1,8 @@
+import Config
+
+config :hexalixir, HexalixirWeb.Endpoint,
+  url: [host: "0.0.0.0"],
+  http: [port: 7860],
+  cache_static_manifest: "priv/static/cache_manifest.json"
+
+config :logger, level: :info

lib/hexalixir/game.ex

@@ -0,0 +1,86 @@
+defmodule Hexalixir.Game do
+  use GenServer
+  alias Hexalixir.Grid
+
+  # Client API
+
+  def start_link(_opts) do
+    GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
+  end
+
+  def click_tile(coords) do
+    GenServer.call(__MODULE__, {:click_tile, coords})
+  end
+
+  def save_color(color, slot) do
+    GenServer.call(__MODULE__, {:save_color, color, slot})
+  end
+
+  def use_saved_color(coords, slot) do
+    GenServer.call(__MODULE__, {:use_saved_color, coords, slot})
+  end
+
+  # Server Callbacks
+
+  @impl true
+  def init(:ok) do
+    {:ok, %{
+      grid: Grid.new(),
+      saved_colors: %{1 => {nil, 6}, 2 => {nil, 6}}
+    }}
+  end
+
+  @impl true
+  def handle_call({:click_tile, coords}, _from, state) do
+    if Map.get(state.grid, coords) do
+      {:reply, {:error, :tile_already_colored}, state}
+    else
+      new_grid = color_tiles([coords | Grid.get_adjacent_coords(coords)], state.grid)
+      new_state = %{state | grid: new_grid}
+
+      {:reply, {:ok, new_grid, Grid.check_win(new_grid)}, new_state}
+    end
+  end
+
+  @impl true
+  def handle_call({:save_color, color, slot}, _from, state) do
+    new_state = put_in(state.saved_colors[slot], {color, 6})
+    {:reply, :ok, new_state}
+  end
+
+  @impl true
+  def handle_call({:use_saved_color, coords, slot}, _from, state) do
+    case state.saved_colors[slot] do
+      {nil, _} ->
+        {:reply, {:error, :no_color_saved}, state}
+
+      {color, 0} ->
+        {:reply, {:error, :no_uses_left}, state}
+
+      {color, uses} ->
+        if Map.get(state.grid, coords) do
+          {:reply, {:error, :tile_already_colored}, state}
+        else
+          new_grid = Map.put(state.grid, coords, color)
+          new_state = %{state |
+            grid: new_grid,
+            saved_colors: Map.put(state.saved_colors, slot, {color, uses - 1})
+          }
+
+          {:reply, {:ok, new_grid, Grid.check_win(new_grid)}, new_state}
+        end
+    end
+  end
+
+  # Private Functions
+
+  defp color_tiles(coords, grid) do
+    Enum.reduce(coords, grid, fn coord, acc ->
+      if Map.get(acc, coord) do
+        acc
+      else
+        Map.put(acc, coord, Grid.random_color())
+      end
+    end)
+  end
+end

lib/hexalixir/grid.ex

@@ -0,0 +1,37 @@
+defmodule Hexalixir.Grid do
+  @grid_size 20
+
+  def new do
+    for x <- 0..(@grid_size - 1),
+        y <- 0..(@grid_size - 1),
+        into: %{} do
+      {{x, y}, nil}
+    end
+  end
+
+  def get_adjacent_coords({x, y}) do
+    [
+      {x + 1, y}, {x - 1, y},       # right, left
+      {x, y + 1}, {x, y - 1},       # up, down
+      {x + 1, y - 1}, {x - 1, y + 1} # diagonals
+    ]
+    |> Enum.filter(fn {x, y} ->
+      x >= 0 && x < @grid_size && y >= 0 && y < @grid_size
+    end)
+  end
+
+  def random_color do
+    ["#FF0000", "#00FF00", "#0000FF", "#FFFF00", "#FF00FF", "#00FFFF"]
+    |> Enum.random()
+  end
+
+  def check_win(grid) do
+    grid
+    |> Map.values()
+    |> Enum.reject(&is_nil/1)
+    |> case do
+      [] -> false
+      [color | rest] -> Enum.all?(rest, &(&1 == color))
+    end
+  end
+end

lib/hexalixir_web/live/game_live.ex

@@ -0,0 +1,48 @@
+defmodule HexalixirWeb.GameLive do
+  use HexalixirWeb, :live_view
+  alias Hexalixir.{Game, Grid}
+
+  @impl true
+  def mount(_params, _session, socket) do
+    {:ok, assign(socket,
+      grid: Grid.new(),
+      saved_colors: %{1 => {nil, 6}, 2 => {nil, 6}},
+      game_won: false
+    )}
+  end
+
+  @impl true
+  def handle_event("click_tile", %{"x" => x, "y" => y}, socket) do
+    coords = {String.to_integer(x), String.to_integer(y)}
+
+    case Game.click_tile(coords) do
+      {:ok, new_grid, won} ->
+        {:noreply, assign(socket, grid: new_grid, game_won: won)}
+
+      {:error, _reason} ->
+        {:noreply, socket}
+    end
+  end
+
+  @impl true
+  def handle_event("save_color", %{"color" => color, "slot" => slot}, socket) do
+    slot = String.to_integer(slot)
+    Game.save_color(color, slot)
+
+    {:noreply, socket}
+  end
+
+  @impl true
+  def handle_event("use_saved_color", %{"x" => x, "y" => y, "slot" => slot}, socket) do
+    coords = {String.to_integer(x), String.to_integer(y)}
+    slot = String.to_integer(slot)
+
+    case Game.use_saved_color(coords, slot) do
+      {:ok, new_grid, won} ->
+        {:noreply, assign(socket, grid: new_grid, game_won: won)}
+
+      {:error, _reason} ->
+        {:noreply, socket}
+    end
+  end
+end

lib/hexalixir_web/templates/game/index.html.heex

@@ -0,0 +1,48 @@
+defmodule HexalixirWeb.GameLive do
+  use HexalixirWeb, :live_view
+  alias Hexalixir.{Game, Grid}
+
+  @impl true
+  def mount(_params, _session, socket) do
+    {:ok, assign(socket,
+      grid: Grid.new(),
+      saved_colors: %{1 => {nil, 6}, 2 => {nil, 6}},
+      game_won: false
+    )}
+  end
+
+  @impl true
+  def handle_event("click_tile", %{"x" => x, "y" => y}, socket) do
+    coords = {String.to_integer(x), String.to_integer(y)}
+
+    case Game.click_tile(coords) do
+      {:ok, new_grid, won} ->
+        {:noreply, assign(socket, grid: new_grid, game_won: won)}
+
+      {:error, _reason} ->
+        {:noreply, socket}
+    end
+  end
+
+  @impl true
+  def handle_event("save_color", %{"color" => color, "slot" => slot}, socket) do
+    slot = String.to_integer(slot)
+    Game.save_color(color, slot)
+
+    {:noreply, socket}
+  end
+
+  @impl true
+  def handle_event("use_saved_color", %{"x" => x, "y" => y, "slot" => slot}, socket) do
+    coords = {String.to_integer(x), String.to_integer(y)}
+    slot = String.to_integer(slot)
+
+    case Game.use_saved_color(coords, slot) do
+      {:ok, new_grid, won} ->
+        {:noreply, assign(socket, grid: new_grid, game_won: won)}
+
+      {:error, _reason} ->
+        {:noreply, socket}
+    end
+  end
+end

mix.exs

@@ -0,0 +1,47 @@
+defmodule Hexalixir.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :hexalixir,
+      version: "0.1.0",
+      elixir: "~> 1.14",
+      elixirc_paths: elixirc_paths(Mix.env()),
+      start_permanent: Mix.env() == :prod,
+      aliases: aliases(),
+      deps: deps()
+    ]
+  end
+
+  def application do
+    [
+      mod: {Hexalixir.Application, []},
+      extra_applications: [:logger, :runtime_tools]
+    ]
+  end
+
+  defp deps do
+    [
+      {:phoenix, "~> 1.7.0"},
+      {:phoenix_html, "~> 3.3"},
+      {:phoenix_live_reload, "~> 1.4", only: :dev},
+      {:phoenix_live_view, "~> 0.18.16"},
+      {:floki, ">= 0.30.0", only: :test},
+      {:esbuild, "~> 0.5", runtime: Mix.env() == :dev},
+      {:tailwind, "~> 0.1.8", runtime: Mix.env() == :dev},
+      {:telemetry_metrics, "~> 0.6"},
+      {:telemetry_poller, "~> 1.0"},
+      {:jason, "~> 1.2"},
+      {:plug_cowboy, "~> 2.5"}
+    ]
+  end
+
+  defp aliases do
+    [
+      setup: ["deps.get", "assets.setup", "assets.build"],
+      "assets.setup": ["tailwind.install --if-missing", "esbuild.install --if-missing"],
+      "assets.build": ["tailwind default", "esbuild default"],
+      "assets.deploy": ["tailwind default --minify", "esbuild default --minify", "phx.digest"]
+    ]
+  end
+end