• בלוג
  • ruby
  • בואו נכתוב משחק איקס עיגול ב Elixir

בואו נכתוב משחק איקס עיגול ב Elixir

25/02/2018

אליקסיר היא אחת השפות המדליקות ביותר שאתם לא כותבים בהן וחבל. ואני יודע שבטח תשאלו תכף למה צריך בכלל עוד שפה ומה אליקסיר עושה טוב יותר משפות אחרות, אבל אלה לא השאלות החשובות. כי לאליקסיר שתי תכונות שמייחדות אותה משאר העולם: היא פונקציונאלית והמידע בה לא משתנה לעולם מרגע שנוצר, מה שנקרא Immutable. כתיבה באליקסיר עוזרת לתרגל תבניות שמקבלות מקום צדדי בשפות אחרות.

1. התקנה ותבנית פרויקט

אליקסיר רצה בתוך המכונה הוירטואלית של Erlang שנקראת BEAM. הבחירה ב BEAM תעזור לאלה מכם שמחפשים סיבות פרקטיות ללמוד את השפה: אירלנג משמשת את כל תעשיית הטלקום ומצטיינת בזמינות גבוהה, תמיכה מלאה ב Zero Downtime Deployment ומוכנות גבוהה לעבודה מבוזרת.

בשביל להתקין את אליקסיר (ועל הדרך גם את אילרנג) צריך רק להוריד ולהריץ את ה Installer מכאן: https://elixir-lang.org/install.html

לאחר ההתקנה תקבלו כלי שורת-פקודה בשם mix שאיתו גם יוצרים את התוכנית הראשונה. משורת הפקודה נכתוב:

$ mix new tictactoe

וקיבלנו את מבנה התיקיות הבא איתו אפשר להתחיל לעבוד:

.
├── README.md
├── config
│   └── config.exs
├── lib
│   └── tictactoe.ex
├── mix.exs
└── test
    ├── test_helper.exs
    └── tictactoe_test.exs

אין עדיין IDE מסודר אבל אפשר לעבוד עם כל Text Editor. כן יש תוספים מעולים ל vim ול atom.

2. נתחיל עם לוח משחק

רוב המתכנתים שיגיעו לכתוב קוד עבור לוח במשחק איקס עיגול יחשבו על מבנה של מערך, כאשר בכל פעם שמישהו מבצע מהלך מסמנים ערך מתאים באחד התאים. באליקסיר כזכור זה לא יכול לעבוד: כל המידע הוא קבוע ולכן לא נוכל ״לסמן״ תאים במערך כדי לייצג מהלכים במשחק.

במקום זה כל שלב במשחק מיוצג על ידי מערך חדש, וכל הפונקציות שנכתוב יקבלו את לוח המשחק כקלט ויחזירו לוח משחק חדש. במחשבה שניה זה לא רק הלוח שמשתנה כל מהלך, אלא גם מזהה השחק הנוכחי. נשמור את שני הערכים במבנה אחד בשביל שיהיה נוח לעבוד איתם יחד.

פתחו את הקובץ lib/tictactoe.ex והחליפו את תוכנו בקוד הבא:

defmodule GameState do
  defstruct player: 'X', board: %{}
end

defmodule Tictactoe do
  def init do
    %GameState{}
  end
end

הקוד מתחיל בהגדרת struct בשם GameState. באליקסיר struct הוא פשוט דרך לאסוף יחד מידע מסוגים שונים ולאכוף מבנה מסוים של המידע. במקרה שלנו המבנה מורכב מ player שמתחיל עם הערך X, ושדה בשם board שמתחיל בתור Map ריק. מבנה Map של אליקסיר דומה ל Hash של רובי או Dictionary של פייתון. הוא מאפשר להגדיר אוסף פריטים כאשר כל אחד מזוהה לפי מפתח ייחודי. אני חושב שיהיה נוח להשתמש באינדקס של כל תא בלוח בתור מפתח, ובמזהה השחקן שתפס את המשבצת בתור ערך.

3. ביצוע מהלך במשחק

ועכשיו לשאלת מיליון הדולר: איך לשנות ערכים בשפה שלא תומכת בשינוי? איך לבצע מהלך במשחק? התשובה כפי שאולי כבר ניחשתם היא שאנחנו לא משנים את הלוח, אלא מחזירים לוח חדש.

