├── apps
├── demon_spirit_game
│ ├── test
│ │ ├── test_helper.exs
│ │ ├── card_test.exs
│ │ ├── chat_supervisor_test.exs
│ │ ├── chat_server_test.exs
│ │ ├── game_win_check_test.exs
│ │ ├── game_supervisor_test.exs
│ │ ├── game_server_test.exs
│ │ └── ai_test.exs
│ ├── .formatter.exs
│ ├── lib
│ │ └── demon_spirit_game
│ │ │ ├── move.ex
│ │ │ ├── application.ex
│ │ │ ├── chat.ex
│ │ │ ├── chat_supervisor.ex
│ │ │ ├── game_supervisor.ex
│ │ │ ├── game_win_check.ex
│ │ │ ├── chat_server.ex
│ │ │ ├── game_server.ex
│ │ │ ├── ai.ex
│ │ │ └── card.ex
│ ├── README.md
│ ├── .gitignore
│ └── mix.exs
├── demon_spirit_web
│ ├── assets
│ │ ├── css
│ │ │ ├── custom-utilities.css
│ │ │ ├── custom-base-styles.css
│ │ │ ├── custom-components.css
│ │ │ ├── components
│ │ │ │ ├── alert.css
│ │ │ │ ├── form.css
│ │ │ │ ├── card.css
│ │ │ │ └── button.css
│ │ │ └── app.css
│ │ ├── .babelrc
│ │ ├── static
│ │ │ ├── favicon.ico
│ │ │ ├── sounds
│ │ │ │ └── move.mp3
│ │ │ ├── images
│ │ │ │ ├── phoenix.png
│ │ │ │ ├── example_screenshot.png
│ │ │ │ ├── black_pawn.svg
│ │ │ │ ├── white_pawn.svg
│ │ │ │ ├── white_king.svg
│ │ │ │ ├── black_king.svg
│ │ │ │ └── bg-blue3.svg
│ │ │ └── robots.txt
│ │ ├── postcss.config.js
│ │ ├── js
│ │ │ ├── hooks
│ │ │ │ ├── update_ding.js
│ │ │ │ ├── draggable_droppable.js
│ │ │ │ ├── phone_number.js
│ │ │ │ ├── draggable.js
│ │ │ │ ├── droppable.js
│ │ │ │ └── chat_scroll.js
│ │ │ ├── app.js
│ │ │ └── socket.js
│ │ ├── package.json
│ │ ├── tailwind.config.js
│ │ └── webpack.config.js
│ ├── lib
│ │ ├── demon_spirit_web
│ │ │ ├── templates
│ │ │ │ ├── page
│ │ │ │ │ └── index.html.heex
│ │ │ │ ├── game
│ │ │ │ │ ├── show
│ │ │ │ │ │ ├── timer.html.heex
│ │ │ │ │ │ ├── player.html.heex
│ │ │ │ │ │ ├── card.html.heex
│ │ │ │ │ │ ├── ready_player_column.html.heex
│ │ │ │ │ │ ├── ready.html.heex
│ │ │ │ │ │ └── board.html.heex
│ │ │ │ │ ├── live_index.html.heex
│ │ │ │ │ ├── new.html.heex
│ │ │ │ │ ├── index
│ │ │ │ │ │ ├── game_table.html.heex
│ │ │ │ │ │ └── about.html.heex
│ │ │ │ │ ├── live_show.html.leex.bak
│ │ │ │ │ └── live_show.html.heex
│ │ │ │ ├── session
│ │ │ │ │ └── new.html.heex
│ │ │ │ ├── chat
│ │ │ │ │ └── live_index.html.heex
│ │ │ │ └── layout
│ │ │ │ │ └── app.html.heex
│ │ │ ├── views
│ │ │ │ ├── page_view.ex
│ │ │ │ ├── layout_view.ex
│ │ │ │ ├── session_view.ex
│ │ │ │ ├── chat_view.ex
│ │ │ │ ├── error_view.ex
│ │ │ │ ├── card_view.ex
│ │ │ │ ├── error_helpers.ex
│ │ │ │ └── game_view.ex
│ │ │ ├── presence.ex
│ │ │ ├── controllers
│ │ │ │ ├── chat_controller.ex
│ │ │ │ ├── page_controller.ex
│ │ │ │ ├── session_controller.ex
│ │ │ │ └── game_controller.ex
│ │ │ ├── authenticator.ex
│ │ │ ├── gettext.ex
│ │ │ ├── live
│ │ │ │ ├── live_game_index.ex
│ │ │ │ ├── live_chat_index.ex
│ │ │ │ └── live_game_show.ex
│ │ │ ├── channels
│ │ │ │ └── user_socket.ex
│ │ │ ├── application.ex
│ │ │ ├── router.ex
│ │ │ ├── endpoint.ex
│ │ │ └── name_generator.ex
│ │ ├── demon_spirit_game_ui
│ │ │ ├── game_info.ex
│ │ │ ├── game_ui_options.ex
│ │ │ ├── game_ui_supervisor.ex
│ │ │ ├── game_registry.ex
│ │ │ └── game_timer.ex
│ │ └── demon_spirit_web.ex
│ ├── test
│ │ ├── test_helper.exs
│ │ ├── demon_spirit_web
│ │ │ ├── views
│ │ │ │ ├── page_view_test.exs
│ │ │ │ ├── layout_view_test.exs
│ │ │ │ └── error_view_test.exs
│ │ │ └── controllers
│ │ │ │ └── page_controller_test.exs
│ │ ├── support
│ │ │ ├── channel_case.ex
│ │ │ └── conn_case.ex
│ │ └── demon_spirit_game_ui
│ │ │ ├── game_ui_test.exs
│ │ │ ├── game_ui_supervisor_test.exs
│ │ │ └── game_registry_test.exs
│ ├── .formatter.exs
│ ├── README.md
│ ├── .gitignore
│ ├── mix.exs
│ └── priv
│ │ └── gettext
│ │ ├── en
│ │ └── LC_MESSAGES
│ │ │ └── errors.po
│ │ └── errors.pot
└── demon_spirit
│ ├── README.md
│ ├── priv
│ └── repo
│ │ ├── migrations
│ │ └── .formatter.exs
│ │ └── seeds.exs
│ ├── test
│ ├── test_helper.exs
│ └── support
│ │ └── data_case.ex
│ ├── .formatter.exs
│ ├── lib
│ ├── demon_spirit
│ │ └── application.ex
│ ├── chat_message.ex
│ ├── guest.ex
│ ├── demon_spirit.ex
│ └── metrics.ex
│ ├── .gitignore
│ └── mix.exs
├── thumbnail.png
├── screenshot.png
├── .dockerignore
├── renovate.json
├── .formatter.exs
├── test_prod.sh
├── config
├── test.exs
├── config.exs
├── releases.exs
├── prod.exs
└── dev.exs
├── next_tasks.txt
├── .gitignore
├── deprecated.txt
├── LICENSE
├── Issues.md
├── mix.exs
├── Dockerfile
├── README.md
└── .github
└── workflows
└── elixir.yaml
/apps/demon_spirit_game/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start()
2 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/css/custom-utilities.css:
--------------------------------------------------------------------------------
1 | /* */
2 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/css/custom-base-styles.css:
--------------------------------------------------------------------------------
1 | /* */
2 |
--------------------------------------------------------------------------------
/apps/demon_spirit/README.md:
--------------------------------------------------------------------------------
1 | # DemonSpirit
2 |
3 | **TODO: Add description**
4 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/templates/page/index.html.heex:
--------------------------------------------------------------------------------
1 | Index
2 |
--------------------------------------------------------------------------------
/thumbnail.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mreishus/demon_spirit_umbrella/HEAD/thumbnail.png
--------------------------------------------------------------------------------
/screenshot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mreishus/demon_spirit_umbrella/HEAD/screenshot.png
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/.babelrc:
--------------------------------------------------------------------------------
1 | {
2 | "presets": [
3 | "@babel/preset-env"
4 | ]
5 | }
6 |
--------------------------------------------------------------------------------
/apps/demon_spirit/priv/repo/migrations/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 | import_deps: [:ecto_sql],
3 | inputs: ["*.exs"]
4 | ]
5 |
--------------------------------------------------------------------------------
/apps/demon_spirit/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start()
2 | # Ecto.Adapters.SQL.Sandbox.mode(DemonSpirit.Repo, :manual)
3 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start()
2 | # Ecto.Adapters.SQL.Sandbox.mode(DemonSpirit.Repo, :manual)
3 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 | import_deps: [:phoenix],
3 | inputs: ["*.{ex,exs}", "{config,lib,test}/**/*.{ex,exs}"]
4 | ]
5 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/views/page_view.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.PageView do
2 | use DemonSpiritWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/views/layout_view.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.LayoutView do
2 | use DemonSpiritWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/views/session_view.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.SessionView do
2 | use DemonSpiritWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/apps/demon_spirit_game/.formatter.exs:
--------------------------------------------------------------------------------
1 | # Used by "mix format"
2 | [
3 | inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
4 | ]
5 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mreishus/demon_spirit_umbrella/HEAD/apps/demon_spirit_web/assets/static/favicon.ico
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/static/sounds/move.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mreishus/demon_spirit_umbrella/HEAD/apps/demon_spirit_web/assets/static/sounds/move.mp3
--------------------------------------------------------------------------------
/apps/demon_spirit_web/test/demon_spirit_web/views/page_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.PageViewTest do
2 | use DemonSpiritWeb.ConnCase, async: true
3 | end
4 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/test/demon_spirit_web/views/layout_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.LayoutViewTest do
2 | use DemonSpiritWeb.ConnCase, async: true
3 | end
4 |
--------------------------------------------------------------------------------
/.dockerignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | npm-debug.log
3 | Dockerfile*
4 | docker-compose*
5 | .dockerignore
6 | .git
7 | .gitignore
8 | README.md
9 | LICENSE
10 | .vscode
11 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/static/images/phoenix.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mreishus/demon_spirit_umbrella/HEAD/apps/demon_spirit_web/assets/static/images/phoenix.png
--------------------------------------------------------------------------------
/renovate.json:
--------------------------------------------------------------------------------
1 | {
2 | "$schema": "https://docs.renovatebot.com/renovate-schema.json",
3 | "extends": [
4 | "config:recommended",
5 | "schedule:weekends"
6 | ]
7 | }
8 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/static/images/example_screenshot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mreishus/demon_spirit_umbrella/HEAD/apps/demon_spirit_web/assets/static/images/example_screenshot.png
--------------------------------------------------------------------------------
/apps/demon_spirit/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 | import_deps: [:ecto],
3 | inputs: ["*.{ex,exs}", "priv/*/seeds.exs", "{config,lib,test}/**/*.{ex,exs}"],
4 | subdirectories: ["priv/*/migrations"]
5 | ]
6 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/css/custom-components.css:
--------------------------------------------------------------------------------
1 | @import "./components/button";
2 | @import "./components/alert";
3 | @import "./components/form";
4 | @import "./components/card";
5 |
6 |
7 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/postcss.config.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | plugins: [
3 | require("postcss-import"),
4 | require("tailwindcss"),
5 | require("autoprefixer"),
6 | ],
7 | };
8 |
--------------------------------------------------------------------------------
/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 | import_deps: [:ecto, :ecto_sql, :phoenix],
3 | subdirectories: ["apps/*"],
4 | plugins: [Phoenix.LiveView.HTMLFormatter],
5 | inputs: ["*.{heex,ex,exs}", "{config,lib,test}/**/*.{heex,ex,exs}", "priv/*/seeds.exs"]
6 | ]
7 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/static/robots.txt:
--------------------------------------------------------------------------------
1 | # See http://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
2 | #
3 | # To ban all spiders from the entire site uncomment the next two lines:
4 | # User-agent: *
5 | # Disallow: /
6 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/css/components/alert.css:
--------------------------------------------------------------------------------
1 | .alert {
2 | @apply border rounded-lg px-4 py-3;
3 | }
4 | .alert-error {
5 | @apply bg-red-100 border-red-300 text-red-700;
6 | }
7 | .alert-info {
8 | @apply bg-blue-100 border-blue-300 text-blue-700;
9 | }
10 |
--------------------------------------------------------------------------------
/test_prod.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | docker build --tag=demon-spirit:test .
3 | export SECRET_KEY_BASE="XoF7n0TfVhLJRYVNWUYqPMyW8nbDYWG7wva8ZtPTFaUrOR6D+AojVaWXJwnjdukz" # This isn't a 'real' secret
4 | docker run --publish 4000:4000 -e "SECRET_KEY_BASE=$SECRET_KEY_BASE" demon-spirit:test
5 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/test/demon_spirit_web/controllers/page_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.PageControllerTest do
2 | use DemonSpiritWeb.ConnCase
3 |
4 | test "GET /", %{conn: conn} do
5 | conn = get(conn, "/")
6 | assert html_response(conn, 302) =~ "redirected"
7 | end
8 | end
9 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/css/components/form.css:
--------------------------------------------------------------------------------
1 | .form-control {
2 | @apply bg-white border border-gray-400 rounded-lg py-1 px-2 mx-2 appearance-none leading-normal;
3 | }
4 | .form-control:focus {
5 | @apply outline-none shadow
6 | }
7 | /*
8 | w-full
9 | block
10 | focus:outline-none
11 | focus:shadow
12 | */
13 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/views/chat_view.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.ChatView do
2 | use DemonSpiritWeb, :view
3 |
4 | @doc """
5 | date_to_hms/1: Turn a DateTime into a string representing the hour and minute in UTC.
6 | """
7 | def date_to_hms(a) do
8 | DemonSpiritWeb.GameView.date_to_hms(a)
9 | end
10 | end
11 |
--------------------------------------------------------------------------------
/apps/demon_spirit_game/lib/demon_spirit_game/move.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritGame.Move do
2 | @moduledoc """
3 | Represents a move.
4 | from: {x, y} tuple of two ints: Destination coords
5 | to: {x, y} tuple of two ints: Destination coords
6 | card: Card being used to make the move
7 | """
8 | defstruct from: {}, to: {}, card: nil
9 | end
10 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/presence.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.Presence do
2 | @moduledoc """
3 | Standard implementation of Phoenix.Presence behaviour.
4 | See https://hexdocs.pm/phoenix/Phoenix.Presence.html
5 | """
6 | use Phoenix.Presence,
7 | otp_app: :demon_spirit_web,
8 | pubsub_server: DemonSpiritWeb.PubSub
9 | end
10 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/css/components/card.css:
--------------------------------------------------------------------------------
1 |
2 | .flip {
3 | transform: rotate(180deg);
4 | }
5 |
6 | td.card_cell.center {
7 | @apply bg-gray-800
8 | }
9 | .card.green td.card_cell.move {
10 | @apply bg-green-600
11 | }
12 | .card.blue td.card_cell.move {
13 | @apply bg-blue-600
14 | }
15 | .card.red td.card_cell.move {
16 | @apply bg-red-600
17 | }
18 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/templates/game/show/timer.html.heex:
--------------------------------------------------------------------------------
1 | <%= if @active do %>
2 |
3 | <%= display_ms(@timer) %>
5 | <% else %>
6 |
7 | <%= display_ms(@timer) %>
9 | <% end %>
10 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/js/hooks/update_ding.js:
--------------------------------------------------------------------------------
1 | let move_audio = new Audio();
2 | move_audio.src = "/sounds/move.mp3";
3 |
4 | let moves = 0;
5 |
6 | let UpdateDing = {
7 | updated() {
8 | let new_moves = this.el.getAttribute("data-moves");
9 | if (new_moves != moves) {
10 | moves = new_moves;
11 | move_audio.play();
12 | }
13 | }
14 | };
15 | export default UpdateDing;
16 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/js/hooks/draggable_droppable.js:
--------------------------------------------------------------------------------
1 | // This is a workaround to phx-hook only allowing one hook.
2 | import {draggableMounted} from "./draggable.js";
3 | import {droppableMounted} from "./droppable.js";
4 | let DraggableDroppable = {
5 | mounted() {
6 | draggableMounted.apply(this);
7 | droppableMounted.apply(this);
8 | }
9 | };
10 |
11 | export default DraggableDroppable;
12 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/controllers/chat_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.ChatController do
2 | use DemonSpiritWeb, :controller
3 | alias DemonSpiritWeb.{LiveChatIndex}
4 | alias Phoenix.LiveView
5 |
6 | def index(conn, _params) do
7 | LiveView.Controller.live_render(conn, LiveChatIndex,
8 | session: %{"chat_name" => "chat_controller"}
9 | )
10 | end
11 | end
12 |
--------------------------------------------------------------------------------
/apps/demon_spirit/priv/repo/seeds.exs:
--------------------------------------------------------------------------------
1 | # Script for populating the database. You can run it as:
2 | #
3 | # mix run priv/repo/seeds.exs
4 | #
5 | # Inside the script, you can read and write to any of your
6 | # repositories directly:
7 | #
8 | # DemonSpirit.Repo.insert!(%DemonSpirit.SomeSchema{})
9 | #
10 | # We recommend using the bang functions (`insert!`, `update!`
11 | # and so on) as they will fail if something goes wrong.
12 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/templates/game/show/player.html.heex:
--------------------------------------------------------------------------------
1 | <%= case @player do %>
2 | <% nil -> %>
3 | (empty)
4 | <% %DemonSpirit.Guest{} -> %>
5 | <%= @player.name %> (g)
6 | <% %{type: :computer} -> %>
7 | <%= @player.name %>
8 | <% _ -> %>
9 | Unknown
10 | <% end %>
11 |
--------------------------------------------------------------------------------
/apps/demon_spirit/lib/demon_spirit/application.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpirit.Application do
2 | # See https://hexdocs.pm/elixir/Application.html
3 | # for more information on OTP Applications
4 | @moduledoc false
5 |
6 | use Application
7 |
8 | def start(_type, _args) do
9 | # DemonSpirit.Repo # Removing DB for now -MR 9/27/19
10 | children = []
11 |
12 | Supervisor.start_link(children, strategy: :one_for_one, name: DemonSpirit.Supervisor)
13 | end
14 | end
15 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_game_ui/game_info.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.GameInfo do
2 | @moduledoc """
3 | GameInfo holds an abbreviated version of a game in progress. It's what's everyone
4 | sees a list of in the lobby. We periodically update our GameInfo struct in the GameRegistry
5 | so others in the lobby can see the state of this game (did someone sit down, etc.)
6 | """
7 | defstruct name: nil, created_at: nil, white: nil, black: nil, winner: nil, status: nil
8 | end
9 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/css/app.css:
--------------------------------------------------------------------------------
1 | /* This file is for your main application css. */
2 |
3 | /* Removed Default phoenix CSS: @import "./phoenix.css"; */
4 | /* Live View Animations - Now Removed. Not sure if needed? Check docs for replacement. */
5 |
6 | /* Tailwind + Customizations */
7 | @import "tailwindcss/base";
8 | @import "./custom-base-styles.css";
9 |
10 | @import "tailwindcss/components";
11 | @import "./custom-components.css";
12 |
13 | @import "tailwindcss/utilities";
14 | @import "./custom-utilities.css";
15 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/js/hooks/phone_number.js:
--------------------------------------------------------------------------------
1 | let PhoneNumber = {
2 | mounted() {
3 | console.log("mounted running");
4 | this.el.addEventListener("input", e => {
5 | console.log("match running");
6 | let match = this.el.value
7 | .replace(/\D/g, "")
8 | .match(/^(\d{3})(\d{3})(\d{4})$/);
9 | if (match) {
10 | console.log("trying to set");
11 | this.el.value = `${match[1]}-${match[2]}-${match[3]}`;
12 | }
13 | });
14 | }
15 | };
16 | export default PhoneNumber;
17 |
18 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/test/demon_spirit_web/views/error_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.ErrorViewTest do
2 | use DemonSpiritWeb.ConnCase, async: true
3 |
4 | # Bring render/3 and render_to_string/3 for testing custom views
5 | import Phoenix.View
6 |
7 | test "renders 404.html" do
8 | assert render_to_string(DemonSpiritWeb.ErrorView, "404.html", []) == "Not Found"
9 | end
10 |
11 | test "renders 500.html" do
12 | assert render_to_string(DemonSpiritWeb.ErrorView, "500.html", []) == "Internal Server Error"
13 | end
14 | end
15 |
--------------------------------------------------------------------------------
/config/test.exs:
--------------------------------------------------------------------------------
1 | import Config
2 |
3 | # Configure your database
4 | # config :demon_spirit, DemonSpirit.Repo,
5 | # username: "postgres",
6 | # password: "postgres",
7 | # database: "demon_spirit_test",
8 | # hostname: "localhost",
9 | # pool: Ecto.Adapters.SQL.Sandbox
10 |
11 | # We don't run a server during test. If one is required,
12 | # you can enable the server option below.
13 | config :demon_spirit_web, DemonSpiritWeb.Endpoint,
14 | http: [port: 4002],
15 | server: false
16 |
17 | # Print only warnings and errors during test
18 | config :logger, level: :warning
19 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/views/error_view.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.ErrorView do
2 | use DemonSpiritWeb, :view
3 |
4 | # If you want to customize a particular status code
5 | # for a certain format, you may uncomment below.
6 | # def render("500.html", _assigns) do
7 | # "Internal Server Error"
8 | # end
9 |
10 | # By default, Phoenix returns the status message from
11 | # the template name. For example, "404.html" becomes
12 | # "Not Found".
13 | def template_not_found(template, _assigns) do
14 | Phoenix.Controller.status_message_from_template(template)
15 | end
16 | end
17 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_game_ui/game_ui_options.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.GameUIOptions do
2 | @moduledoc """
3 | Represents selected options while creating a game.
4 | """
5 | use Ecto.Schema
6 | import Ecto.Changeset
7 |
8 | schema "gameuioptions" do
9 | # Either "computer" or "human"
10 | field(:vs, :string)
11 | field(:computer_skill, :integer)
12 | end
13 |
14 | def changeset(base, params \\ %{}) do
15 | base
16 | |> cast(params, [:vs, :computer_skill])
17 | |> validate_required([:vs])
18 | |> validate_inclusion(:vs, ~w(human computer))
19 | end
20 | end
21 |
--------------------------------------------------------------------------------
/next_tasks.txt:
--------------------------------------------------------------------------------
1 | See also README.md for larger tasks.
2 |
3 | TODO
4 | - GameRegistry tests
5 | - (Partially done) Seating system (Track people leaving game in progress)
6 | - (Partially done) Let people stand up or switch seats if the game hasn't started yet
7 | - First move / Has Game Started
8 | - Clean up: comments on all functions
9 | - Types: %Game -> t.Game() ?
10 |
11 | DONE
12 | - game controller / list: Looks at GameRegistry and lists games using liveview
13 | - Render cards better (show the moves that can be done, flip for black)
14 | - CSS Revamp
15 | - Split out GameUIServer: Create GameUI module
16 | - Board flip
17 | - AI
18 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/controllers/page_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.PageController do
2 | use DemonSpiritWeb, :controller
3 |
4 | def index(conn, _params) do
5 | case conn do
6 | %{assigns: %{current_guest: _current_guest}} ->
7 | redirect(conn, to: Routes.game_path(conn, :index))
8 |
9 | %{assigns: %{current_user: _current_user}} ->
10 | redirect(conn, to: Routes.game_path(conn, :index))
11 |
12 | _ ->
13 | conn
14 | |> put_session(:redir_to, conn.request_path)
15 | |> redirect(to: Routes.session_path(conn, :new))
16 | end
17 | end
18 | end
19 |
--------------------------------------------------------------------------------
/apps/demon_spirit/lib/chat_message.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpirit.ChatMessage do
2 | @moduledoc """
3 | Chat message.
4 | """
5 | use Ecto.Schema
6 | import Ecto.Changeset
7 |
8 | schema "chat_messages" do
9 | field(:name, :string)
10 | field(:message, :string)
11 | field(:created, :utc_datetime)
12 | # timestamps(type: :utc_datetime) # I can't seem to get these to work w/o a database
13 | end
14 |
15 | def changeset(base, params \\ %{}) do
16 | base
17 | |> cast(params, [:name, :message, :created])
18 | |> validate_required([:name, :message, :created])
19 | |> validate_length(:message, max: 256)
20 | end
21 | end
22 |
--------------------------------------------------------------------------------
/apps/demon_spirit/lib/guest.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpirit.Guest do
2 | @moduledoc """
3 | Guest represents a low-friction, ephemeral login.
4 | """
5 | use Ecto.Schema
6 | import Ecto.Changeset
7 |
8 | schema "guests" do
9 | field(:name, :string)
10 | end
11 |
12 | def changeset(base, params \\ %{}) do
13 | base
14 | |> cast(params, [:name, :id])
15 | |> validate_required([:name, :id])
16 | |> validate_length(:name, min: 3)
17 | end
18 |
19 | # Do I need an ID to prevent Name conflicts?
20 | # @primary_key {:id, :binary_id, autogenerate: false}
21 | # %DemonSpirit.Guest{name: name, id: Ecto.UUID.generate()}
22 | end
23 |
--------------------------------------------------------------------------------
/apps/demon_spirit_game/README.md:
--------------------------------------------------------------------------------
1 | # DemonSpiritGame
2 |
3 | **TODO: Add description**
4 |
5 | ## Installation
6 |
7 | If [available in Hex](https://hex.pm/docs/publish), the package can be installed
8 | by adding `demon_spirit_game` to your list of dependencies in `mix.exs`:
9 |
10 | ```elixir
11 | def deps do
12 | [
13 | {:demon_spirit_game, "~> 0.1.0"}
14 | ]
15 | end
16 | ```
17 |
18 | Documentation can be generated with [ExDoc](https://github.com/elixir-lang/ex_doc)
19 | and published on [HexDocs](https://hexdocs.pm). Once published, the docs can
20 | be found at [https://hexdocs.pm/demon_spirit_game](https://hexdocs.pm/demon_spirit_game).
21 |
22 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/js/hooks/draggable.js:
--------------------------------------------------------------------------------
1 | let Draggable = {
2 | mounted() {
3 | let pushEvent = (x, y) => this.pushEvent(x, y);
4 |
5 | this.el.addEventListener('dragstart', e => {
6 | let sx = parseInt(this.el.dataset.x, 10);
7 | let sy = parseInt(this.el.dataset.y, 10);
8 | e.dataTransfer.setData('sx', sx);
9 | e.dataTransfer.setData('sy', sy);
10 | pushEvent('drag-piece', {sx, sy});
11 | });
12 | this.el.addEventListener('dragend', e => {
13 | pushEvent('drag-end', null);
14 | });
15 | }
16 | };
17 | let m = Draggable.mounted;
18 | export { m as draggableMounted };
19 | export default Draggable;
20 |
--------------------------------------------------------------------------------
/apps/demon_spirit/.gitignore:
--------------------------------------------------------------------------------
1 | # The directory Mix will write compiled artifacts to.
2 | /_build/
3 |
4 | # If you run "mix test --cover", coverage assets end up here.
5 | /cover/
6 |
7 | # The directory Mix downloads your dependencies sources to.
8 | /deps/
9 |
10 | # Where 3rd-party dependencies like ExDoc output generated docs.
11 | /doc/
12 |
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 |
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 |
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 |
22 | # Ignore package tarball (built via "mix hex.build").
23 | demon_spirit-*.tar
24 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Vim
2 | *.swp
3 | *.swo
4 |
5 | # The directory Mix will write compiled artifacts to.
6 | /_build/
7 |
8 | # If you run "mix test --cover", coverage assets end up here.
9 | /cover/
10 |
11 | # The directory Mix downloads your dependencies sources to.
12 | /deps/
13 |
14 | # Where 3rd-party dependencies like ExDoc output generated docs.
15 | /doc/
16 |
17 | # Ignore .fetch files in case you like to edit your project deps locally.
18 | /.fetch
19 |
20 | # If the VM crashes, it generates a dump, let's ignore it too.
21 | erl_crash.dump
22 |
23 | # Also ignore archive artifacts (built via "mix archive.build").
24 | *.ez
25 |
26 | # Sobelow
27 | .sobelow
28 |
29 | # language server
30 | .elixir_ls
31 |
--------------------------------------------------------------------------------
/apps/demon_spirit_game/.gitignore:
--------------------------------------------------------------------------------
1 | # The directory Mix will write compiled artifacts to.
2 | /_build/
3 |
4 | # If you run "mix test --cover", coverage assets end up here.
5 | /cover/
6 |
7 | # The directory Mix downloads your dependencies sources to.
8 | /deps/
9 |
10 | # Where third-party dependencies like ExDoc output generated docs.
11 | /doc/
12 |
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 |
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 |
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 |
22 | # Ignore package tarball (built via "mix hex.build").
23 | demon_spirit_game-*.tar
24 |
25 |
--------------------------------------------------------------------------------
/deprecated.txt:
--------------------------------------------------------------------------------
1 | warning: DemonSpiritWeb.Endpoint.subscribe/1 is deprecated.
2 | DemonSpiritWeb.Endpoint.subscribe/2 is deprecated, please call Phoenix.PubSub
3 | directly instead lib/demon_spirit_web/live/live_game_index.ex:18:
4 | DemonSpiritWeb.LiveGameIndex.mount/3
5 |
6 | warning: DemonSpiritWeb.Endpoint.subscribe/1 is deprecated.
7 | DemonSpiritWeb.Endpoint.subscribe/2 is deprecated, please call Phoenix.PubSub
8 | directly instead lib/demon_spirit_web/live/live_chat_index.ex:16:
9 | DemonSpiritWeb.LiveChatIndex.mount/3
10 |
11 | warning: DemonSpiritWeb.Endpoint.subscribe/1 is deprecated.
12 | DemonSpiritWeb.Endpoint.subscribe/2 is deprecated, please call Phoenix.PubSub
13 | directly instead lib/demon_spirit_web/live/live_game_show.ex:18:
14 | DemonSpiritWeb.LiveGameShow.mount/3
15 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/js/hooks/droppable.js:
--------------------------------------------------------------------------------
1 | let Droppable = {
2 | mounted() {
3 |
4 | let pushEvent = (x, y) => this.pushEvent(x, y);
5 |
6 | this.el.addEventListener('dragover', function(e) {
7 | e.preventDefault();
8 | });
9 |
10 | this.el.addEventListener('drop', function(e) {
11 | // Source X, Y ( What piece was picked up)
12 | let sx = parseInt(e.dataTransfer.getData('sx'), 10);
13 | let sy = parseInt(e.dataTransfer.getData('sy'), 10);
14 |
15 | // Target X, Y (What square was dropped on)
16 | let tx = parseInt(e.target.dataset.x, 10);
17 | let ty = parseInt(e.target.dataset.y, 10);
18 | pushEvent('drop-piece', {sx, sy, tx, ty});
19 | });
20 | }
21 | };
22 | let m = Droppable.mounted;
23 | export { m as droppableMounted };
24 | export default Droppable;
25 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/README.md:
--------------------------------------------------------------------------------
1 | # DemonSpiritWeb
2 |
3 | To start your Phoenix server:
4 |
5 | * Install dependencies with `mix deps.get`
6 | * Create and migrate your database with `mix ecto.setup`
7 | * Install Node.js dependencies with `cd assets && npm install`
8 | * Start Phoenix endpoint with `mix phx.server`
9 |
10 | Now you can visit [`localhost:4000`](http://localhost:4000) from your browser.
11 |
12 | Ready to run in production? Please [check our deployment guides](https://hexdocs.pm/phoenix/deployment.html).
13 |
14 | ## Learn more
15 |
16 | * Official website: http://www.phoenixframework.org/
17 | * Guides: https://hexdocs.pm/phoenix/overview.html
18 | * Docs: https://hexdocs.pm/phoenix
19 | * Mailing list: http://groups.google.com/group/phoenix-talk
20 | * Source: https://github.com/phoenixframework/phoenix
21 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/authenticator.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.Authenticator do
2 | @moduledoc """
3 | Authenticator looks for guest or user information in the
4 | session, and moves it to "assigns" of the connection.
5 |
6 | Note: The entire Guest object is stored in the session,
7 | because it is not persisted anywhere!
8 | """
9 | import Plug.Conn
10 | def init(opts), do: opts
11 |
12 | def call(conn, _opts) do
13 | # User case (?)
14 | # user =
15 | # conn
16 | # |> get_session(:user_id)
17 | # |> case do
18 | # nil -> nil
19 | # id -> Auction.get_user(id)
20 | # end
21 | user = nil
22 | guest = conn |> get_session(:current_guest)
23 |
24 | conn
25 | |> assign(:current_user, user)
26 | |> assign(:current_guest, guest)
27 | end
28 | end
29 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/static/images/black_pawn.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/static/images/white_pawn.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/gettext.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.Gettext do
2 | @moduledoc """
3 | A module providing Internationalization with a gettext-based API.
4 |
5 | By using [Gettext](https://hexdocs.pm/gettext),
6 | your module gains a set of macros for translations, for example:
7 |
8 | import DemonSpiritWeb.Gettext
9 |
10 | # Simple translation
11 | gettext("Here is the string to translate")
12 |
13 | # Plural translation
14 | ngettext("Here is the string to translate",
15 | "Here are the strings to translate",
16 | 3)
17 |
18 | # Domain-based translation
19 | dgettext("errors", "Here is the error message to translate")
20 |
21 | See the [Gettext Docs](https://hexdocs.pm/gettext) for detailed usage.
22 | """
23 | use Gettext, otp_app: :demon_spirit_web
24 | end
25 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/templates/game/show/card.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | <%= @card.name %>
5 |
6 |
7 |
8 |
9 | <%= for i <- 0..4 do %>
10 |
11 | <%= for j <- 0..4 do %>
12 | <%
13 | x = j - 2
14 | y = (i * -1) + 2
15 | %>
16 |
17 |
18 | <% end %>
19 |
20 | <% end %>
21 |
22 |
23 |
24 |
2 |
" rounded h-32 flex flex-col justify-between py-2"}>
3 |
4 | <%= @color %>
5 |
6 |
7 | <%= render "show/player.html", player: @player %>
8 |
9 |
10 | <%= if @player != nil do %>
11 |
12 | <%= if @ready do %>
13 |
14 | Ready.
15 |
16 | <% else %>
17 |
18 | Not Ready.
19 |
20 | <% end %>
21 |
22 | <% end %>
23 |
24 |
25 |
Welcome!
2 |
3 | Please log in as a guest account.
4 |
5 |
6 | <%= form_for @guest, Routes.session_path(@conn, :create), fn f -> %>
7 | <%= label f, :name, class: "block font-semibold mb-2" %>
8 | <%= text_input f, :name, placeholder: "Name", autofocus: true, required: true, class: 'form-control ml-0' %>
9 | <%= error_tag f, :name %>
10 |
11 | <%= submit "Log In As Guest", class: "btn btn-primary" %>
12 |
13 | <% end %>
14 |
15 |
16 |
What's this site?
17 |
18 | Demon Spirit is an
19 | abstract strategy game , something like chess with different rules, a smaller board, and random starting conditions.
20 |
21 |
22 | Play against a friend or the computer AI.
23 |
24 |
25 |
2 |
3 |
4 |
New Game
5 |
6 | <%= link "Create a new game", to: Routes.game_path(@socket, :new),
7 | class: "btn btn-primary mt-4 text-xl shadow-md" %>
8 |
9 |
10 |
Current Games
11 | <%= render "index/game_table.html", socket: @socket, games: @games %>
12 |
13 |
14 | <%= render "index/about.html", socket: @socket %>
15 |
16 |
17 |
18 |
19 |
20 |
Lobby Chat
21 |
22 | <%= live_render(@socket, DemonSpiritWeb.LiveChatIndex,
23 | session: %{"chat_name" => "lobby", "guest" => @guest},
24 | id: "lobby",
25 | container: {:div, class: "h-full mt-4"}
26 | ) %>
27 |
28 |
29 |
30 |
31 |
2 |
3 |
10 |
11 |
26 |
27 |
28 | <%= form_for @chat_message, "#", [phx_submit: :message], fn f -> %>
29 | <%= text_input f, :message,
30 | placeholder: "your message..",
31 | class: "form-control mt-2 mx-0 bg-orange-200 w-full text-sm",
32 | autofocus: true
33 | %>
34 | <% end %>
35 |
36 |
4 |
5 |
13 |
--------------------------------------------------------------------------------
/mix.exs:
--------------------------------------------------------------------------------
1 | defmodule DemonSpirit.Umbrella.MixProject do
2 | use Mix.Project
3 |
4 | def project do
5 | [
6 | apps_path: "apps",
7 | start_permanent: Mix.env() == :prod,
8 | deps: deps(),
9 | version: "0.1.0",
10 | releases: [
11 | demon_spirit_umbrella: [
12 | applications: [
13 | demon_spirit_web: :permanent,
14 | demon_spirit_game: :permanent,
15 | demon_spirit: :permanent
16 | ]
17 | ]
18 | ]
19 | ]
20 | end
21 |
22 | # Dependencies can be Hex packages:
23 | #
24 | # {:mydep, "~> 0.3.0"}
25 | #
26 | # Or git/path repositories:
27 | #
28 | # {:mydep, git: "https://github.com/elixir-lang/mydep.git", tag: "0.1.0"}
29 | #
30 | # Type "mix help deps" for more examples and options.
31 | #
32 | # Dependencies listed here are available only for this project
33 | # and cannot be accessed from applications inside the apps folder
34 | defp deps do
35 | [
36 | {:ex_check, ">= 0.0.0", only: :dev, runtime: false},
37 | {:credo, "~> 1.7.0", only: [:dev, :test], runtime: false},
38 | {:dialyxir, ">= 1.0.0", only: :dev, runtime: false},
39 | # Temporarily set the manager option for this so it compiles
40 | # https://elixirforum.com/t/elixir-v1-15-0-released/56584/4?u=axelson
41 | {:ssl_verify_fun, ">= 0.0.0", manager: :rebar3, override: true}
42 | ]
43 | end
44 | end
45 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/test/demon_spirit_game_ui/game_ui_test.exs:
--------------------------------------------------------------------------------
1 | defmodule GameUiTest do
2 | use ExUnit.Case, async: true
3 | alias DemonSpiritWeb.{GameUI, GameUIOptions}
4 |
5 | describe "clarify_cancel/2" do
6 | test "current player allowed to cancel clarification" do
7 | game_name = generate_game_name()
8 | g = GameUI.new(game_name, %GameUIOptions{vs: "human"})
9 |
10 | g =
11 | %{
12 | g
13 | | white: :p1,
14 | black: :p2,
15 | selected: :selected_junk,
16 | move_dest: :move_dest_junk,
17 | moves_need_clarify: :moves_need_clarify_junk
18 | }
19 | |> GameUI.clarify_cancel(:p1)
20 |
21 | assert g.moves_need_clarify == nil
22 | assert g.selected == nil
23 | assert g.move_dest == []
24 | end
25 |
26 | test "opponent not allowed to cancel clarification" do
27 | game_name = generate_game_name()
28 | g = GameUI.new(game_name, %GameUIOptions{vs: "human"})
29 |
30 | g = %{
31 | g
32 | | white: :p1,
33 | black: :p2,
34 | selected: :selected_junk,
35 | move_dest: :move_dest_junk,
36 | moves_need_clarify: :moves_need_clarify_junk
37 | }
38 |
39 | g_new = g |> GameUI.clarify_cancel(:p2)
40 |
41 | assert g == g_new
42 | end
43 | end
44 |
45 | defp generate_game_name do
46 | "game-#{:rand.uniform(1_000_000)}"
47 | end
48 | end
49 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/static/images/black_king.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
12 |
--------------------------------------------------------------------------------
/apps/demon_spirit_game/test/chat_server_test.exs:
--------------------------------------------------------------------------------
1 | defmodule ChatServerTest do
2 | use ExUnit.Case, async: true
3 | alias DemonSpiritGame.{ChatServer}
4 |
5 | describe "start_link/1" do
6 | test "spawns a process" do
7 | chat_name = generate_chat_name()
8 |
9 | assert {:ok, _pid} = ChatServer.start_link(chat_name)
10 | end
11 |
12 | test "each name can only have one process" do
13 | chat_name = generate_chat_name()
14 |
15 | assert {:ok, _pid} = ChatServer.start_link(chat_name)
16 | assert {:error, _reason} = ChatServer.start_link(chat_name)
17 | end
18 | end
19 |
20 | describe "add_message/2 and messages/1" do
21 | test "general message persistance" do
22 | chat_name = generate_chat_name()
23 | assert {:ok, _pid} = ChatServer.start_link(chat_name)
24 |
25 | ChatServer.add_message(chat_name, "m1")
26 | ChatServer.add_message(chat_name, "m2")
27 | ChatServer.add_message(chat_name, "m3")
28 | messages = ChatServer.messages(chat_name)
29 | assert messages == ["m1", "m2", "m3"]
30 | end
31 |
32 | test "message limit 250" do
33 | chat_name = generate_chat_name()
34 | assert {:ok, _pid} = ChatServer.start_link(chat_name)
35 |
36 | 1..1000
37 | |> Enum.each(fn _ ->
38 | ChatServer.add_message(chat_name, "hi")
39 | end)
40 |
41 | messages = ChatServer.messages(chat_name)
42 | assert length(messages) == 250
43 | end
44 | end
45 |
46 | defp generate_chat_name do
47 | "chat-#{:rand.uniform(1_000_000)}"
48 | end
49 | end
50 |
--------------------------------------------------------------------------------
/apps/demon_spirit_game/lib/demon_spirit_game/game_supervisor.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritGame.GameSupervisor do
2 | @moduledoc """
3 | A supervisor that starts `GameServer` processes dynamically.
4 | """
5 |
6 | use DynamicSupervisor
7 |
8 | alias DemonSpiritGame.GameServer
9 |
10 | def start_link(_arg) do
11 | DynamicSupervisor.start_link(__MODULE__, :ok, name: __MODULE__)
12 | end
13 |
14 | def init(:ok) do
15 | DynamicSupervisor.init(strategy: :one_for_one)
16 | end
17 |
18 | @doc """
19 | Starts a `GameServer` process and supervises it.
20 | """
21 | def start_game(game_name) do
22 | child_spec = %{
23 | id: GameServer,
24 | start: {GameServer, :start_link, [game_name]},
25 | restart: :transient
26 | }
27 |
28 | DynamicSupervisor.start_child(__MODULE__, child_spec)
29 | end
30 |
31 | @doc """
32 | Starts a `GameServer` process and supervises it.
33 | Uses a hardcoded set of cards (needed for testing).
34 | """
35 | def start_game(game_name, :hardcoded_cards) do
36 | child_spec = %{
37 | id: GameServer,
38 | start: {GameServer, :start_link, [game_name, :hardcoded_cards]},
39 | restart: :transient
40 | }
41 |
42 | DynamicSupervisor.start_child(__MODULE__, child_spec)
43 | end
44 |
45 | @doc """
46 | Terminates the `GameServer` process normally. It won't be restarted.
47 | """
48 | def stop_game(game_name) do
49 | :ets.delete(:games, game_name)
50 |
51 | child_pid = GameServer.game_pid(game_name)
52 | DynamicSupervisor.terminate_child(__MODULE__, child_pid)
53 | end
54 | end
55 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/templates/game/new.html.heex:
--------------------------------------------------------------------------------
1 |
9 | New Game Options
10 | <%= form_for @conn, Routes.game_path(@conn, :create), [as: :game_opts], fn f -> %>
11 | <%= label f, "Play against human or computer?", class: "block font-semibold mt-6" %>
12 | <%= select(f, :vs, ["Human": "human", "Computer": "computer"], class: "mt-4 rounded p-1 border") %>
13 | <%= select(f, :computer_skill, [
14 | "Level 0 (Easiest)": 1,
15 | "Level 1": 10,
16 | "Level 2": 20,
17 | "Level 3": 30,
18 | "Level 4": 40,
19 | "Level 5": 50,
20 | "Level 6": 60,
21 | "Level 7": 70,
22 | "Level 8": 80,
23 | "Level 9": 90,
24 | "Level 10 (Hardest)": 100,
25 | ], class: "hidden mt-4 p-1 rounded block border") %>
26 | <%= submit "Start Game", class: "btn btn-primary mt-4 block" %>
27 | <% end %>
28 |
29 |
34 |
35 |
36 |
53 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/js/app.js:
--------------------------------------------------------------------------------
1 | // We need to import the CSS so that webpack will load it.
2 | // The MiniCssExtractPlugin is used to separate it out into
3 | // its own CSS file.
4 | import css from "../css/app.css";
5 |
6 | // webpack automatically bundles all modules in your
7 | // entry points. Those entry points can be configured
8 | // in "webpack.config.js".
9 | //
10 | // Import dependencies
11 | //
12 | import "phoenix_html";
13 |
14 | // Import local files
15 | //
16 | // Local files can be imported directly using relative paths, for example:
17 | // import socket from "./socket"
18 |
19 | import { Socket } from "phoenix";
20 |
21 | //import LiveSocket from "phoenix_live_view";
22 | import * as LiveView from "phoenix_live_view";
23 | const { LiveSocket } = LiveView;
24 |
25 | let Hooks = {};
26 |
27 | import PhoneNumber from "./hooks/phone_number";
28 | Hooks.PhoneNumber = PhoneNumber;
29 |
30 | import Draggable from "./hooks/draggable";
31 | Hooks.Draggable = Draggable;
32 |
33 | import Droppable from "./hooks/droppable";
34 | Hooks.Droppable = Droppable;
35 |
36 | import DraggableDroppable from "./hooks/draggable_droppable";
37 | Hooks.DraggableDroppable = DraggableDroppable;
38 |
39 | import UpdateDing from "./hooks/update_ding";
40 | Hooks.UpdateDing = UpdateDing;
41 |
42 | import ChatScroll from "./hooks/chat_scroll";
43 | Hooks.ChatScroll = ChatScroll;
44 |
45 | let csrfToken = document
46 | .querySelector("meta[name='csrf-token']")
47 | .getAttribute("content");
48 |
49 | let liveSocket = new LiveSocket("/live", Socket, {
50 | hooks: Hooks,
51 | params: { _csrf_token: csrfToken },
52 | });
53 | liveSocket.connect();
54 |
--------------------------------------------------------------------------------
/apps/demon_spirit/test/support/data_case.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpirit.DataCase do
2 | @moduledoc """
3 | This module defines the setup for tests requiring
4 | access to the application's data layer.
5 |
6 | You may define functions here to be used as helpers in
7 | your tests.
8 |
9 | Finally, if the test case interacts with the database,
10 | it cannot be async. For this reason, every test runs
11 | inside a transaction which is reset at the beginning
12 | of the test unless the test case is marked as async.
13 | """
14 |
15 | use ExUnit.CaseTemplate
16 |
17 | using do
18 | quote do
19 | alias DemonSpirit.Repo
20 |
21 | import Ecto
22 | import Ecto.Changeset
23 | import Ecto.Query
24 | import DemonSpirit.DataCase
25 | end
26 | end
27 |
28 | # setup tags do
29 | # # :ok = Ecto.Adapters.SQL.Sandbox.checkout(DemonSpirit.Repo)
30 |
31 | # # unless tags[:async] do
32 | # # Ecto.Adapters.SQL.Sandbox.mode(DemonSpirit.Repo, {:shared, self()})
33 | # # end
34 |
35 | # :ok
36 | # end
37 |
38 | @doc """
39 | A helper that transforms changeset errors into a map of messages.
40 |
41 | assert {:error, changeset} = Accounts.create_user(%{password: "short"})
42 | assert "password is too short" in errors_on(changeset).password
43 | assert %{password: ["password is too short"]} = errors_on(changeset)
44 |
45 | """
46 | def errors_on(changeset) do
47 | Ecto.Changeset.traverse_errors(changeset, fn {message, opts} ->
48 | Regex.replace(~r"%{(\w+)}", message, fn _, key ->
49 | opts |> Keyword.get(String.to_existing_atom(key), key) |> to_string()
50 | end)
51 | end)
52 | end
53 | end
54 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/router.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.Router do
2 | use DemonSpiritWeb, :router
3 | import Plug.BasicAuth
4 | import Phoenix.LiveDashboard.Router
5 |
6 | pipeline :browser do
7 | plug(:accepts, ["html"])
8 | plug(:fetch_session)
9 | plug(:fetch_flash)
10 | plug(:protect_from_forgery)
11 | plug(:put_secure_browser_headers)
12 | plug(DemonSpiritWeb.Authenticator)
13 | end
14 |
15 | pipeline :api do
16 | plug(:accepts, ["json"])
17 | end
18 |
19 | ## BEGIN Phoenix LiveDashboard ###
20 | scope "/" do
21 | if Mix.env() == :dev do
22 | pipe_through([:browser])
23 | else
24 | pipe_through([:browser, :dash_admins_only])
25 | end
26 |
27 | live_dashboard("/dashboard")
28 | end
29 |
30 | pipeline :dash_admins_only do
31 | # Compile_env here fixes a warning, but causes the docker build to not work
32 | # plug(:basic_auth, Application.compile_env(:demon_spirit_web, :dash_basic_auth, nil))
33 | plug(:basic_auth, Application.fetch_env!(:demon_spirit_web, :dash_basic_auth))
34 | end
35 |
36 | ## END Phoenix LiveDashboard ###
37 |
38 | scope "/", DemonSpiritWeb do
39 | pipe_through(:browser)
40 |
41 | get("/", PageController, :index)
42 |
43 | get("/game/live_test", GameController, :live_test)
44 | resources("/game", GameController, only: [:new, :create, :show, :index])
45 | resources("/session", SessionController, only: [:new, :create, :delete], singleton: true)
46 | resources("/chat", ChatController, only: [:index])
47 | end
48 |
49 | # Other scopes may use custom stacks.
50 | # scope "/api", DemonSpiritWeb do
51 | # pipe_through :api
52 | # end
53 | end
54 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/views/error_helpers.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.ErrorHelpers do
2 | @moduledoc """
3 | Conveniences for translating and building error messages.
4 | """
5 |
6 | use Phoenix.HTML
7 |
8 | @doc """
9 | Generates tag for inlined form input errors.
10 | """
11 | def error_tag(form, field) do
12 | Enum.map(Keyword.get_values(form.errors, field), fn error ->
13 | content_tag(:span, translate_error(error), class: "help-block")
14 | end)
15 | end
16 |
17 | @doc """
18 | Translates an error message using gettext.
19 | """
20 | def translate_error({msg, opts}) do
21 | # When using gettext, we typically pass the strings we want
22 | # to translate as a static argument:
23 | #
24 | # # Translate "is invalid" in the "errors" domain
25 | # dgettext("errors", "is invalid")
26 | #
27 | # # Translate the number of files with plural rules
28 | # dngettext("errors", "1 file", "%{count} files", count)
29 | #
30 | # Because the error messages we show in our forms and APIs
31 | # are defined inside Ecto, we need to translate them dynamically.
32 | # This requires us to call the Gettext module passing our gettext
33 | # backend as first argument.
34 | #
35 | # Note we use the "errors" domain, which means translations
36 | # should be written to the errors.po file. The :count option is
37 | # set by Ecto and indicates we should also apply plural rules.
38 | if count = opts[:count] do
39 | Gettext.dngettext(DemonSpiritWeb.Gettext, "errors", msg, msg, count, opts)
40 | else
41 | Gettext.dgettext(DemonSpiritWeb.Gettext, "errors", msg, opts)
42 | end
43 | end
44 | end
45 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/test/demon_spirit_game_ui/game_ui_supervisor_test.exs:
--------------------------------------------------------------------------------
1 | defmodule GameUiSupervisorTest do
2 | use ExUnit.Case, async: true
3 | doctest DemonSpiritWeb.GameUISupervisor
4 |
5 | alias DemonSpiritWeb.{GameUISupervisor, GameUIServer, GameUIOptions}
6 |
7 | defp default_options do
8 | %GameUIOptions{
9 | vs: "human"
10 | }
11 | end
12 |
13 | describe "start_game" do
14 | test "spawns a game server process" do
15 | game_name = "game-#{:rand.uniform(1000)}"
16 | assert {:ok, _pid} = GameUISupervisor.start_game(game_name, default_options())
17 |
18 | via = GameUIServer.via_tuple(game_name)
19 | assert GenServer.whereis(via) |> Process.alive?()
20 | end
21 |
22 | test "returns an error if game is already started" do
23 | game_name = "game-#{:rand.uniform(1000)}"
24 |
25 | assert {:ok, pid} = GameUISupervisor.start_game(game_name, default_options())
26 |
27 | assert {:error, {:already_started, ^pid}} =
28 | GameUISupervisor.start_game(game_name, default_options())
29 | end
30 | end
31 |
32 | describe "stop_game" do
33 | test "terminates the process normally" do
34 | game_name = "game-#{:rand.uniform(1000)}"
35 | {:ok, _pid} = GameUISupervisor.start_game(game_name, default_options())
36 | via = GameUIServer.via_tuple(game_name)
37 |
38 | assert :ok = GameUISupervisor.stop_game(game_name)
39 | refute GenServer.whereis(via)
40 | end
41 | end
42 |
43 | # describe "ets preservation of crashed processes" do
44 | # test "supervised game gets restarted and retains status after crashing" do
45 | #
46 | # .... GameUISupervisor / GameUIServer does not currently do this .....
47 | #
48 | # end
49 | # end
50 | end
51 |
--------------------------------------------------------------------------------
/config/config.exs:
--------------------------------------------------------------------------------
1 | # This file is responsible for configuring your umbrella
2 | # and **all applications** and their dependencies with the
3 | # help of Mix.Config.
4 | #
5 | # Note that all applications in your umbrella share the
6 | # same configuration and dependencies, which is why they
7 | # all use the same configuration file. If you want different
8 | # configurations or dependencies per app, it is best to
9 | # move said applications out of the umbrella.
10 | import Config
11 |
12 | config :demon_spirit, env: Mix.env()
13 |
14 | # Configure Mix tasks and generators
15 | config :demon_spirit,
16 | ecto_repos: [DemonSpirit.Repo]
17 |
18 | config :demon_spirit_web,
19 | ecto_repos: [DemonSpirit.Repo],
20 | generators: [context_app: :demon_spirit]
21 |
22 | # Configures the endpoint
23 | config :demon_spirit_web, DemonSpiritWeb.Endpoint,
24 | url: [host: "localhost"],
25 | secret_key_base: "V2POCUrmSoTzr8ri1xDPLNlDU0cWruIl6kZFJCnssRbPxe471biGMvn70pfmcmpn",
26 | render_errors: [view: DemonSpiritWeb.ErrorView, accepts: ~w(html json)],
27 | pubsub_server: DemonSpiritWeb.PubSub,
28 | live_view: [
29 | signing_salt: "l5JjWQ6UpCgG+H5FItedIQEjMdxX3QW7"
30 | ]
31 |
32 | # Configures Elixir's Logger
33 | config :logger, :console,
34 | format: "$time $metadata[$level] $message\n",
35 | metadata: [:request_id]
36 |
37 | # Use Jason for JSON parsing in Phoenix
38 | config :phoenix, :json_library, Jason
39 |
40 | # Basic Auth for /dashboard - :dash_basic_auth - set during runtime in releases.exs
41 | config :demon_spirit_web, :dash_basic_auth,
42 | username: "admin",
43 | password: "EyAU6Ax8cyDkVcNA"
44 |
45 | # Import environment specific config. This must remain at the bottom
46 | # of this file so it overrides the configuration defined above.
47 | import_config "#{Mix.env()}.exs"
48 |
--------------------------------------------------------------------------------
/apps/demon_spirit/mix.exs:
--------------------------------------------------------------------------------
1 | defmodule DemonSpirit.MixProject do
2 | use Mix.Project
3 |
4 | def project do
5 | [
6 | app: :demon_spirit,
7 | version: "0.1.0",
8 | build_path: "../../_build",
9 | config_path: "../../config/config.exs",
10 | deps_path: "../../deps",
11 | lockfile: "../../mix.lock",
12 | elixir: "~> 1.5",
13 | elixirc_paths: elixirc_paths(Mix.env()),
14 | start_permanent: Mix.env() == :prod,
15 | aliases: aliases(),
16 | deps: deps()
17 | ]
18 | end
19 |
20 | # Configuration for the OTP application.
21 | #
22 | # Type `mix help compile.app` for more information.
23 | def application do
24 | [
25 | mod: {DemonSpirit.Application, []},
26 | extra_applications: [:logger, :runtime_tools]
27 | ]
28 | end
29 |
30 | # Specifies which paths to compile per environment.
31 | defp elixirc_paths(:test), do: ["lib", "test/support"]
32 | defp elixirc_paths(_), do: ["lib"]
33 |
34 | # Specifies your project dependencies.
35 | #
36 | # Type `mix help deps` for examples and options.
37 | defp deps do
38 | [
39 | {:ecto_sql, "~> 3.11.0"},
40 | {:postgrex, ">= 0.0.0"},
41 | {:jason, "~> 1.0"},
42 | {:poison, "~> 4.0"},
43 | {:httpoison, "~> 2.0"}
44 | ]
45 | end
46 |
47 | # Aliases are shortcuts or tasks specific to the current project.
48 | # For example, to create, migrate and run the seeds file at once:
49 | #
50 | # $ mix ecto.setup
51 | #
52 | # See the documentation for `Mix` for more info on aliases.
53 | defp aliases do
54 | [
55 | # "ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
56 | # "ecto.reset": ["ecto.drop", "ecto.setup"],
57 | # test: ["ecto.create --quiet", "ecto.migrate", "test"]
58 | ]
59 | end
60 | end
61 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/templates/game/index/game_table.html.heex:
--------------------------------------------------------------------------------
1 | <%= if length(@games) > 0 do %>
2 |
3 | <%= for game <- sort_gameinfos(@games) do %>
4 |
5 | <%= link game.name, to: Routes.game_path(@socket, :show, game.name), class: "text-blue-600 underline" %>
6 |
7 | <%= render "show/player.html", player: game.white %>
8 | <%= if game.winner == :white do %>
9 | winner
10 | <% end %>
11 | vs.
12 | <%= render "show/player.html", player: game.black %>
13 | <%= if game.winner == :black do %>
14 | winner
15 | <% end %>
16 |
17 |
18 | <%= case game.status do %>
19 | <% :playing -> %>
20 | in progress
21 | <% :staging -> %>
22 | staging
23 | <% :done -> %>
24 | won
25 | <% _ -> %>
26 | unknown
27 | <% end %>
28 |
29 |
30 | <%= date_to_hms(game.created_at) %>
31 | <%= date_to_md(game.created_at) %>
32 |
33 |
34 | <% end %>
35 |
36 | <% else %>
37 |
38 | No games are currently running.
39 |
40 | <% end %>
41 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/endpoint.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.Endpoint do
2 | use Phoenix.Endpoint, otp_app: :demon_spirit_web
3 |
4 | @session_options [
5 | store: :cookie,
6 | key: "_demon_spirit_web_key",
7 | signing_salt: "xh+R/LzW"
8 | ]
9 |
10 | socket("/live", Phoenix.LiveView.Socket, websocket: [connect_info: [session: @session_options]])
11 |
12 | socket("/socket", DemonSpiritWeb.UserSocket,
13 | websocket: true,
14 | longpoll: false
15 | )
16 |
17 | # Serve at "/" the static files from "priv/static" directory.
18 | #
19 | # You should set gzip to true if you are running phx.digest
20 | # when deploying your static files in production.
21 | plug(Plug.Static,
22 | at: "/",
23 | from: :demon_spirit_web,
24 | gzip: false,
25 | only: ~w(css fonts images sounds js favicon.ico robots.txt)
26 | )
27 |
28 | # Code reloading can be explicitly enabled under the
29 | # :code_reloader configuration of your endpoint.
30 | if code_reloading? do
31 | socket("/phoenix/live_reload/socket", Phoenix.LiveReloader.Socket)
32 | plug(Phoenix.LiveReloader)
33 | plug(Phoenix.CodeReloader)
34 | end
35 |
36 | ## LiveDashboard Plugins
37 | plug(Phoenix.LiveDashboard.RequestLogger,
38 | param_key: "request_logger",
39 | cookie_key: "request_logger"
40 | )
41 |
42 | plug(Plug.RequestId)
43 | plug(Plug.Telemetry, event_prefix: [:phoenix, :endpoint])
44 |
45 | plug(Plug.Parsers,
46 | parsers: [:urlencoded, :multipart, :json],
47 | pass: ["*/*"],
48 | json_decoder: Phoenix.json_library()
49 | )
50 |
51 | plug(Plug.MethodOverride)
52 | plug(Plug.Head)
53 |
54 | # The session will be stored in the cookie and signed,
55 | # this means its contents can be read but not tampered with.
56 | # Set :encryption_salt if you would also like to encrypt it.
57 | plug(Plug.Session, @session_options)
58 |
59 | plug(DemonSpiritWeb.Router)
60 | end
61 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/name_generator.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.NameGenerator do
2 | @moduledoc """
3 | NameGenerator: Makes random room names.
4 | """
5 |
6 | @doc """
7 | generate/1: Takes no input. Outputs a string of a random room name.
8 | """
9 | def generate do
10 | [
11 | Enum.random(adj()),
12 | Enum.random(noun()),
13 | :rand.uniform(9999)
14 | ]
15 | |> Enum.join("-")
16 | end
17 |
18 | defp adj do
19 | ~w[
20 | becoming
21 | bucolic
22 | chatoyant
23 | comely
24 | demure
25 | desultory
26 | diaphanous
27 | dulcet
28 | effervescent
29 | ephemeral
30 | ethereal
31 | evanescent
32 | evocative
33 | fetching
34 | fugacious
35 | furtive
36 | gossamer
37 | halcyon
38 | incipient
39 | ineffable
40 | labyrinthine
41 | lissome
42 | lithe
43 | mellifluous
44 | murmurous
45 | opulent
46 | pyrrhic
47 | quintessential
48 | redolent
49 | riparian
50 | sempiternal
51 | summery
52 | sumptuous
53 | surreptitious
54 | susurrous
55 | untoward
56 | vestigial
57 | woebegone
58 | ]
59 | end
60 |
61 | defp noun do
62 | ~w[
63 | ailurophile
64 | assemblage
65 | brood
66 | bungalow
67 | cynosure
68 | dalliance
69 | demesne
70 | denouement
71 | desuetude
72 | ebullience
73 | elision
74 | elixir
75 | eloquence
76 | epiphany
77 | felicity
78 | forbearance
79 | glamour
80 | harbinger
81 | imbrication
82 | imbroglio
83 | ingénue
84 | inglenook
85 | insouciance
86 | lagniappe
87 | lagoon
88 | languor
89 | lassitude
90 | leisure
91 | love
92 | moiety
93 | mondegreen
94 | nemesis
95 | offing
96 | onomatopoeia
97 | palimpsest
98 | panacea
99 | panoply
100 | pastiche
101 | penumbra
102 | petrichor
103 | plethora
104 | propinquity
105 | ratatouille
106 | ripple
107 | scintilla
108 | serendipity
109 | susquehanna
110 | talisman
111 | tintinnabulation
112 | umbrella
113 | wafture
114 | ]
115 | end
116 | end
117 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_game_ui/game_registry.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.GameRegistry do
2 | @moduledoc """
3 | GameRegistry: A centralized list of all games going on, and a little information about them.
4 | It's stored in key value format, in ETS.
5 | keys = game_name (string)
6 | values = %GameInfo{}, which is a short summary about the game
7 | """
8 | use GenServer
9 | require Logger
10 |
11 | @topic "game-registry"
12 |
13 | ######### Public API
14 |
15 | def start_link(_) do
16 | GenServer.start_link(__MODULE__, nil, name: __MODULE__)
17 | end
18 |
19 | def add(game_name, info) do
20 | Logger.info("GameRegistry: Asked to add #{game_name}")
21 | put(game_name, info)
22 | notify()
23 | end
24 |
25 | def update(game_name, info) do
26 | put(game_name, info)
27 | notify()
28 | end
29 |
30 | def remove(game_name) do
31 | Logger.info("GameRegistry: Asked to remove #{game_name}")
32 | :ets.delete(__MODULE__, game_name)
33 | notify()
34 | end
35 |
36 | def list() do
37 | :ets.match(__MODULE__, :"$1")
38 | |> Enum.map(fn [{_k, v}] -> v end)
39 | |> Enum.sort_by(
40 | fn gi ->
41 | if datetime?(gi.created_at), do: DateTime.to_iso8601(gi.created_at), else: nil
42 | end,
43 | &>=/2
44 | )
45 | end
46 |
47 | ###### Private Implementation Helpers
48 |
49 | def datetime?(%DateTime{}), do: true
50 | def datetime?(_), do: false
51 |
52 | def init(_) do
53 | :ets.new(
54 | __MODULE__,
55 | [:named_table, :public, write_concurrency: true, read_concurrency: true]
56 | )
57 |
58 | {:ok, nil}
59 | end
60 |
61 | defp notify() do
62 | Phoenix.PubSub.broadcast(
63 | DemonSpiritWeb.PubSub,
64 | @topic,
65 | {:state_update, %{}}
66 | )
67 | end
68 |
69 | # Basic put function. See git history for "get" if needed.
70 | defp put(key, value) do
71 | :ets.insert(__MODULE__, {key, value})
72 | end
73 | end
74 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/templates/game/show/ready.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
Waiting for players..
6 |
7 |
8 |
9 |
10 | <%= render "show/ready_player_column.html", player: @state.white, ready: @state.white_ready, color: "White", bg: "bg-gray-300" %>
11 | <%= render "show/ready_player_column.html", player: @state.black, ready: @state.black_ready, color: "Black", bg: "bg-gray-400" %>
12 |
13 |
14 |
15 |
16 |
17 | Room name:
18 | <%= @state.game_name %>
19 |
20 |
21 |
Link:
22 |
Routes.game_path(@socket, :show, @state.game_name)}
24 | />
25 |
26 | Send the link to a friend to have them join the game.
27 |
28 |
29 |
30 |
31 | <%= if show_ready_button?(@state, @guest) do %>
32 |
33 | Ready
34 |
35 | <% end %>
36 |
37 | <%= if show_not_ready_button?(@state, @guest) do %>
38 |
39 | Not Ready
40 |
41 | <% end %>
42 |
43 |
44 | Leave Room
45 |
46 |
47 |
48 |
49 |
50 |
2 |
About
3 |
4 | Demon Spirit is an abstract strategy game, something like chess with different rules, smaller board, and random starting conditions.
5 |
6 |
7 | Play against a friend or the computer AI.
8 |
9 |
10 | Show text rules .
11 |
12 |
13 |
14 |
Rules
15 |
16 | The pieces move according to 2 move cards you have.
17 | The king and pawns move the same.
18 | Using a move card places that card on the side, where your opponent will get it next turn.
19 |
20 | There are two ways to win:
21 |
22 | Capture your opponent's king.
23 | Move your king to the square where your opponent's king started.
24 |
25 |
26 |
27 |
28 |
Development
29 |
30 | <%= link "Check out the GitHub", to: "https://github.com/mreishus/demon_spirit_umbrella", class: "underline text-blue-700" %>.
31 |
32 |
33 | Made with: Elixir, Phoenix, LiveView, Tailwind CSS, Docker, Kubernetes, Caddy, Proxmox, Cloudflare.
34 |
35 |
36 | By: <%= link "Matthew Reishus", to: "https://matthewreishus.com", class: "underline text-blue-700" %>
37 |
38 |
39 |
DemonSpirit
8 |
12 |
13 |
14 |
15 |
16 |
17 |
18 | <%= link "Demon Spirit", to: Routes.game_path(@conn, :index), class: "underline hover:text-blue-300" %> (1.6.2)
19 |
20 |
21 |
22 |
23 | <%= if @current_guest do %>
24 |
25 | Logged in as <%= @current_guest.name %> (guest).
26 |
27 | <%= link "Log Out", to: Routes.session_path(@conn, :delete), method: :delete, class: "hover:text-red-600 underline" %>
28 | <% else %>
29 | <%= link "Log In", to: Routes.session_path(@conn, :new), class: "underline hover:text-blue-300" %>
30 | <% end %>
31 |
32 |
33 |
34 |
35 |
36 |
38 |
39 | <%= if get_flash(@conn, :info) != nil do %>
40 | <%= get_flash(@conn, :info) %>
41 | <% end %>
42 | <%= if get_flash(@conn, :error) != nil do %>
43 | <%= get_flash(@conn, :error) %>
44 | <% end %>
45 | <%= @inner_content %>
46 |
47 | <%= csrf_meta_tag() %>
48 |
49 |
50 |
51 |
--------------------------------------------------------------------------------
/config/releases.exs:
--------------------------------------------------------------------------------
1 | # In this file, we load production configuration and secrets
2 | # from environment variables. You can also hardcode secrets,
3 | # although such is generally not recommended and you have to
4 | # remember to add this file to your .gitignore.
5 | import Config
6 |
7 | ##
8 | ## Removed database_url and config of DemonSpirit.Repo,
9 | ## Since the DB is removed -MR 9/27/19
10 | ##
11 |
12 | # database_url =
13 | # System.get_env("DATABASE_URL") ||
14 | # raise """
15 | # environment variable DATABASE_URL is missing.
16 | # For example: ecto://USER:PASS@HOST/DATABASE
17 | # """
18 |
19 | # config :demon_spirit, DemonSpirit.Repo,
20 | # # ssl: true,
21 | # url: database_url,
22 | # pool_size: String.to_integer(System.get_env("POOL_SIZE") || "10")
23 |
24 | secret_key_base =
25 | System.get_env("SECRET_KEY_BASE") ||
26 | raise """
27 | environment variable SECRET_KEY_BASE is missing.
28 | You can generate one by calling: mix phx.gen.secret
29 | """
30 |
31 | config :demon_spirit_web, DemonSpiritWeb.Endpoint,
32 | http: [:inet6, port: String.to_integer(System.get_env("PORT") || "4000")],
33 | secret_key_base: secret_key_base
34 |
35 | ### Begin Dashboard Auth ###
36 | # Set Username/Password for Dashboard Basic Auth (/dashboard)
37 | #
38 | # Read from env variables DASH_BASIC_USER and DASH_BASIC_PASS
39 | # If none is set, instead of refusing to run, simply set to random strings.
40 | defmodule ReleaseUtil do
41 | def random_string(length) do
42 | :crypto.strong_rand_bytes(length) |> Base.url_encode64() |> binary_part(0, length)
43 | end
44 | end
45 |
46 | # Note: This doesn't actually work.
47 | # Spent a lot of time on it and I'm stuck..
48 | dash_basic_username = System.get_env("DASH_BASIC_USER") || ReleaseUtil.random_string(32)
49 | dash_basic_password = System.get_env("DASH_BASIC_PASS") || ReleaseUtil.random_string(32)
50 |
51 | config :demon_spirit_web, :dash_basic_auth,
52 | username: dash_basic_username,
53 | password: dash_basic_password
54 |
55 | ### End Dashboard Auth ###
56 |
57 | # ## Using releases (Elixir v1.9+)
58 | #
59 | # If you are doing OTP releases, you need to instruct Phoenix
60 | # to start each relevant endpoint:
61 | #
62 | config :demon_spirit_web, DemonSpiritWeb.Endpoint, server: true
63 | #
64 | # Then you can assemble a release by calling `mix release`.
65 | # See `mix help release` for more information.
66 |
--------------------------------------------------------------------------------
/apps/demon_spirit_game/lib/demon_spirit_game/game_win_check.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritGame.GameWinCheck do
2 | @moduledoc """
3 | Checks a DemonSpiritGame.Game for a winner and returns
4 | a copy of the game with the winner set if applicable.
5 | """
6 | alias DemonSpiritGame.{Game}
7 |
8 | @doc """
9 | check/1: Looks for a winner in a Game and
10 | sets the :winner key if needed.
11 | Input: %Game{}
12 | Output: %Game{}
13 | """
14 | @spec check(%Game{}) :: %Game{}
15 | def check(game) do
16 | game
17 | |> check_winner_kings()
18 | |> check_winner_temple()
19 | end
20 |
21 | _ = """
22 | check_winner_kings/1: Looks for a winner in a Game and
23 | sets the :winner key if needed.
24 |
25 | Only checks the condition of a king being killed.
26 | :winner set to :error in the case that both kings are missing.
27 |
28 | Input: %Game{}
29 | Output: %Game{}, possibly with :winner set to :white or :black
30 | """
31 |
32 | @spec check_winner_kings(%Game{}) :: %Game{}
33 | defp check_winner_kings(game) do
34 | king_colors =
35 | game.board
36 | |> Map.values()
37 | |> Enum.filter(fn p -> p.type == :king end)
38 | |> Enum.map(fn p -> p.color end)
39 |
40 | white_missing = :white not in king_colors
41 | black_missing = :black not in king_colors
42 |
43 | cond do
44 | white_missing && black_missing ->
45 | game |> mark_winner(:error)
46 |
47 | white_missing ->
48 | game |> mark_winner(:black)
49 |
50 | black_missing ->
51 | game |> mark_winner(:white)
52 |
53 | true ->
54 | game
55 | end
56 | end
57 |
58 | _ = """
59 | check_winner_kings/1: Looks for a winner in a Game and
60 | """
61 |
62 | defp check_winner_temple(game) do
63 | black_ascended = game.board[{2, 0}] == %{color: :black, type: :king}
64 | white_ascended = game.board[{2, 4}] == %{color: :white, type: :king}
65 |
66 | cond do
67 | white_ascended && black_ascended ->
68 | game |> mark_winner(:error)
69 |
70 | white_ascended ->
71 | game |> mark_winner(:white)
72 |
73 | black_ascended ->
74 | game |> mark_winner(:black)
75 |
76 | true ->
77 | game
78 | end
79 | end
80 |
81 | defp mark_winner(game = %Game{winner: winner}, _) when not is_nil(winner), do: game
82 |
83 | defp mark_winner(game, color) do
84 | %Game{game | winner: color}
85 | end
86 | end
87 |
--------------------------------------------------------------------------------
/config/prod.exs:
--------------------------------------------------------------------------------
1 | import Config
2 |
3 | # For production, don't forget to configure the url host
4 | # to something meaningful, Phoenix uses this information
5 | # when generating URLs.
6 | #
7 | # Note we also include the path to a cache manifest
8 | # containing the digested version of static files. This
9 | # manifest is generated by the `mix phx.digest` task,
10 | # which you should run after static files are built and
11 | # before starting your production server.
12 | config :demon_spirit_web, DemonSpiritWeb.Endpoint,
13 | url: [host: "demonspirit.xyz", port: 80],
14 | code_reloader: false,
15 | cache_static_manifest: "priv/static/cache_manifest.json",
16 | check_origin: [
17 | "//demonspirit.xyz",
18 | "//example.com",
19 | "//localhost",
20 | "//172.22.2.30:31229",
21 | "//172.22.2.31:31229",
22 | "//172.22.2.32:31229",
23 | "//172.22.2.33:31229"
24 | ]
25 |
26 | # ## SSL Support
27 | #
28 | # To get SSL working, you will need to add the `https` key
29 | # to the previous section and set your `:url` port to 443:
30 | #
31 | # config :demon_spirit_web, DemonSpiritWeb.Endpoint,
32 | # ...
33 | # url: [host: "example.com", port: 443],
34 | # https: [
35 | # :inet6,
36 | # port: 443,
37 | # cipher_suite: :strong,
38 | # keyfile: System.get_env("SOME_APP_SSL_KEY_PATH"),
39 | # certfile: System.get_env("SOME_APP_SSL_CERT_PATH")
40 | # ]
41 | #
42 | # The `cipher_suite` is set to `:strong` to support only the
43 | # latest and more secure SSL ciphers. This means old browsers
44 | # and clients may not be supported. You can set it to
45 | # `:compatible` for wider support.
46 | #
47 | # `:keyfile` and `:certfile` expect an absolute path to the key
48 | # and cert in disk or a relative path inside priv, for example
49 | # "priv/ssl/server.key". For all supported SSL configuration
50 | # options, see https://hexdocs.pm/plug/Plug.SSL.html#configure/1
51 | #
52 | # We also recommend setting `force_ssl` in your endpoint, ensuring
53 | # no data is ever sent via http, always redirecting to https:
54 | #
55 | # config :demon_spirit_web, DemonSpiritWeb.Endpoint,
56 | # force_ssl: [hsts: true]
57 | #
58 | # Check `Plug.SSL` for all available options in `force_ssl`.
59 |
60 | # Do not print debug messages in production
61 | config :logger, level: :info
62 |
63 | # No longer using prod.secret.exs - Letting
64 | # the release system check releases.exs at runtime
65 |
--------------------------------------------------------------------------------
/apps/demon_spirit_game/test/game_win_check_test.exs:
--------------------------------------------------------------------------------
1 | defmodule GameWinCheckTest do
2 | use ExUnit.Case, async: true
3 |
4 | doctest DemonSpiritGame.GameWinCheck, import: true
5 | alias DemonSpiritGame.{Game, Card, GameWinCheck}
6 |
7 | setup do
8 | # Static list of cards, use when creating a new game to remove RNG from tests
9 | cards = Card.cards() |> Enum.sort_by(fn card -> card.name end) |> Enum.take(5)
10 | game = Game.new(cards)
11 |
12 | %{
13 | game: game
14 | }
15 | end
16 |
17 | describe "check/1" do
18 | test "game with no winner is returned unchanged", %{game: game} do
19 | new_game = GameWinCheck.check(game)
20 | assert game == new_game
21 | assert new_game.winner == nil
22 | end
23 |
24 | test "white king elimination", %{game: game} do
25 | {_piece, new_board} = game.board |> Map.pop({2, 0})
26 | game = %Game{game | board: new_board} |> GameWinCheck.check()
27 | assert game.winner == :black
28 | end
29 |
30 | test "black king elimination", %{game: game} do
31 | {_piece, new_board} = game.board |> Map.pop({2, 4})
32 | game = %Game{game | board: new_board} |> GameWinCheck.check()
33 | assert game.winner == :white
34 | end
35 |
36 | test "white king ascends", %{game: game} do
37 | # Move Black King to {2, 2}
38 | {black_king, new_board} = game.board |> Map.pop({2, 4})
39 | new_board = new_board |> Map.put({2, 2}, black_king)
40 | game = %Game{game | board: new_board}
41 |
42 | # Move White King to {2, 4}
43 | {white_king, new_board} = game.board |> Map.pop({2, 0})
44 | new_board = new_board |> Map.put({2, 4}, white_king)
45 | game = %Game{game | board: new_board}
46 |
47 | # Check
48 | game = GameWinCheck.check(game)
49 | assert game.winner == :white
50 | end
51 |
52 | test "black king ascends", %{game: game} do
53 | # Move White King to {2, 2}
54 | {white_king, new_board} = game.board |> Map.pop({2, 0})
55 | new_board = new_board |> Map.put({2, 2}, white_king)
56 | game = %Game{game | board: new_board}
57 |
58 | # Move Black King to {2, 0}
59 | {black_king, new_board} = game.board |> Map.pop({2, 4})
60 | new_board = new_board |> Map.put({2, 0}, black_king)
61 | game = %Game{game | board: new_board}
62 |
63 | # Check
64 | game = GameWinCheck.check(game)
65 | assert game.winner == :black
66 | end
67 | end
68 | end
69 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/assets/js/socket.js:
--------------------------------------------------------------------------------
1 | // NOTE: The contents of this file will only be executed if
2 | // you uncomment its entry in "assets/js/app.js".
3 |
4 | // To use Phoenix channels, the first step is to import Socket,
5 | // and connect at the socket path in "lib/web/endpoint.ex".
6 | //
7 | // Pass the token on params as below. Or remove it
8 | // from the params if you are not using authentication.
9 | import {Socket} from "phoenix"
10 |
11 | let socket = new Socket("/socket", {params: {token: window.userToken}})
12 |
13 | // When you connect, you'll often need to authenticate the client.
14 | // For example, imagine you have an authentication plug, `MyAuth`,
15 | // which authenticates the session and assigns a `:current_user`.
16 | // If the current user exists you can assign the user's token in
17 | // the connection for use in the layout.
18 | //
19 | // In your "lib/web/router.ex":
20 | //
21 | // pipeline :browser do
22 | // ...
23 | // plug MyAuth
24 | // plug :put_user_token
25 | // end
26 | //
27 | // defp put_user_token(conn, _) do
28 | // if current_user = conn.assigns[:current_user] do
29 | // token = Phoenix.Token.sign(conn, "user socket", current_user.id)
30 | // assign(conn, :user_token, token)
31 | // else
32 | // conn
33 | // end
34 | // end
35 | //
36 | // Now you need to pass this token to JavaScript. You can do so
37 | // inside a script tag in "lib/web/templates/layout/app.html.eex":
38 | //
39 | //
40 | //
41 | // You will need to verify the user token in the "connect/3" function
42 | // in "lib/web/channels/user_socket.ex":
43 | //
44 | // def connect(%{"token" => token}, socket, _connect_info) do
45 | // # max_age: 1209600 is equivalent to two weeks in seconds
46 | // case Phoenix.Token.verify(socket, "user socket", token, max_age: 1209600) do
47 | // {:ok, user_id} ->
48 | // {:ok, assign(socket, :user, user_id)}
49 | // {:error, reason} ->
50 | // :error
51 | // end
52 | // end
53 | //
54 | // Finally, connect to the socket:
55 | socket.connect()
56 |
57 | // Now that you are connected, you can join channels with a topic:
58 | let channel = socket.channel("topic:subtopic", {})
59 | channel.join()
60 | .receive("ok", resp => { console.log("Joined successfully", resp) })
61 | .receive("error", resp => { console.log("Unable to join", resp) })
62 |
63 | export default socket
64 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Demon Spirit
2 |
3 | _Demon Spirit_, an abstract board game on a 5x5 grid served over the web. You
4 | can play against other players or a computer AI with programmable difficulty.
5 | Built in Elixir, Phoenix, and Phoenix Live View.
6 |
7 | ## Running the project (Development)
8 |
9 | ```
10 | mix deps.get
11 | cd ./apps/demon_spirit_web/assets
12 | npm install
13 | cd ../../../
14 | mix phx.server
15 | ```
16 |
17 | Visit [http://localhost:4000](http://localhost:4000) in web browser
18 |
19 | ## Running the project (Production Test)
20 |
21 | ```
22 | ./test_prod.sh
23 | # Visit http://localhost:4000 in your browser
24 | ```
25 |
26 | This will create a new docker image named `demon-spirit:test`, and run it,
27 | published to port 4000 on localhost.
28 |
29 | ## Running the project (Production)
30 |
31 | Create a Docker Image:
32 |
33 | ```
34 | edit build.sh with your favorite text editor - change docker tag to your namespace
35 | ./build.sh
36 | ```
37 |
38 | Run the docker image via your favorite method. Expose port 4000 to anywhere
39 | you want, typically 80. Since it doesn't require a database, that's all you
40 | need.
41 |
42 | ## Linting / Tests / Etc
43 |
44 | Run `mix check` to run all tests and linting.
45 |
46 | ## Online Version
47 |
48 | **Newest version is deployed at
49 | [https://demonspirit.xyz/](https://demonspirit.xyz/).**
50 |
51 | ## Issues
52 |
53 | Some issues are tracked in [Issues.MD](./Issues.md).
54 |
55 | ## Organization
56 |
57 | - DemonSpiritGame.\*
58 |
59 | Game logic. All functions for tracking and changing game state.
60 |
61 | - DemonSpiritWeb.\*
62 |
63 | Phoenix app that will allow users to play the game online. Uses Phoenix
64 | LiveView.
65 |
66 | - DemonSpirit
67 |
68 | If the web app ever tracks user accounts, win records, etc, the data models
69 | and associated functions will be here. Current implementation is anonymous
70 | sessions only.
71 |
72 | - Lessons Learned
73 |
74 | If I were making this app again, I don't think I would use an umbrella
75 | project. I'm not sure the apps are separated cleanly enough to warrant it.
76 |
77 | Current view:
78 |
79 | 
80 |
81 | ## Optional Honeycomb Configuration
82 |
83 | To report metrics to honeycomb.io, set these environment variables when running:
84 |
85 | - HONEYCOMB_APIKEY
86 | - HONEYCOMB_DATASET
87 |
88 | Example:
89 |
90 | ```bash
91 | export HONEYCOMB_APIKEY="012345678912345678abcde123456789"
92 | export HONEYCOMB_DATASET="demonspirit-elixir"
93 | ```
94 |
--------------------------------------------------------------------------------
/config/dev.exs:
--------------------------------------------------------------------------------
1 | import Config
2 |
3 | # Configure your database
4 | config :demon_spirit, DemonSpirit.Repo,
5 | username: "postgres",
6 | password: "postgres",
7 | database: "demon_spirit_dev",
8 | hostname: "localhost",
9 | show_sensitive_data_on_connection_error: true,
10 | pool_size: 10
11 |
12 | # For development, we disable any cache and enable
13 | # debugging and code reloading.
14 | #
15 | # The watchers configuration can be used to run external
16 | # watchers to your application. For example, we use it
17 | # with webpack to recompile .js and .css sources.
18 | config :demon_spirit_web, DemonSpiritWeb.Endpoint,
19 | http: [port: 4000],
20 | debug_errors: true,
21 | code_reloader: true,
22 | check_origin: false,
23 | watchers: [
24 | node: [
25 | "node_modules/webpack/bin/webpack.js",
26 | "--mode",
27 | "development",
28 | "--watch",
29 | cd: Path.expand("../apps/demon_spirit_web/assets", __DIR__)
30 | ]
31 | ]
32 |
33 | # ## SSL Support
34 | #
35 | # In order to use HTTPS in development, a self-signed
36 | # certificate can be generated by running the following
37 | # Mix task:
38 | #
39 | # mix phx.gen.cert
40 | #
41 | # Note that this task requires Erlang/OTP 20 or later.
42 | # Run `mix help phx.gen.cert` for more information.
43 | #
44 | # The `http:` config above can be replaced with:
45 | #
46 | # https: [
47 | # port: 4001,
48 | # cipher_suite: :strong,
49 | # keyfile: "priv/cert/selfsigned_key.pem",
50 | # certfile: "priv/cert/selfsigned.pem"
51 | # ],
52 | #
53 | # If desired, both `http:` and `https:` keys can be
54 | # configured to run both http and https servers on
55 | # different ports.
56 |
57 | # Watch static and templates for browser reloading.
58 | config :demon_spirit_web, DemonSpiritWeb.Endpoint,
59 | live_reload: [
60 | patterns: [
61 | ~r"priv/static/.*(js|css|png|jpeg|jpg|gif|svg)$",
62 | ~r"priv/gettext/.*(po)$",
63 | ~r"lib/demon_spirit_web/{live,views}/.*(ex)$",
64 | ~r"lib/demon_spirit_web/templates/.*(eex)$",
65 | ~r{lib/demon_spirit_web/live/.*(ex)$}
66 | ]
67 | ]
68 |
69 | # Do not include metadata nor timestamps in development logs
70 | config :logger, :console, format: "[$level] $message\n"
71 |
72 | # Initialize plugs at runtime for faster development compilation
73 | config :phoenix, :plug_init_mode, :runtime
74 |
75 | # Set a higher stacktrace during development. Avoid configuring such
76 | # in production as building large stacktraces may be expensive.
77 | config :phoenix, :stacktrace_depth, 20
78 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb do
2 | @moduledoc """
3 | The entrypoint for defining your web interface, such
4 | as controllers, views, channels and so on.
5 |
6 | This can be used in your application as:
7 |
8 | use DemonSpiritWeb, :controller
9 | use DemonSpiritWeb, :view
10 |
11 | The definitions below will be executed for every view,
12 | controller, etc, so keep them short and clean, focused
13 | on imports, uses and aliases.
14 |
15 | Do NOT define functions inside the quoted expressions
16 | below. Instead, define any helper function in modules
17 | and import those modules here.
18 | """
19 |
20 | alias DemonSpiritWeb.GameUIOptions
21 |
22 | def controller do
23 | quote do
24 | use Phoenix.Controller, namespace: DemonSpiritWeb
25 | import Plug.Conn
26 | import DemonSpiritWeb.Gettext
27 | alias DemonSpiritWeb.Router.Helpers, as: Routes
28 | import Phoenix.LiveView.Controller, only: [live_render: 3]
29 | end
30 | end
31 |
32 | def view do
33 | quote do
34 | use Phoenix.View,
35 | root: "lib/demon_spirit_web/templates",
36 | namespace: DemonSpiritWeb,
37 | pattern: "**/*"
38 |
39 | # Import convenience functions from controllers
40 | import Phoenix.Controller, only: [get_flash: 1, get_flash: 2, view_module: 1]
41 |
42 | # Use all HTML functionality (forms, tags, etc)
43 | use Phoenix.HTML
44 |
45 | import DemonSpiritWeb.ErrorHelpers
46 | import DemonSpiritWeb.Gettext
47 | alias DemonSpiritWeb.Router.Helpers, as: Routes
48 |
49 | import Phoenix.LiveView.Helpers
50 | end
51 | end
52 |
53 | def router do
54 | quote do
55 | use Phoenix.Router
56 | import Plug.Conn
57 | import Phoenix.Controller
58 | import Phoenix.LiveView.Router
59 | end
60 | end
61 |
62 | def channel do
63 | quote do
64 | use Phoenix.Channel
65 | import DemonSpiritWeb.Gettext
66 | end
67 | end
68 |
69 | @doc """
70 | When used, dispatch to the appropriate controller/view/etc.
71 | """
72 | defmacro __using__(which) when is_atom(which) do
73 | apply(__MODULE__, which, [])
74 | end
75 |
76 | @doc """
77 | Use ecto w/o DB to validate incoming game options
78 | Input: %{"vs" => "computer", ... other options ... }
79 | OUTPUT: {:ok, %GameUIOptions{}}
80 | """
81 | def validate_game_ui_options(params) do
82 | %GameUIOptions{}
83 | |> GameUIOptions.changeset(params)
84 | |> Ecto.Changeset.apply_action(:insert)
85 | end
86 | end
87 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/priv/gettext/en/LC_MESSAGES/errors.po:
--------------------------------------------------------------------------------
1 | ## `msgid`s in this file come from POT (.pot) files.
2 | ##
3 | ## Do not add, change, or remove `msgid`s manually here as
4 | ## they're tied to the ones in the corresponding POT file
5 | ## (with the same domain).
6 | ##
7 | ## Use `mix gettext.extract --merge` or `mix gettext.merge`
8 | ## to merge POT files into PO files.
9 | msgid ""
10 | msgstr ""
11 | "Language: en\n"
12 |
13 | ## From Ecto.Changeset.cast/4
14 | msgid "can't be blank"
15 | msgstr ""
16 |
17 | ## From Ecto.Changeset.unique_constraint/3
18 | msgid "has already been taken"
19 | msgstr ""
20 |
21 | ## From Ecto.Changeset.put_change/3
22 | msgid "is invalid"
23 | msgstr ""
24 |
25 | ## From Ecto.Changeset.validate_acceptance/3
26 | msgid "must be accepted"
27 | msgstr ""
28 |
29 | ## From Ecto.Changeset.validate_format/3
30 | msgid "has invalid format"
31 | msgstr ""
32 |
33 | ## From Ecto.Changeset.validate_subset/3
34 | msgid "has an invalid entry"
35 | msgstr ""
36 |
37 | ## From Ecto.Changeset.validate_exclusion/3
38 | msgid "is reserved"
39 | msgstr ""
40 |
41 | ## From Ecto.Changeset.validate_confirmation/3
42 | msgid "does not match confirmation"
43 | msgstr ""
44 |
45 | ## From Ecto.Changeset.no_assoc_constraint/3
46 | msgid "is still associated with this entry"
47 | msgstr ""
48 |
49 | msgid "are still associated with this entry"
50 | msgstr ""
51 |
52 | ## From Ecto.Changeset.validate_length/3
53 | msgid "should be %{count} character(s)"
54 | msgid_plural "should be %{count} character(s)"
55 | msgstr[0] ""
56 | msgstr[1] ""
57 |
58 | msgid "should have %{count} item(s)"
59 | msgid_plural "should have %{count} item(s)"
60 | msgstr[0] ""
61 | msgstr[1] ""
62 |
63 | msgid "should be at least %{count} character(s)"
64 | msgid_plural "should be at least %{count} character(s)"
65 | msgstr[0] ""
66 | msgstr[1] ""
67 |
68 | msgid "should have at least %{count} item(s)"
69 | msgid_plural "should have at least %{count} item(s)"
70 | msgstr[0] ""
71 | msgstr[1] ""
72 |
73 | msgid "should be at most %{count} character(s)"
74 | msgid_plural "should be at most %{count} character(s)"
75 | msgstr[0] ""
76 | msgstr[1] ""
77 |
78 | msgid "should have at most %{count} item(s)"
79 | msgid_plural "should have at most %{count} item(s)"
80 | msgstr[0] ""
81 | msgstr[1] ""
82 |
83 | ## From Ecto.Changeset.validate_number/3
84 | msgid "must be less than %{number}"
85 | msgstr ""
86 |
87 | msgid "must be greater than %{number}"
88 | msgstr ""
89 |
90 | msgid "must be less than or equal to %{number}"
91 | msgstr ""
92 |
93 | msgid "must be greater than or equal to %{number}"
94 | msgstr ""
95 |
96 | msgid "must be equal to %{number}"
97 | msgstr ""
98 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/priv/gettext/errors.pot:
--------------------------------------------------------------------------------
1 | ## This is a PO Template file.
2 | ##
3 | ## `msgid`s here are often extracted from source code.
4 | ## Add new translations manually only if they're dynamic
5 | ## translations that can't be statically extracted.
6 | ##
7 | ## Run `mix gettext.extract` to bring this file up to
8 | ## date. Leave `msgstr`s empty as changing them here has no
9 | ## effect: edit them in PO (`.po`) files instead.
10 |
11 | ## From Ecto.Changeset.cast/4
12 | msgid "can't be blank"
13 | msgstr ""
14 |
15 | ## From Ecto.Changeset.unique_constraint/3
16 | msgid "has already been taken"
17 | msgstr ""
18 |
19 | ## From Ecto.Changeset.put_change/3
20 | msgid "is invalid"
21 | msgstr ""
22 |
23 | ## From Ecto.Changeset.validate_acceptance/3
24 | msgid "must be accepted"
25 | msgstr ""
26 |
27 | ## From Ecto.Changeset.validate_format/3
28 | msgid "has invalid format"
29 | msgstr ""
30 |
31 | ## From Ecto.Changeset.validate_subset/3
32 | msgid "has an invalid entry"
33 | msgstr ""
34 |
35 | ## From Ecto.Changeset.validate_exclusion/3
36 | msgid "is reserved"
37 | msgstr ""
38 |
39 | ## From Ecto.Changeset.validate_confirmation/3
40 | msgid "does not match confirmation"
41 | msgstr ""
42 |
43 | ## From Ecto.Changeset.no_assoc_constraint/3
44 | msgid "is still associated with this entry"
45 | msgstr ""
46 |
47 | msgid "are still associated with this entry"
48 | msgstr ""
49 |
50 | ## From Ecto.Changeset.validate_length/3
51 | msgid "should be %{count} character(s)"
52 | msgid_plural "should be %{count} character(s)"
53 | msgstr[0] ""
54 | msgstr[1] ""
55 |
56 | msgid "should have %{count} item(s)"
57 | msgid_plural "should have %{count} item(s)"
58 | msgstr[0] ""
59 | msgstr[1] ""
60 |
61 | msgid "should be at least %{count} character(s)"
62 | msgid_plural "should be at least %{count} character(s)"
63 | msgstr[0] ""
64 | msgstr[1] ""
65 |
66 | msgid "should have at least %{count} item(s)"
67 | msgid_plural "should have at least %{count} item(s)"
68 | msgstr[0] ""
69 | msgstr[1] ""
70 |
71 | msgid "should be at most %{count} character(s)"
72 | msgid_plural "should be at most %{count} character(s)"
73 | msgstr[0] ""
74 | msgstr[1] ""
75 |
76 | msgid "should have at most %{count} item(s)"
77 | msgid_plural "should have at most %{count} item(s)"
78 | msgstr[0] ""
79 | msgstr[1] ""
80 |
81 | ## From Ecto.Changeset.validate_number/3
82 | msgid "must be less than %{number}"
83 | msgstr ""
84 |
85 | msgid "must be greater than %{number}"
86 | msgstr ""
87 |
88 | msgid "must be less than or equal to %{number}"
89 | msgstr ""
90 |
91 | msgid "must be greater than or equal to %{number}"
92 | msgstr ""
93 |
94 | msgid "must be equal to %{number}"
95 | msgstr ""
96 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/live/live_chat_index.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.LiveChatIndex do
2 | @moduledoc """
3 | LiveChatIndex: A Live view for showing a chat room on a webpage.
4 | This is intended to be nestable inside other live views.
5 | """
6 | use Phoenix.LiveView
7 | alias DemonSpiritWeb.{ChatView, Endpoint, Presence}
8 | alias DemonSpiritGame.{ChatServer, ChatSupervisor}
9 |
10 | def render(assigns) do
11 | ChatView.render("live_index.html", assigns)
12 | end
13 |
14 | def mount(_params, %{"chat_name" => chat_name, "guest" => guest}, socket) do
15 | topic = topic_for(chat_name)
16 | if connected?(socket), do: Endpoint.subscribe(topic)
17 | {:ok, _} = Presence.track(self(), topic, guest.id, guest)
18 | ChatSupervisor.start_chat_if_needed(chat_name)
19 |
20 | {:ok,
21 | assign(socket,
22 | guest: guest,
23 | chat_name: chat_name,
24 | chat_message: DemonSpirit.new_chat_message(),
25 | messages: ChatServer.messages(chat_name),
26 | topic: topic,
27 | users: []
28 | )}
29 | end
30 |
31 | def handle_event(
32 | "message",
33 | %{"chat_message" => params},
34 | socket = %{assigns: %{chat_name: chat_name, guest: guest}}
35 | ) do
36 | msg_tuple =
37 | params
38 | |> Map.put("name", guest.name)
39 | |> DemonSpirit.fake_insert_chat_message()
40 |
41 | case msg_tuple do
42 | {:ok, this_msg} ->
43 | ChatServer.add_message(chat_name, this_msg)
44 |
45 | notify(socket.assigns.topic)
46 |
47 | {:noreply,
48 | assign(socket,
49 | chat_message: DemonSpirit.new_chat_message(),
50 | messages: ChatServer.messages(chat_name)
51 | )}
52 |
53 | _ ->
54 | # Silent failure if e.g. blank message
55 | {:noreply, socket}
56 | end
57 | end
58 |
59 | def notify(topic) do
60 | Endpoint.broadcast_from(self(), topic, "state_update", %{})
61 | end
62 |
63 | def topic_for(chat_name) do
64 | "chat-topic:" <> chat_name
65 | end
66 |
67 | def handle_info(
68 | %{event: "state_update"},
69 | socket = %{assigns: %{chat_name: chat_name}}
70 | ) do
71 | messages = ChatServer.messages(chat_name)
72 | {:noreply, assign(socket, messages: messages)}
73 | end
74 |
75 | # Handle "presence_diff", someone joined or left
76 | def handle_info(%{event: "presence_diff"}, socket = %{assigns: %{topic: topic}}) do
77 | users =
78 | Presence.list(topic)
79 | |> Enum.map(fn {_user_id, data} ->
80 | data[:metas]
81 | |> List.first()
82 | end)
83 |
84 | {:noreply, assign(socket, users: users)}
85 | end
86 | end
87 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_game_ui/game_timer.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.GameTimer do
2 | @moduledoc """
3 | GameTimer: Represents a chess timer containing a "time left" for both
4 | white and black players.
5 | """
6 | alias DemonSpiritGame.{Game}
7 | alias DemonSpiritWeb.GameTimer
8 | require Logger
9 |
10 | defstruct white_time: 0,
11 | white_time_current: 0,
12 | black_time: 0,
13 | black_time_current: 0,
14 | last_move: nil,
15 | started: false
16 |
17 | @initial_time 5 * 60 * 1000
18 |
19 | def new do
20 | %GameTimer{
21 | white_time: @initial_time,
22 | black_time: @initial_time,
23 | white_time_current: @initial_time,
24 | black_time_current: @initial_time,
25 | last_move: nil,
26 | started: false
27 | }
28 | end
29 |
30 | def apply_move(timer = %GameTimer{}, game = %Game{}) do
31 | if timer.started == false do
32 | %{timer | started: true, last_move: DateTime.utc_now()}
33 | else
34 | apply_move_started(timer, game)
35 | end
36 | end
37 |
38 | defp apply_move_started(timer = %GameTimer{}, game = %Game{}) do
39 | time_elapsed = DateTime.diff(DateTime.utc_now(), timer.last_move, :millisecond)
40 |
41 | case game.turn do
42 | :white ->
43 | t = timer.white_time - time_elapsed
44 | %{timer | white_time: t, white_time_current: t, last_move: DateTime.utc_now()}
45 |
46 | :black ->
47 | t = timer.black_time - time_elapsed
48 | %{timer | black_time: t, black_time_current: t, last_move: DateTime.utc_now()}
49 |
50 | _ ->
51 | Logger.warning("GameTimer: Don't know whose turn it is.", [])
52 | %{timer | last_move: DateTime.utc_now()}
53 | end
54 | end
55 |
56 | def get_current_time(timer, game) do
57 | if timer.started == false do
58 | timer
59 | else
60 | get_current_time_started(timer, game)
61 | end
62 | end
63 |
64 | defp get_current_time_started(timer = %GameTimer{}, game = %Game{}) do
65 | time_elapsed = DateTime.diff(DateTime.utc_now(), timer.last_move, :millisecond)
66 |
67 | case game.turn do
68 | :white ->
69 | t = timer.white_time - time_elapsed
70 | %{timer | white_time_current: t}
71 |
72 | :black ->
73 | t = timer.black_time - time_elapsed
74 | %{timer | black_time_current: t}
75 |
76 | _ ->
77 | Logger.warning("GameTimer: Don't know whose turn it is [2].", [])
78 | timer
79 | end
80 | end
81 |
82 | def check_winner(timer = %GameTimer{}) do
83 | cond do
84 | timer.white_time_current < 0 -> :black
85 | timer.black_time_current < 0 -> :white
86 | true -> nil
87 | end
88 | end
89 | end
90 |
--------------------------------------------------------------------------------
/apps/demon_spirit_game/test/game_supervisor_test.exs:
--------------------------------------------------------------------------------
1 | defmodule GameSupervisorTest do
2 | use ExUnit.Case, async: true
3 |
4 | alias DemonSpiritGame.{GameSupervisor, GameServer}
5 |
6 | describe "start_game/1" do
7 | test "spawns a game server process" do
8 | game_name = "game-#{:rand.uniform(1000)}"
9 | assert {:ok, _pid} = GameSupervisor.start_game(game_name)
10 |
11 | via = GameServer.via_tuple(game_name)
12 | assert GenServer.whereis(via) |> Process.alive?()
13 | end
14 |
15 | test "returns an error if game is already started" do
16 | game_name = "game-#{:rand.uniform(1000)}"
17 |
18 | assert {:ok, pid} = GameSupervisor.start_game(game_name)
19 | assert {:error, {:already_started, ^pid}} = GameSupervisor.start_game(game_name)
20 | end
21 | end
22 |
23 | describe "start_game/2" do
24 | test "spawns a game server process" do
25 | game_name = "game-#{:rand.uniform(1000)}"
26 | assert {:ok, _pid} = GameSupervisor.start_game(game_name, :hardcoded_cards)
27 |
28 | via = GameServer.via_tuple(game_name)
29 | assert GenServer.whereis(via) |> Process.alive?()
30 | end
31 |
32 | test "returns an error if game is already started" do
33 | game_name = "game-#{:rand.uniform(1000)}"
34 |
35 | assert {:ok, pid} = GameSupervisor.start_game(game_name, :hardcoded_cards)
36 |
37 | assert {:error, {:already_started, ^pid}} =
38 | GameSupervisor.start_game(game_name, :hardcoded_cards)
39 | end
40 | end
41 |
42 | describe "stop_game" do
43 | test "terminates the process normally" do
44 | game_name = "game-#{:rand.uniform(1000)}"
45 | {:ok, _pid} = GameSupervisor.start_game(game_name)
46 | via = GameServer.via_tuple(game_name)
47 |
48 | assert :ok = GameSupervisor.stop_game(game_name)
49 | refute GenServer.whereis(via)
50 | end
51 | end
52 |
53 | describe "ets preservation of crashed processes" do
54 | test "supervised game gets restarted and retains status after crashing" do
55 | # Start a supervised game
56 | game_name = "game-#{:rand.uniform(1000)}"
57 | {:ok, pid} = GameSupervisor.start_game(game_name)
58 |
59 | # Move a single piece, and record the state before/after
60 | initial_state = GameServer.state(game_name)
61 | move = GameServer.all_valid_moves(game_name) |> Enum.at(0)
62 | GameServer.move(game_name, move)
63 | new_state = GameServer.state(game_name)
64 | assert initial_state != new_state
65 |
66 | # Make the game crash
67 | Process.exit(pid, :kaboom)
68 | # Give supervisor time to restart
69 | :timer.sleep(10)
70 |
71 | # Check the restored state and verify it's not the initial state
72 | restored_state = GameServer.state(game_name)
73 | assert restored_state == new_state
74 | assert restored_state != initial_state
75 | end
76 | end
77 | end
78 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/templates/game/show/board.html.heex:
--------------------------------------------------------------------------------
1 | <% game = @state.game %>
2 | <% my_turn = @state[game.turn] == @guest %>
3 |
4 | <%# Game Won Modal %>
5 | <%= if game.winner != nil do %>
6 |
7 |
8 |
9 |
10 | <%= game.winner %> wins!
11 |
12 |
13 | <%= link "Back to Lobby", to: Routes.game_path(@socket, :index), class: "btn btn-primary" %>
14 |
15 |
16 |
17 |
23 |
24 |
25 | Use which move?
26 |
27 | <%= for {i, card} <- clarify_moves(@state) do %>
28 |
32 |
33 |
34 | <%= render "show/card.html", card: card, flip: false, class: "" %>
35 |
36 | <% end %>
37 |
38 | Cancel
39 |
40 |
41 |
42 |
43 |
47 | <%# Render Pieces %>
48 | <%= for {{x, y}, piece} <- game.board do %>
49 |
to_string(x) <> "-" <> to_string(y) <> "-" <> Atom.to_string(piece.type) <> "-" <> Atom.to_string(piece.color) }
51 | phx-click={phx_click_value(x, y)}
52 | phx-hook="DraggableDroppable"
53 | draggable='true'
54 | onclick="event.preventDefault(); return false;"
55 | data-x={x}
56 | data-y={y}
57 | class={"cursor-pointer absolute piece " <> Atom.to_string(piece.type) <> " " <> Atom.to_string(piece.color)}
58 | style={piece_style(x, y, @flip_per)}>
59 |
60 | <% end %>
61 |
62 | <%# Render Square Targets %>
63 | <%= for x <- [0, 1, 2, 3, 4] do %>
64 | <%= for y <- [0, 1, 2, 3, 4] do %>
65 |
to_string(x) <> "-" <> to_string(y) }
67 | phx-click={phx_click_value(x, y)}
68 | phx-hook="Droppable"
69 | onclick="event.preventDefault(); return false;"
70 | data-x={x}
71 | data-y={y}
72 | class={square_class(x, y, @state, my_turn)}
73 | style={piece_style(x, y, @flip_per)}
74 | >
77 | <% end %>
78 | <% end %>
79 |
17 |
19 |
20 |
22 | image/svg+xml
23 |
27 |
28 |
29 |
31 |
34 |
41 |
42 |
66 |
68 |
70 |
72 |
74 |
105 |
114 |
123 |
132 |
141 |
142 |
--------------------------------------------------------------------------------
/.github/workflows/elixir.yaml:
--------------------------------------------------------------------------------
1 | name: Elixir CI
2 |
3 | # Define workflow that runs when changes are pushed to the
4 | # `main` branch or pushed to a PR branch that targets the `main`
5 | # branch. Change the branch name if your project uses a
6 | # different name for the main branch like "master" or "production".
7 | on:
8 | push:
9 | branches: [ "master" ]
10 | pull_request:
11 | branches: [ "master" ]
12 |
13 | # Sets the ENV `MIX_ENV` to `test` for running tests
14 | env:
15 | MIX_ENV: test
16 |
17 | permissions:
18 | contents: read
19 |
20 | jobs:
21 | test:
22 | # Set up a Postgres DB service. By default, Phoenix applications
23 | # use Postgres. This creates a database for running tests.
24 | # Additional services can be defined here if required.
25 | # services:
26 | # db:
27 | # image: postgres:12
28 | # ports: ['5432:5432']
29 | # env:
30 | # POSTGRES_PASSWORD: postgres
31 | # options: >-
32 | # --health-cmd pg_isready
33 | # --health-interval 10s
34 | # --health-timeout 5s
35 | # --health-retries 5
36 |
37 | runs-on: ubuntu-latest
38 | name: Test on OTP ${{matrix.otp}} / Elixir ${{matrix.elixir}}
39 | strategy:
40 | # Specify the OTP and Elixir versions to use when building
41 | # and running the workflow steps.
42 | matrix:
43 | otp: ['26.1.1'] # Define the OTP version [required]
44 | elixir: ['1.15.7'] # Define the elixir version [required]
45 | steps:
46 | # Step: Setup Elixir + Erlang image as the base.
47 | - name: Set up Elixir
48 | uses: erlef/setup-beam@v1
49 | with:
50 | otp-version: ${{matrix.otp}}
51 | elixir-version: ${{matrix.elixir}}
52 |
53 | # Step: Check out the code.
54 | - name: Checkout code
55 | uses: actions/checkout@v4
56 |
57 | # Step: Define how to cache deps. Restores existing cache if present.
58 | - name: Cache deps
59 | id: cache-deps
60 | uses: actions/cache@v3
61 | env:
62 | cache-name: cache-elixir-deps
63 | with:
64 | path: deps
65 | key: ${{ runner.os }}-mix-${{ env.cache-name }}-${{ hashFiles('**/mix.lock') }}
66 | restore-keys: |
67 | ${{ runner.os }}-mix-${{ env.cache-name }}-
68 |
69 | # Step: Define how to cache the `_build` directory. After the first run,
70 | # this speeds up tests runs a lot. This includes not re-compiling our
71 | # project's downloaded deps every run.
72 | - name: Cache compiled build
73 | id: cache-build
74 | uses: actions/cache@v3
75 | env:
76 | cache-name: cache-compiled-build
77 | with:
78 | path: _build
79 | key: ${{ runner.os }}-mix-${{ env.cache-name }}-${{ hashFiles('**/mix.lock') }}
80 | restore-keys: |
81 | ${{ runner.os }}-mix-${{ env.cache-name }}-
82 | ${{ runner.os }}-mix-
83 |
84 | # Step: Conditionally bust the cache when job is re-run.
85 | # Sometimes, we may have issues with incremental builds that are fixed by
86 | # doing a full recompile. In order to not waste dev time on such trivial
87 | # issues (while also reaping the time savings of incremental builds for
88 | # *most* day-to-day development), force a full recompile only on builds
89 | # that are retried.
90 | - name: Clean to rule out incremental build as a source of flakiness
91 | if: github.run_attempt != '1'
92 | run: |
93 | mix deps.clean --all
94 | mix clean
95 | shell: sh
96 |
97 | # Step: Download project dependencies. If unchanged, uses
98 | # the cached version.
99 | - name: Install dependencies
100 | run: mix deps.get
101 |
102 | # Step: Compile the project treating any warnings as errors.
103 | # Customize this step if a different behavior is desired.
104 |
105 | - name: Compiles without warnings
106 | run: mix compile
107 |
108 | # - name: Compiles without warnings
109 | # run: mix compile --warnings-as-errors
110 |
111 | # Step: Check that the checked in code has already been formatted.
112 | # This step fails if something was found unformatted.
113 | # Customize this step as desired.
114 | - name: Check Formatting
115 | run: mix format --check-formatted
116 |
117 | # Step: Execute the tests.
118 | - name: Run tests
119 | run: mix test
120 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/views/game_view.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritWeb.GameView do
2 | use DemonSpiritWeb, :view
3 | alias DemonSpiritWeb.GameUI
4 | import Phoenix.Component, only: [live_render: 3]
5 |
6 | @doc """
7 | staging?/1: Given the current gameui, is it in a staging state?
8 | The staging state is when we are waiting for players to sit down
9 | and ready up before the game begins.
10 | """
11 | def staging?(gameui) do
12 | GameUI.staging?(gameui)
13 | end
14 |
15 | @doc """
16 | needs_clarify?/1: Does the current player need to clarify which move they meant?
17 | """
18 | def needs_clarify?(gameui) do
19 | gameui.moves_need_clarify != nil and length(gameui.moves_need_clarify) > 0
20 | end
21 |
22 | @doc """
23 | clarify_moves/1: Get a list of moves a clarifying player can choose from, with index.
24 | In format: [ {0, %Card{}}, {1, %Card{}}, ... ]
25 | """
26 | def clarify_moves(gameui) do
27 | if needs_clarify?(gameui) do
28 | gameui.moves_need_clarify
29 | |> Enum.with_index()
30 | |> Enum.map(fn {move, i} -> {i, move.card} end)
31 | else
32 | []
33 | end
34 | end
35 |
36 | @doc """
37 | show_ready_button?/1: Given a gameui state and a player, should
38 | they see the ready button?
39 | """
40 | def show_ready_button?(gameui, guest) do
41 | cond do
42 | staging?(gameui) and gameui.black == guest and not gameui.black_ready ->
43 | true
44 |
45 | staging?(gameui) and gameui.white == guest and not gameui.white_ready ->
46 | true
47 |
48 | true ->
49 | false
50 | end
51 | end
52 |
53 | @doc """
54 | show_ready_button?/1: Given a gameui state and a player, should
55 | they see the "not ready" button?
56 | """
57 | def show_not_ready_button?(gameui, guest) do
58 | cond do
59 | staging?(gameui) and gameui.black == guest and gameui.black_ready ->
60 | true
61 |
62 | staging?(gameui) and gameui.white == guest and gameui.white_ready ->
63 | true
64 |
65 | true ->
66 | false
67 | end
68 | end
69 |
70 | def sort_gameinfos(gis) do
71 | gis |> Enum.sort_by(fn g -> {g.status, DateTime.to_iso8601(g.created_at)} end, &>=/2)
72 | end
73 |
74 | @doc """
75 | date_to_md/1: Turn a DateTime into a string representing the month and day in UTC.
76 | """
77 | def date_to_md(a) do
78 | "#{a.month}/#{a.day}"
79 | end
80 |
81 | @doc """
82 | date_to_hms/1: Turn a DateTime into a string representing the hour and minute in UTC.
83 | """
84 | def date_to_hms(a) do
85 | "#{a.hour}:#{zero_pad(a.minute)}"
86 | end
87 |
88 | # Zero_pad: Given an integer and an amount, pad left with 0s.
89 | # Returns string. zero_pad(1, 2) = "01". zero_pad(1, 3) = "001".
90 | @spec zero_pad(integer(), non_neg_integer()) :: String.t()
91 | def zero_pad(number, amount \\ 2) do
92 | number
93 | |> Integer.to_string()
94 | |> String.pad_leading(amount, "0")
95 | end
96 |
97 | def display_ms(ms) do
98 | seconds = ms / 1000
99 | seconds_int = trunc(seconds)
100 | # seconds_leftover = seconds - seconds_int
101 | {minutes_int, seconds_int_rem} = {div(seconds_int, 60), rem(seconds_int, 60)}
102 | "#{minutes_int}:#{zero_pad(seconds_int_rem, 2)}"
103 | end
104 |
105 | @doc """
106 | game_row_class/1: Returns the appropriate CSS class for a game row based on the game's status.
107 | """
108 | def game_row_class(game) do
109 | case game.status do
110 | :playing -> "bg-blue-200"
111 | :staging -> "bg-blue-100"
112 | :done -> "bg-blue-200"
113 | _ -> "bg-blue-300"
114 | end
115 | end
116 |
117 | def phx_click_value(x, y) do
118 | "click-square-#{x}-#{y}"
119 | end
120 |
121 | def piece_style(x, y, flip_per) do
122 | if flip_per do
123 | "transform: translate(#{(4 - x) * 100}%, #{y * 100}%);"
124 | else
125 | "transform: translate(#{x * 100}%, #{(4 - y) * 100}%);"
126 | end
127 | end
128 |
129 | def square_class(x, y, state, my_turn) do
130 | base_class = "cursor-pointer absolute square"
131 | selected_class = if my_turn and {x, y} == state.selected, do: " selected", else: ""
132 | move_dest_class = if my_turn and {x, y} in state.move_dest, do: " move_dest", else: ""
133 | also_piece_class = if Map.has_key?(state.game.board, {x, y}), do: " also_piece", else: ""
134 |
135 | last_move_class =
136 | if state.last_move != nil and
137 | (state.last_move.from == {x, y} or state.last_move.to == {x, y}),
138 | do: " last_move",
139 | else: ""
140 |
141 | base_class <> selected_class <> move_dest_class <> also_piece_class <> last_move_class
142 | end
143 | end
144 |
--------------------------------------------------------------------------------
/apps/demon_spirit_game/test/game_server_test.exs:
--------------------------------------------------------------------------------
1 | defmodule GameServerTest do
2 | use ExUnit.Case, async: true
3 |
4 | doctest DemonSpiritGame.GameServer
5 | alias DemonSpiritGame.{GameServer, Game, Move, Card}
6 |
7 | describe "start_link/1" do
8 | test "spawns a process" do
9 | game_name = generate_game_name()
10 |
11 | assert {:ok, _pid} = GameServer.start_link(game_name)
12 | end
13 |
14 | test "each name can only have one process" do
15 | game_name = generate_game_name()
16 |
17 | assert {:ok, _pid} = GameServer.start_link(game_name)
18 | assert {:error, _reason} = GameServer.start_link(game_name)
19 | end
20 | end
21 |
22 | describe "start_link/2" do
23 | test "spawns a process" do
24 | game_name = generate_game_name()
25 |
26 | assert {:ok, _pid} = GameServer.start_link(game_name, :hardcoded_cards)
27 | end
28 |
29 | test "each name can only have one process" do
30 | game_name = generate_game_name()
31 |
32 | assert {:ok, _pid} = GameServer.start_link(game_name, :hardcoded_cards)
33 | assert {:error, _reason} = GameServer.start_link(game_name, :hardcoded_cards)
34 | end
35 | end
36 |
37 | describe "state/1" do
38 | test "get game state" do
39 | game_name = generate_game_name()
40 | assert {:ok, _pid} = GameServer.start_link(game_name)
41 | state = GameServer.state(game_name)
42 | assert %Game{} = state
43 | assert state.board |> Map.keys() |> length == 10
44 | end
45 |
46 | test "get game state (hardcoded cards)" do
47 | game_name = generate_game_name()
48 | assert {:ok, _pid} = GameServer.start_link(game_name, :hardcoded_cards)
49 | state = GameServer.state(game_name)
50 | assert %Game{} = state
51 | assert state.board |> Map.keys() |> length == 10
52 | assert state.cards.side.name == "Drake"
53 | end
54 | end
55 |
56 | describe "move/2" do
57 | setup do
58 | {:ok, wild_pig} = Card.by_name("Wild Pig")
59 | {:ok, cobra} = Card.by_name("Python")
60 | {:ok, drake} = Card.by_name("Drake")
61 | %{wild_pig: wild_pig, cobra: cobra, drake: drake}
62 | end
63 |
64 | test "Moving a piece via GameServer", %{cobra: cobra, wild_pig: wild_pig, drake: drake} do
65 | ## Need a way to generate an initial game state w/o RNG
66 | ## To know a move we can test
67 | game_name = generate_game_name()
68 | assert {:ok, _pid} = GameServer.start_link(game_name, :hardcoded_cards)
69 | game = GameServer.state(game_name)
70 |
71 | ## Simple move
72 | move = %Move{from: {0, 0}, to: {1, 1}, card: cobra}
73 |
74 | ## Do the move ourself (w/o server)
75 | {:ok, game_move_manual} = Game.move(game, move)
76 | {:ok, game_move_server} = GameServer.move(game_name, move)
77 |
78 | ## Are the moves the same?
79 | assert game_move_manual == game_move_server
80 | ## Are they diff from the initial state?
81 | refute game == game_move_server
82 |
83 | ## Did the move do what we expect?
84 | # Player flipped
85 | assert game_move_server.turn == :black
86 | # Card rotated
87 | assert game_move_server.cards.side == cobra
88 | assert wild_pig in game_move_server.cards.white
89 | assert drake in game_move_server.cards.white
90 | # Piece Moved
91 | refute game_move_server.board |> Map.has_key?({0, 0})
92 | assert game_move_server.board |> Map.has_key?({1, 1})
93 | end
94 | end
95 |
96 | describe "all_valid_moves/1" do
97 | test "a" do
98 | game_name = generate_game_name()
99 | assert {:ok, _pid} = GameServer.start_link(game_name, :hardcoded_cards)
100 | moves = GameServer.all_valid_moves(game_name)
101 | assert length(moves) == 9
102 | count = moves |> Enum.filter(fn m -> m.from == {4, 0} && m.to == {4, 1} end) |> Enum.count()
103 | assert count == 1
104 | end
105 | end
106 |
107 | describe "active_piece?/2" do
108 | test "a" do
109 | game_name = generate_game_name()
110 | assert {:ok, _pid} = GameServer.start_link(game_name, :hardcoded_cards)
111 | assert GameServer.active_piece?(game_name, {0, 0})
112 | refute GameServer.active_piece?(game_name, {2, 2})
113 | refute GameServer.active_piece?(game_name, {4, 4})
114 | end
115 | end
116 |
117 | describe "game_summary/1" do
118 | test "a" do
119 | game_name = generate_game_name()
120 | assert {:ok, _pid} = GameServer.start_link(game_name, :hardcoded_cards)
121 | summary = GameServer.game_summary(game_name)
122 | assert %{game: state, all_valid_moves: moves} = summary
123 | # Check moves
124 | assert length(moves) == 9
125 | count = moves |> Enum.filter(fn m -> m.from == {4, 0} && m.to == {4, 1} end) |> Enum.count()
126 | assert count == 1
127 | # Check game
128 | assert state.board |> Map.keys() |> length == 10
129 | assert state.cards.side.name == "Drake"
130 | end
131 | end
132 |
133 | defp generate_game_name do
134 | "game-#{:rand.uniform(1_000_000)}"
135 | end
136 | end
137 |
--------------------------------------------------------------------------------
/apps/demon_spirit_game/lib/demon_spirit_game/game_server.ex:
--------------------------------------------------------------------------------
1 | defmodule DemonSpiritGame.GameServer do
2 | @moduledoc """
3 | Genserver to hold a %Game{}'s state within a process.
4 | """
5 | use GenServer
6 | require Logger
7 | @timeout :timer.hours(1)
8 |
9 | alias DemonSpiritGame.{Game, Move}
10 |
11 | #####################################
12 | ########### PUBLIC API ##############
13 | #####################################
14 |
15 | @doc """
16 | start_link/1: Generates a new game server under a provided name.
17 | """
18 | @spec start_link(String.t()) :: {:ok, pid} | {:error, any}
19 | def start_link(game_name) do
20 | GenServer.start_link(__MODULE__, {game_name}, name: via_tuple(game_name))
21 | end
22 |
23 | @doc """
24 | start_link/2: Generates a new game server under a provided name.
25 | Providing :hardcoded_cards removes the RNG of initial card selection
26 | and simply picks the first 5 cards in alphabetical order.
27 | This should only be used for testing.
28 | """
29 | @spec start_link(String.t(), :hardcoded_cards) :: {:ok, pid} | {:error, any}
30 | def start_link(game_name, :hardcoded_cards) do
31 | GenServer.start_link(__MODULE__, {game_name, :hardcoded_cards}, name: via_tuple(game_name))
32 | end
33 |
34 | @doc """
35 | via_tuple/1: Given a game name string, generate a via tuple for addressing the game.
36 | """
37 | def via_tuple(game_name),
38 | do: {:via, Registry, {DemonSpiritGame.GameRegistry, {__MODULE__, game_name}}}
39 |
40 | @doc """
41 | game_pid/1: Returns the `pid` of the game server process registered
42 | under the given `game_name`, or `nil` if no process is registered.
43 | """
44 | def game_pid(game_name) do
45 | game_name
46 | |> via_tuple()
47 | |> GenServer.whereis()
48 | end
49 |
50 | @doc """
51 | state/1: Retrieves the game state for the game under a provided name.
52 | """
53 | @spec state(String.t()) :: %Game{} | nil
54 | def state(game_name) do
55 | case game_pid(game_name) do
56 | nil -> nil
57 | _ -> GenServer.call(via_tuple(game_name), :state)
58 | end
59 | end
60 |
61 | @doc """
62 | move/2: Applies the given move to a game and returns the new game state.
63 | """
64 | @spec move(String.t(), %Move{}) :: {:ok, %Game{}} | {:error, :invalid_move}
65 | def move(game_name, move = %Move{}) do
66 | GenServer.call(via_tuple(game_name), {:move, move})
67 | end
68 |
69 | @doc """
70 | all_valid_moves/1: Return all valid moves for a game, given its name.
71 | """
72 | def all_valid_moves(game_name) do
73 | GenServer.call(via_tuple(game_name), :all_valid_moves)
74 | end
75 |
76 | @doc """
77 | active_piece?/2: Given a coordinate, does a piece exist there
78 | and belong to the currently playing player?
79 | """
80 | def active_piece?(game_name, coords = {x, y}) when is_integer(x) and is_integer(y) do
81 | GenServer.call(via_tuple(game_name), {:active_piece?, coords})
82 | end
83 |
84 | @doc """
85 | game_summary/1: Return both the game state and "all valid moves."
86 | %{
87 | game: %Game{},
88 | all_valid_moves: [ %Move{}, ... ]
89 | }
90 | """
91 | def game_summary(game_name) do
92 | GenServer.call(via_tuple(game_name), :game_summary)
93 | end
94 |
95 | #####################################
96 | ########### IMPLEMENTATION ##########
97 | #####################################
98 |
99 | def init({game_name, :hardcoded_cards}) do
100 | Logger.info("GameServer: Starting a server for game named [#{game_name}] (hardcoded cards).")
101 | _init(game_name, Game.new(game_name, :hardcoded_cards))
102 | end
103 |
104 | def init({game_name}) do
105 | Logger.info("GameServer: Starting a server for game named [#{game_name}].")
106 | _init(game_name, Game.new(game_name))
107 | end
108 |
109 | defp _init(game_name, new_game) do
110 | game =
111 | case :ets.lookup(:games, game_name) do
112 | [] ->
113 | game = new_game
114 | :ets.insert(:games, {game_name, game})
115 | game
116 |
117 | [{^game_name, game}] ->
118 | game
119 | end
120 |
121 | {:ok, game, @timeout}
122 | end
123 |
124 | def handle_call(:state, _from, game) do
125 | {:reply, game, game, @timeout}
126 | end
127 |
128 | def handle_call({:move, move = %Move{}}, _from, game) do
129 | case Game.move(game, move) do
130 | {:ok, new_game} ->
131 | :ets.insert(:games, {game.game_name, new_game})
132 | {:reply, {:ok, new_game}, new_game, @timeout}
133 |
134 | {:error, _} ->
135 | # ???
136 | {:reply, {:error, :invalid_move}, game, @timeout}
137 | end
138 | end
139 |
140 | def handle_call(:all_valid_moves, _from, game) do
141 | {:reply, Game.all_valid_moves(game), game, @timeout}
142 | end
143 |
144 | def handle_call({:active_piece?, coords = {x, y}}, _from, game)
145 | when is_integer(x) and is_integer(y) do
146 | response = Game.active_piece?(game, coords)
147 | {:reply, response, game, @timeout}
148 | end
149 |
150 | def handle_call(:game_summary, _from, game) do
151 | reply = %{
152 | all_valid_moves: Game.all_valid_moves(game),
153 | game: game
154 | }
155 |
156 | {:reply, reply, game, @timeout}
157 | end
158 |
159 | # When timing out, the order is handle_info(:timeout, _) -> terminate({:shutdown, :timeout}, _)
160 | def handle_info(:timeout, game) do
161 | {:stop, {:shutdown, :timeout}, game}
162 | end
163 |
164 | def terminate({:shutdown, :timeout}, game) do
165 | Logger.info("GameServer: Terminate (Timeout) running for #{game.game_name}")
166 | :ets.delete(:games, game.game_name)
167 | :ok
168 | end
169 |
170 | def terminate(_reason, game) do
171 | Logger.info("GameServer: Strange termination for [#{game.game_name}].")
172 | :ok
173 | end
174 | end
175 |
--------------------------------------------------------------------------------
/apps/demon_spirit_web/lib/demon_spirit_web/templates/game/live_show.html.leex.bak:
--------------------------------------------------------------------------------
1 | <% game = @state.game %>
2 |
3 | <% top_cards = if @flip_per, do: game.cards.white, else: game.cards.black %>
4 | <% top_player = if @flip_per, do: @state.white, else: @state.black %>
5 | <% bottom_cards = if @flip_per, do: game.cards.black, else: game.cards.white %>
6 | <% bottom_player = if @flip_per, do: @state.black, else: @state.white %>
7 |
8 |
180 |
181 |
182 |
1
183 |
184 |
185 |
186 | <%= render "show/board.html", state: @state, flip_per: @flip_per %>
187 |
188 | 2
189 |
192 |
197 |
198 |
199 | <%= render "show/board.html", state: @state, flip_per: @flip_per %>
200 |
201 |
202 |
203 |
204 | <%= render "show/player.html", player: top_player %>
205 |
206 |
207 |
208 | <%= render "show/card.html", card: game.cards.side, flip: (game.turn == :black and not @flip_per) || (@flip_per and game.turn == :white) %>
209 | <%= if game.winner == nil do %>
210 |
211 | <%= game.turn %>'s turn
212 |
213 | <% end %>
214 |
215 |
216 |
217 | <%= render "show/player.html", player: bottom_player %>
218 |
219 |
220 |
225 |
229 | <%#= inspect(game, pretty: true) %>
230 |
231 |
232 | <%= inspect(@users, pretty: true) %>
233 |
234 |
235 | <%= inspect(@state, pretty: true) %>
236 |
237 |
238 | PHX Hook Example
239 | @game_name}
97 | phx-hook="UpdateDing"
98 | class="hidden"
99 | data-moves={@state.game.moves}
100 | >
101 | <%= @state.game.moves %>
102 |
103 |
104 |
105 | <%# Main %>
106 |
107 |
108 |
109 | <%# Left - Chat %>
110 |
111 | <%= live_render(@socket, DemonSpiritWeb.LiveChatIndex,
112 | session: %{"chat_name" => @game_name, "guest" => @guest},
113 | id: @game_name,
114 | container: {:div, class: "h-full"}
115 | ) %>
116 |
117 |
118 | <%# Main - Board %>
119 |
120 |
121 | <%# Top cards, hide while staging %>
122 | <%= if staging?(@state) do %>
123 |
124 | <% else %>
125 |
126 | <%# Top Bar %>
127 | <%= for card <- top_cards do %>
128 | <%= render "show/card.html", card: card, flip: true, class: "mx-4" %>
129 | <% end %>
130 |
131 | <% end %>
132 |
133 |
134 | <%= render "show/board.html", state: @state, flip_per: @flip_per, guest: @guest, socket: @socket %>
135 |
136 |
137 | <%# Bottom cards, hide while staging %>
138 | <%= if staging?(@state) do %>
139 |
140 | <% else %>
141 |
142 | <%# Bottom Bar %>
143 | <%= for card <- bottom_cards do %>
144 | <%= render "show/card.html", card: card, flip: false, class: "mx-4" %>
145 | <% end %>
146 |
147 | <% end %>
148 |
149 |
150 |
151 | <%# Right - Side card and Players%>
152 | <%= if not staging?(@state) do %>
153 |
154 |
155 | <%= render "show/timer.html", timer: top_timer, active: top_next %>
156 | <%= if top_next do %>
157 |
158 | Next Move
160 | <% end %>
161 | <%= render "show/player.html", player: top_player %>
162 |
163 |
164 |
165 | <%= render "show/card.html",
166 | card: game.cards.side,
167 | flip: (game.turn == :black and not @flip_per) || (@flip_per and game.turn == :white),
168 | class: "mx-4"
169 | %>
170 | <%= if game.winner == nil do %>
171 |
172 | <%= game.turn %>'s turn
173 |
174 | <% end %>
175 |
176 |
177 |
178 | <%= render "show/player.html", player: bottom_player %>
179 | <%= if bottom_next do %>
180 |
181 | Next Move
183 | <% end %>
184 | <%= render "show/timer.html", timer: bottom_timer, active: bottom_next %>
185 |
186 |
187 |
188 | <% end %>
189 |
190 |
191 |
192 |
25 |