How to implement different game rules?

I’m learning Elixir by myself for fun now. I have basic Python knowledge before. I think the best way to learn a new programming language is to do some real projects. I’m try to create a web based poker game. The basic unit of the game is the table. Different tables have different game rules. e.g. Texas Hold’em table, Omaha table. etc. But as a functional programming language, Elixir has no class no object no inheritance. My question is how to implement a structure that can associate with different game rules?

Just use different modules for different games. Maybe also create a basic module with @callbacks and use it as a @behaviour on the implementation modules, to define a common interface for them, and ensure they have the functions the base game module calls.


I think that you could dive straight into a project if Elixir was Object-Oriented (Python). The patterns used to design a game using functional programming are different. In my opinion start by studying the basics of Elixir (Syntax + Project organisation using Mix).
Reading this documentation will be a good starting point.
Good luck.

If You like Poker with Elixir, there is an old post about it here You might need to adapt for newer version, but the post is nice.

Other games I often saw, Tic Tac Toe, Tetris…

I wrote a little game engine for go here

For a more complete example, there is this video

1 Like

@AlecHsueh: I don’t exactly know about rules that you need to implement, but here is my idea:

Firstly declare your configuration with some raw data that you will process in game:

config :my_app, table_rules: %{
  omaha: %{}, # here you can describe rules for Omaha
  texas: %{} # here you can describe rules for Texas Hold'em
# Note: keep rules in format that you like

Secondly create a GenServer-based module:

defmodule MyApp.TableServer do
  use GenServer

  def card_played(player, card) do
    call_self({:card_played, player, card})

  # rest public server API

  def init(opts) do
    table_name = opts[:table]
    rules = :my_app |> Application.fetch_env!(:table_rules) |> Map.fetch!(table_name)
    {:ok, %{rules: rules, table_name: table_name}}

  def start_link(opts \\ [table: :texas]) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)

  defp call_self(request), do:, request)

  def handle_call({:card_played, player, card}, _from, state = %{rules: rules}) do
    # your code based on table rules (case, cond, if, etc)
    {:reply, :ok, state}

  # other handlers for calls (as in your public server API

Finally for each table you need to start a new server like:

alias MyApp.TableServer

TableServer.start_link(table: :config_table_name)

and call your server public API like:

alias MyApp.TableServer

player = %{} # …
card = %{} # …
TableServer.card_played(player, card)

Note: You can also use DynamicSupervisor for your table server processes.

I would take care not to link the game implementation (e.g. :card_played) to a GenServer. You can implement all of the logic with pure modules and functions.

To Spawn, or not to Spawn? by Saša Jurić gives a good overview about when and how to reach for processes and even talks about an implementation of a card game to boot (Blackjack).

1 Like

This comment:

your code based on table rules (…)

does not mean that you need to write login directly in this place.

I believe that this is easiest example for board games (as far as I remember table in each game have only one event like card played) at same time + time for players in their rounds to think about next move.