Dagaz: Эволюция вместо революции03.02.2017 11:19

Помимо этого общего недостатка (а также фатального недостатка, связанного с закрытостью исходных кодов), каждый из перечисленных проектов обладает и индивидуальными особенностями. Так, Zillions of Games использует лиспо-подобный DSL, весьма облегчающий процесс описания настольных игр, но несколько ограничивающий функциональность доступную разработчику. Реализовать, с его помощью, можно действительно очень многое, но далеко не всё. Некоторые игры, такие как «Ритмомахия» или «Каури», разработать на чистом ZRF решительно невозможно. Иные, наподобие «Ko Shogi» или «Gwangsanghui», сделать можно, но столь сложным образом, что существенно страдает их производительность (а следовательно и «интеллект» AI).

Расширение Axiom Development Kit появилось как попытка улучшения Zillions of Games. Поскольку эта библиотека оперирует числами (а не только булевскими флагами, как Zillions of Games), такие игры как «Ритмомахия» становятся реализуемыми, но сам процесс разработки местами напоминает кошмар (я немного писал об этом). В качестве DSL, Axiom использует Forth Script (подмножество языка Форт) и этот язык (а главное отладка программ на нём) действительно намного сложнее тёплого и лампового ZRF. Кроме того, сделать с его помощью можно далеко не всё. Разработка таких игр как «Таврели» или, упомянутая выше «Каури», по прежнему, не представляется возможной.

Про «LUDÆ» я мало что могу рассказать (поскольку никогда не видел этого продукта вживую), что же касается Jocly, то недостатком этой системы (на мой взгляд) является полный отказ от использования какого либо DSL для описания игр. Фактически, это MVC-фреймворк для разработки настольных игр на языке JavaScript. Даже внесение довольно тривиальных изменений в уже разработанные игры превращается в весьма трудоёмкий процесс. Игры, созданные самими авторами, также не лишены серьёзных ошибок (я связываю это со сложностью процесса разработки). Например, в «Алькуэрке» возникают ситуации при которых одни и те же фигуры «берутся» по нескольку раз за ход, а в «Турецких шашках» ошибочно действует правило «Турецкого удара» — главное что отличает эту игру от других шашечных систем.

     (grid
         (start-rectangle 6 6 55 55)
         (dimensions
             ("a/b/c/d/e/f/g/h" (50 0)) ; files
             ("8/7/6/5/4/3/2/1" (0 50)) ; ranks
         )
         (directions (n 0 -1) (s 0 1) (e 1 0) (w -1 0))
     )

    design.addDirection("w");
    design.addDirection("e");
    design.addDirection("s");
    design.addDirection("n");

    design.addPosition("a8", [0, 1, 8, 0]);
    design.addPosition("b8", [-1, 1, 8, 0]);
    ...

ZrfDesign.prototype.navigate = function(aPlayer, aPos, aDir) {
  var dir = aDir;
  if (typeof this.players[aPlayer] !== "undefined") {
      dir = this.players[aPlayer][aDir];
  }
  if (this.positions[aPos][dir] !== 0) {
      return aPos + this.positions[aPos][dir];
  } else {
      return null;
  }
}

design.addPlayer("White", [1, 0, 3, 2]);

(define checker-shift (
   $1 (verify empty?)
   (if (in-zone? promotion)
      (add King)
    else
      add
   )
))

    design.addCommand(1, ZRF.FUNCTION,	24);	// from
    design.addCommand(1, ZRF.PARAM,	0);	// $1
    design.addCommand(1, ZRF.FUNCTION,	22);	// navigate
    design.addCommand(1, ZRF.FUNCTION,	1);	// empty?
    design.addCommand(1, ZRF.FUNCTION,	20);	// verify
    design.addCommand(1, ZRF.IN_ZONE,	0);	// promotion
    design.addCommand(1, ZRF.FUNCTION,	0);	// not
    design.addCommand(1, ZRF.IF,	4);
    design.addCommand(1, ZRF.PROMOTE,	1);	// King
    design.addCommand(1, ZRF.FUNCTION,	25);	// to
    design.addCommand(1, ZRF.JUMP,	2);
    design.addCommand(1, ZRF.FUNCTION,	25);	// to
    design.addCommand(1, ZRF.FUNCTION,	28);	// end

    design.addPiece("Man", 0);
    design.addMove(0, 0, [3, 3], 0);
    design.addMove(0, 0, [0, 0], 0);
    design.addMove(0, 0, [1, 1], 0);
    design.addMove(0, 1, [3], 1);
    design.addMove(0, 1, [0], 1);
    design.addMove(0, 1, [1], 1);