כל מהלך בלוח מיוצג על ידי תא במפה: המפתח הוא צמד האינדקסים (שורה, עמודה) והערך הוא מזהה השחקן ש"תפס" את המשבצת. בלוח הבא למשל שחקן X לקח את המשבצת השמאלית עליונה, ושחקן O לקח את המשבצת הימנית עליונה:

%{{0, 0} => 'X', {0, 2} => 'O'}

סימן סוגריים מסולסלים של אליקסיר מייצג ״צמד״, שזה דבר דומה מאוד ל Tuple מ Python (וגם נקרא Tuple באליקסיר).

הפונקציה play שמבצעת את המהלך מקבלת את לוח המשחק הישן ואת המהלך שרוצים לבצע, ומחזירה את הלוח לאחר הביצוע. הפונקציה צריכה לבדוק גם שהמשחק עדיין נמשך ושהמשבצת לא תפוסה, אבל דווקא המקרה האחרון ב cond הוא המעניין ביותר כאן:

  def play({row, col}, state) do
    cond do
      # tried to play a finished game
      game_over(state) ->
        state

      # square taken
      {row, col} in Map.keys(state.board) ->
        state

      # square free - take it!
      true ->
        %GameState{
          player: next_player(state.player),
          board: Map.put_new(state.board, { row, col }, state.player),
        }
    end
  end

הפקודה cond של אליקסיר אגב דומה ל switch/case בשפות אחרות ומאפשרת בדיקה של מספר תנאים והחזרת ערך לפי התנאי שמתקיים. הקוד שהוצג מטפל ב-3 תנאים אפשריים: או שהמשחק נגמר (ותכף נצטרך לראות את הקוד של game_over עצמה), או שהמשבצת כבר תפוסה, או שבוצע מהלך תקין במשבצת פנויה.

בשני המקרים הראשונים לא קרה שום שינוי בלוח המשחק ולכן מחזירים את הלוח בדיוק כפי שקיבלנו אותו. המקרה האחרון הוא כאמור המעניין יותר. אנחנו אומנם לא יכולים לשנות את הלוח אבל בהחלט אפשר להחזיר לוח חדש שמורכב מכל תוכן הלוח הקודם ועוד המשבצת החדשה שעכשיו תפסנו. אגב ב State הבא שאותו מחזירים השחקן כבר מוגדר להיות השחקן הבא, וגם את הפונקציה next_player נצטרך לראות מיד.

כשמריצים את הקוד מקבלים התנהגות פונקציונאלית טיפוסית. הפעלה של הפונקציה play על אותו קלט תמיד מחזירה את אותו הפלט:

> s=TicTacToe.init
%GameState{board: %{}, player: 'X'}

> TicTacToe.play({0, 0}, s)
%GameState{board: %{{0, 0} => 'X'}, player: 'O'}

> TicTacToe.play({0, 0}, s)
%GameState{board: %{{0, 0} => 'X'}, player: 'O'}

> s1=TicTacToe.play({0, 0}, s)
%GameState{board: %{{0, 0} => 'X'}, player: 'O'}

> s2=TicTacToe.play( {0, 0}, s1)
%GameState{board: %{{0, 0} => 'X'}, player: 'O'}

> s2=TicTacToe.play({0, 1}, s1)
%GameState{board: %{{0, 0} => 'X', {0, 1} => 'O'}, player: 'X'}

4. שתי הפונקציות החסרות

לאליקסיר יש טריק נחמד במימוש הפונקציה שמחזירה את השחקן הבא:

def next_player('X'), do: 'O'
def next_player('O'), do: 'X'

שפות מונחות עצמים רבות מאפשרות לכם להגדיר מספר מימושים לאותה פונקציה לפי סוג הפרמטרים שהפונקציה מקבלת. אליקסיר (ושפות נוספות מהמשפחה) מאפשרות להגדיר מימושים שונים גם לפי ערכים ממש שמועברים לפונקציה. כך השחקן הבא של X הוא O ולהיפך.

זיהוי סיום משחק הוא קצת יותר מורכב, כי צריך לזהות אם יש מנצח. באליקסיר הדרך המקובלת לגשת לבעיות כאלה היא הרבה יותר תיאורית מאשר במקומות אחרים. הפקודה Enum.any? מקבלת אוסף איברים ופונקציה ובודקת אם אחד האיברים מהאוסף יגרום לפונקציה להחזיר אמת. המימוש הבא מעביר ל any את אוסף האינדקסים שעשויים להביא לניצחון, ופונקציה שבודקת אם בכל 3 המשבצות יש את אותו הערך:

  def is_winning_triplet(['X', 'X', 'X']), do: true
  def is_winning_triplet(['O', 'O', 'O']), do: true
  def is_winning_triplet(triplet), do: false

  def has_winner?(state) do
    Enum.any?([
      [ {0, 0}, {0, 1}, {0, 2} ],
      [ {1, 0}, {1, 1}, {1, 2} ],
      [ {2, 0}, {2, 1}, {2, 2} ],
      [ {0, 0}, {1, 0}, {2, 0} ],
      [ {0, 1}, {1, 1}, {2, 1} ],
      [ {0, 2}, {1, 2}, {2, 2} ],
      [ {0, 0}, {1, 1}, {2, 2} ],
      [ {0, 2}, {1, 1}, {2, 0} ],
    ],
    fn x ->
      Map.take(state.board, x)
      |> Map.values
      |> is_winning_triplet
    end)
  end

  def game_over?(state) do
    has_winner?(state) || Map.size(state.board) == 9
  end

הסימן המוזר >| מציין הפעלה הפוכה של פונקציה. הרעיון הוא שבמקום לכתוב:

f(g(h(x)))

אפשר לכתוב את הקוד הבא שהוא שקול לגמרי ועשוי להיות יותר קריא כששמות הפונקציות ארוכות:

h(x)
|> g
|> f

בעברית נגיד שמפעילים את הפונקציה h על x, את התוצאה שולחים ל-g, ואת התוצאה של זה שולחים ל f. בקוד שהוצג לוקחים מהלוח את ה key/values בשלושת האינדקסים, את התוצאה שולחים ל Map.values כדי לקבל רק את הערכים, ואת התוצאה שולחים ל is_winning_triplet כדי לדעת אם הערכים אכן מעידים על ניצחון.

סך הכל קוד המשחק המלא נראה כך:

defmodule GameState do
  defstruct player: 'X', board: %{}
end

defmodule TicTacToe do
  def init do
    %GameState{}
  end

  def is_winning_triplet(['X', 'X', 'X']), do: true
  def is_winning_triplet(['O', 'O', 'O']), do: true
  def is_winning_triplet(_), do: false

  def has_winner?(state) do
    Enum.any?([
      [ {0, 0}, {0, 1}, {0, 2} ],
      [ {1, 0}, {1, 1}, {1, 2} ],
      [ {2, 0}, {2, 1}, {2, 2} ],
      [ {0, 0}, {1, 0}, {2, 0} ],
      [ {0, 1}, {1, 1}, {2, 1} ],
      [ {0, 2}, {1, 2}, {2, 2} ],
      [ {0, 0}, {1, 1}, {2, 2} ],
      [ {0, 2}, {1, 1}, {2, 0} ],
    ],
    fn x ->
      Map.take(state.board, x)
      |> Map.values
      |> is_winning_triplet
    end)
  end

  def game_over?(state) do
    has_winner?(state) || Map.size(state.board) == 9
  end

  def next_player('X'), do: 'O'
  def next_player('O'), do: 'X'

  def play(state, {row, col}) do
    cond do
      # tried to play a finished game
      game_over?(state) ->
        state

      # square taken
      {row, col} in Map.keys(state.board) ->
        state

      # square free - take it!
      true ->
        %GameState{
          player: next_player(state.player),
          board: Map.put_new(state.board, { row, col }, state.player),
        }
    end
  end
end

5. כתיבת בדיקות למשחק

מאחר והקוד כולו הוא פונקציונאלי וכל ה State נשמר באופן חיצוני לפונקציות, יחסית קל לכתוב בדיקות לקוד. פתחו את הקובץ test/tictactoe_test.exs וכתבו בו את התוכן הבא:

defmodule TicTacToeTest do
  use ExUnit.Case
  doctest TicTacToe

  test 'board starts empty' do
    s = TicTacToe.init
    assert map_size(s.board) == 0
  end

  test 'X plays first' do
    s = TicTacToe.init
    assert s.player == 'X'
  end

  test 'winning row is detected' do
    board = %{ {0, 0} => 'X', {0, 1} => 'X', { 0, 2 } => 'X' }
    s = %GameState{board: board, player: 'O'}
    assert TicTacToe.has_winner?(s)
  end

  test 'winning column is detected' do
    board = %{ {0, 0} => 'X', {1, 0} => 'X', { 2, 0 } => 'X' }
    s = %GameState{board: board, player: 'O'}
    assert TicTacToe.has_winner?(s)
  end

  test 'O can win too' do
    board = %{ {0, 0} => 'O', {1, 0} => 'O', { 2, 0 } => 'O' }
    s = %GameState{board: board, player: 'O'}
    assert TicTacToe.has_winner?(s)
  end

  test 'XOX is not a win' do
    board = %{ {0, 0} => 'X', {1, 0} => 'O', { 2, 0 } => 'X' }
    s = %GameState{board: board, player: 'O'}
    refute TicTacToe.has_winner?(s)
  end

  test 'State does not change when playing a finished board' do
    board = %{ {0, 0} => 'X', {1, 0} => 'X', { 2, 0 } => 'X' }
    s = %GameState{board: board, player: 'O'}
    assert TicTacToe.play({1, 1}, s) == s
  end

  test 'State does not change when playing a taken square' do
    board = %{ {0, 0} => 'X' }
    s = %GameState{board: board, player: 'O'}
    assert TicTacToe.play({0, 0}, s) == s
  end
end

הפקודה test מגדירה בלוק בדיקה, הפקודה assert מגדירה תנאי שחייב להחזיר ערך אמת כדי שהבדיקה תעבור והפקודה refute היא ההפך מ assert. בגלל שה State חיצוני לא צריך לשחק את כל המשחק בכדי לבדוק ניצחון, ומספיק ליצור את הלוח המנצח בצורה ישירה.

חזרו לשורת הפקודה והריצו את הבדיקות כדי לראות שכתבתם הכל כמו שצריך עד עכשיו. כך זה נראה אצלי:

$ mix test
........

Finished in 0.05 seconds
8 tests, 0 failures

Randomized with seed 600647

בשביל המשחק ננסה להכניס שינוי בקוד, למשל שהפונקציה game_over תבדוק רק את המצב שהלוח מתמלא:

  def game_over?(state) do
    Map.size(state.board) == 9
  end

הפעלה חוזרת של הבדיקות ומקבלים:

localhost:tictactoe ynonperek$ mix test
Compiling 1 file (.ex)
.....

  1) test State does not change when playing a finished board (TicTacToeTest)
     test/tictactoe_test.exs:39
     Assertion with == failed
     code:  assert TicTacToe.play({1, 1}, s) == s
     left:  %GameState{board: %{{0, 0} => 'X', {1, 0} => 'X', {2, 0} => 'X', {1, 1} => 'O'}, player: 'X'}
     right: %GameState{board: %{{0, 0} => 'X', {1, 0} => 'X', {2, 0} => 'X'}, player: 'O'}
     stacktrace:
       test/tictactoe_test.exs:42: (test)

..

Finished in 0.06 seconds
8 tests, 1 failure

Randomized with seed 997125

הבדיקות עוברות והמשחק כמעט גמור. בשבוע הבא נבנה ממשק טקסטואלי למשחק ודרכו נלמד עוד דבר או שניים על אליקסיר. אם אתם בקטע של אתגרים מוזמנים לנסות לכתוב את הממשק בעצמכם במהלך השבוע ולספר לי פה בתגובות איך הולך.

המטרה בשבוע הבא תהיה להריץ ולקבל משהו כזה:

localhost:tictactoe ynonperek$ ./tictactoe 
X/O Game.
Next Move (player: X): 0 0
 X  .  . 
 .  .  . 
 .  .  . 
Next Move (player: O): 0 1
 X  O  . 
 .  .  . 
 .  .  . 
Next Move (player: X): 1 0
 X  O  . 
 X  .  . 
 .  .  . 
Next Move (player: O): 1 1
 X  O  . 
 X  O  . 
 .  .  . 
Next Move (player: X): 2 0
 X  O  . 
 X  O  . 
 X  .  . 
Game over. X won