С Шашками всё тоже не просто. Практически во всех традиционных шашечных играх (за исключением Фанороны), игрок обязан продолжать взятия, пока есть такая возможность. Это означает, что выполняя частичный ход содержащий взятие, мы ещё не знаем, завершает он допустимый составной ход или нет.

(define checker-captured-find
   mark
   (if (on-board? $1)  
      $1    
      (if (and enemy? (on-board? $1) (empty? $1) (not captured?)) 
          (set-flag more-captures true)
      )
   )
   back
)

(define king-captured-find
   mark
   (while (and (on-board? $1) (empty? $1))
      $1
   )
   (if (on-board? $1)  
      $1    
      (if (and enemy? (empty? $1) (not captured?)) 
          (set-flag more-captures true)
      )
   )
   back
)

(define checker-jump (
  (verify (not captured?))    
  $1
  (verify enemy?)
  (verify (not captured?))
  $1
  (verify empty?)
  (set-flag more-captures false)
  (if (in-zone? promotion)
      (king-captured-find $1)
      (king-captured-find $2)
      (king-captured-find $3)
   else
      (checker-captured-find $1)
      (checker-captured-find $2)
      (checker-captured-find $3)
  )
  (if (flag? more-captures)
      (opposite $1)
      (markit)
      $1
  )
  (if (not (flag? more-captures))
      (opposite $1) 
      (if enemy?
          capture
      )
      $1
      (capture-all)
  )
  (if (in-zone? promotion)
      (if (flag? more-captures)
          (add-partial King jumptype)
       else
          (add-partial King notype)
      )
   else
      (if (flag? more-captures)
          (add-partial jumptype)
       else
          (add-partial notype)
      )
  )
))

• (option «pass partial» true) — разрешает прерывать цепочку взятий
• (option «maximal captures» true) — взять максимальное количество фигур
• (option «maximal captures» 2) — взять максимальное количество дамок (если количество взятых дамок одинаково — брать максимальное количество фигур)

		if(aGame.g.captureLongestLine) {
			var moves0=this.mMoves;
			var moves1=[];
			var bestLength=0;
			for(var i in moves0) {
				var move=moves0[i];
				if(move.pos.length==bestLength)
					moves1.push(move);
				else if(move.pos.length>bestLength) {
					moves1=[move];
					bestLength=move.pos.length;
				}
			}
			this.mMoves=moves1;
		}

(define slide (
  $1 (while empty? add $1) 
  (verify enemy?)
  add
))

(define slide-1 (
  $1 (verify enemy?)
  add
))

(define slide-2 (
  $1 (verify empty?)
  $1 (verify enemy?)
  add
))

(define slide-3 (
  $1 (verify empty?)
  $1 (verify empty?)
  $1 (verify enemy?)
  add
))
...

(define king-shift (
   $1 (while empty?
       add $1
   )
))

    design.addCommand(3, ZRF.FUNCTION,	24);	// from
    design.addCommand(3, ZRF.PARAM,	0);	// $1
    design.addCommand(3, ZRF.FUNCTION,	22);	// navigate
    design.addCommand(3, ZRF.FUNCTION,	1);	// empty?
    design.addCommand(3, ZRF.FUNCTION,	0);	// not
    design.addCommand(3, ZRF.IF,	7);
    design.addCommand(3, ZRF.FORK,	3);
    design.addCommand(3, ZRF.FUNCTION,	25);	// to
    design.addCommand(3, ZRF.FUNCTION,	28);	// end
    design.addCommand(3, ZRF.PARAM,	1);	// $2
    design.addCommand(3, ZRF.FUNCTION,	22);	// navigate
    design.addCommand(3, ZRF.JUMP,	-8);
    design.addCommand(3, ZRF.FUNCTION,	28);	// end

• Во время генерации хода, доска доступна в том состоянии, каким оно было на момент начала генерации. Перемещаемая фигура не убирается с исходного поля и, разумеется, не устанавливается на текущее. Это требование понятно (особенно если вспомнить об иммутабельности доски), но в реальной жизни бывает крайне неудобным.
• Состояние флагов (битовых переменных) и позиционных флагов (битовых переменных, привязанных к конкретным позициям) доступно лишь в процессе генерации хода. В случае Zillions of Games, рассматривающей каждый частичный ход как отдельный, это сильно снижает их полезность, но мы должны обеспечить аналогичную семантику, чтобы всё работало.
• Хранение атрибутов (именованных битовых флагов, привязанных к фигурам) не ограничено генерацией хода. Атрибуты — часть состояния доски. Кстати, сами фигуры тоже иммутабельны, изменяя им какой либо из атрибутов, мы создаём новую фигуру.
• Поскольку состояние доски доступно на момент начала генерации хода, прочитать атрибут можно лишь по месту начального расположения фигуры, но если мы хотим изменить атрибут, то делать это надо на той позиции, где фигура завершает своё перемещение (то есть окажется в момент завершения хода). Если изменить атрибут на другом поле (например на исходном) — фатальной ошибки не произойдёт. Значение просто не установится.
• Каскадные ходы не передаются при клонировании ходов. Вернее передаются, но только если отключена опция »discard cascades». Ни разу не видел игры, где это используется!
• Промежуточные взятия и сбросы фигур также не передаются в клонированный ход. В результате, взятие дамкой в «Русских шашках» превращается в настоящую головоломку (от точки возможного завершения хода командой add, выполняемой в цикле, необходимо двигаться назад, чтобы взять ранее перепрыгнутую вражескую фигуру.
• Мы не можем взять фигуру, у которой на том же ходу изменился тип, значение атрибута или владелец! Это больше похоже на баг, но из песни слова не выкинешь.
• Если ход завершается на позиции содержащей фигуру, «шахматное взятие» выполняется автоматически. Если на том же поле вызвать команду capture явно, будет удалена и та фигура, которая выполняла ход (таким образом можно делать фигуры-камикадзе). Аналогичным образом (командой create) можно менять тип и владельца фигуры.
• Если включена опция отложенного взятия, при продолжении хода, все взятия фигур должны перемещаться в последний частичный ход составного хода. Этой опции, по понятным причинам, нет в ZRF, но когда она нужна, её так не хватает! Реализация правила «Турецкого удара» в ZRF — это форменное мучение! К счастью, мы рассматриваем составной ход целиком. Почему бы не реализовать такую полезную опцию?

var CompleteMove = function(board, gen) {
  var t = 1;
  if (Model.Game.passPartial === true) {
      t = 2;
  }
  for (var pos in board.pieces) {
       var piece = board.pieces[pos];
       if ((piece.player === board.player) || (Model.Game.sharedPieces === true)) {
           for (var move in Model.Game.design.pieces[piece.type]) {
                if ((move.type === 0) && (move.mode === gen.mode)) {
                    var g = f.copy(move.template, move.params);
                    if (t > 0) {
                        g.moveType = t;
                        g.generate();
                        if (g.moveType === 0) {
                            CompleteMove(board, g);
                        }
                    } else {
                        board.addFork(g);
                    }
                    t = 0;
                }
           }
       }
  }
}

ZrfBoard.prototype.generateInternal = function(callback, cont) {
  this.forks = [];
  if ((this.moves.length === 0) && (Model.Game.design.failed !== true)) {
      var mx = null;
      for (var pos in this.pieces) {
           var piece = this.pieces[pos];
           if ((piece.player === this.player) || (Model.Game.sharedPieces === true)) {
               for (var move in Model.Game.design.pieces[piece.type]) {
                   if (move.type === 0) {
                       var g = Model.Game.createGen(move.template, move.params);
                       g.init(this, pos);
                       this.addFork(g);
                       if (Model.Game.design.modes.length > 0) {
                           var ix = Model.find(Model.Game.design.modes, move.mode);
                           if (ix >= 0) {
                               if ((mx === null) || (ix < mx)) {
                                   mx = ix;
                               }
                           }
                       }
                   }
               }
           }
      }
      for (var tp in Model.Game.design.pieces) {
           for (var pos in Model.Game.design.positions) {
               for (var move in Model.Game.design.pieces[tp]) {
                    if (move.type === 1) {
                        var g = Model.Game.createGen(move.template, move.params);
                        g.init(this, pos);
                        g.piece = new ZrfPiece(tp, this.player);
                        g.from  = null;
                        g.mode  = move.mode;
                        this.addFork(g);
                        if (Model.Game.design.modes.length > 0) {
                            var ix = Model.find(Model.Game.design.modes, move.mode);
                            if (ix >= 0) {
                                if ((mx === null) || (ix < mx)) {
                                    mx = ix;
                                }
                            }
                        }
                    }
               }
           }
      }
      while ((this.forks.length > 0) && (callback.checkContinue() === true)) {
           var f = this.forks.shift();
           if ((mx === null) || (Model.Game.design.modes[mx] === f.mode)) {
               f.generate();
               if ((cont === true) && (f.moveType === 0)) {
                   CompleteMove(this, f);
               }
           }
      }
      if (cont === true) {
          Model.Game.CheckInvariants(this);
          Model.Game.PostActions(this);
          if (Model.Game.passTurn === 1) {
              this.moves.push(new ZrfMove());
          }
          if (Model.Game.passTurn === 2) {
              if (this.moves.length === 0) {
                  this.moves.push(new ZrfMove());
              }
          }
      }
  }
  if (this.moves.length === 0) {
      this.player = 0;
  }
  return this.moves;
}

(define approach-capture (
    $1
    (verify empty?)
    to
    $1
    (verify enemy?)
    capture
    (while (enemy? $1) $1 capture)
    (add-partial capturing)
))

(define withdrawl-capture (
    $1
    (verify empty?)
    to
    back
    (opposite $1)
    (verify enemy?)
    capture
    (while (enemy? (opposite $1)) (opposite $1) capture)
    (add-partial capturing)
))

• maximal-captures = true — Правило большинства (например в «Международных шашках»)
• pass-partial = true — Возможность прерывания составного хода (как в «Фанороне»)
• pass-turn = true — Возможность пропуска хода
• pass-turn = forced — Возможность пропуска хода при отсутствии других ходов
• discard-cascades = true — Сброс каскадных перемещений при завершении версии хода
• include-off-pieces = true — Учёт фигур находящихся в резерве при подсчёте
• recycle-captures = true — Перевод игр в резерв при выполнении взятия
• smart-moves = true — Режим «интеллектуального» UI (при наличии единственного хода)
• smart-moves = from — Перемещает фигуру при указании стартовой позиции
• smart-moves = to — Перемещает фигуру при указании целевой позиции

• zrf-advanced = true — Все опции zrf-advanced
• zrf-advanced = simple — Упрощённая семантика перемещения фигур при генерации хода
• zrf-advanced = fork — Взятия и сбросы переносятся через ZRF_FORK
• zrf-advanced = composite — Доступность флагов установленных предыдущими частичными ходами
• zrf-advanced = mark — Поддержка вложенных вызовов mark/back
• zrf-advanced = delayed — Реализация правила «Турецкого удара» (во всех шашках, кроме турецких)
• zrf-advanced = last — Очистка пометок last-from и last-to при завершении составного хода
• zrf-advanced = shared — Возможность хода чужими фигурами (как в «Ставропольских шашках»)
• zrf-advanced = partial — Возможность продолжения составного хода не только фигурой, завершившей частичных ход
• zrf-advanced = numeric — Поддержка работы с числовыми значениями (как в «Ритмомахии»)
• zrf-advanced = foreach — Поддержка оператора foreach для поиска позиции на доске
• zrf-advanced = repeat — Поддержка команды повторения хода (пропуск хода всеми игроками)
• zrf-advanced = player — Поддержка команд для определения текущего игрока, следующего, принадлежности фигур
• zrf-advanced = global — Поддержка глобальных значений состояния (как в Axiom)

• board-model = heap — Хранение неупорядоченного множества фигур на позиции (как в манкалах)
• board-model = stack — Хранение упорядоченного множества фигур на позиции (как в «Столбовых шашках»)
• board-model = quantum — Квантовая доска (фигура одновременно присутствует на нескольких позициях)