Как я моделирую шахматную доску при программировании компьютера для игры шахмат?

Простой подход должен использовать 8x8 целочисленный массив. Используйте 0 для пустых квадратов и присвойте значения для частей:

1 white pawns
2 white knights
3 white bishops
4 white rooks
5 white queens
6 white king

Black pieces use negative values
-1 black pawn
-2 black knight
etc

8| -4 -2 -3 -5 -6 -3 -2 -4
7| -1 -1 -1 -1 -1 -1 -1 -1
6|  0  0  0  0  0  0  0  0
5|  0  0  0  0  0  0  0  0
4|  0  0  0  0  0  0  0  0
3|  0  0  0  0  0  0  0  0
2|  1  1  1  1  1  1  1  1 
1|  4  2  3  5  6  3  2  4
  -------------------------
   1  2  3  4  5  6  7  8

перемещения Части могут быть вычислены при помощи индексов массива. Например, белые пешки перемещаются путем увеличения индекса строки 1, или 2, если это - первый шаг пешки. Таким образом, белая пешка на [2] [1] могла переместиться в [3] [1] или [4] [1].

Однако это простое 8x8 представление в виде массива имеет шахматную доску, имеет несколько проблем. Прежде всего при перемещении 'скользящих' фигур как грачи, епископы и королевы, необходимо постоянно проверять индексы, чтобы видеть, отъехала ли часть плата.

Большая часть chessprograms сегодня, особенно те, которые работают на ЦП на 64 бита, используют растровый подход, чтобы представить шахматную доску и генерировать перемещения. x88 является альтернативным обозначением модели платы для машин без центральных процессоров на 64 бита.

При создании шахматного движка я изначально использовал подход [8] [8], однако недавно я изменил свой код представлять шахматную доску, используя массив из 64 предметов. Я обнаружил, что эта реализация была примерно на 1/3 более эффективной, по крайней мере, в моем случае.

Одна из вещей, которую вы хотите учитывать при использовании подхода [8] [8], - это описание позиций. Например, если вы хотите описать правильный ход для шахматной фигуры, вам потребуется 2 байта для этого. Хотя с массивом элементов [64] вы можете сделать это одним байтом.

Для преобразования из позиции на табло [64] в табло [8] [8] вы можете просто использовать следующие вычисления:

Row = (byte) (index / 8)

Col = (byte) (index% 8)

Хотя я обнаружил, что вам никогда не придется делать это во время рекурсивного поиска перемещения, который чувствителен к производительности.

Существует, конечно, много различных способов представить шахматную доску, и лучший способ будет зависеть от того, что является самым важным для Вас.

Ваши два основных варианта между скоростью и кодируют ясность.

, Если скорость является Вашим приоритетом тогда, необходимо использовать 64 типа данных bit для каждого набора частей на плате (например, белые пешки, черные королевы, en passant пешки). Можно тогда использовать в своих интересах собственные битовые операции при генерации перемещений и тестировании законности перемещения.

, Если ясность кода является приоритетом тогда, забывают разрядную перестановку и идут для приятно абстрактных типов данных как другие, уже предложили. Просто помните, если Вы идете этим путем, вероятный удар производительности, перекрывающей раньше.

Для начинания Вас посмотрите на код для Лукавый (C) и SharpChess (C#).

Ну, не уверенный, если это помогает, но Темно-Синий, использовал единственное 6-разрядное число для представления определенной позиции по плате. Это помогло ему сохранить место на - микросхема по сравнению с, он - конкурент, который использовал 64-разрядный bitboard.

Это не могло бы быть релевантно, так как возможности, у Вас могли бы быть регистры на 64 бита на Ваших целевых аппаратных средствах, уже.

Используя bitboard был бы эффективный способ представить состояние шахматной доски. Основная идея состоит в том, что Вы используете 64 бита bitsets для представления каждого из квадратов на плате, где сначала укусил, обычно представляет A1 (нижний левый квадрат), и 64-й бит представляет H8 (по диагонали противоположный квадрат). Каждый тип части (пешка, король, и т.д.) каждого плеера (черный, белый) получает свою собственную разрядную плату, и все 12 из этих плат составляет игровое состояние. Для получения дополнительной информации проверьте эту статью .

Я использовал бы многомерный массив так, чтобы каждый элемент в массиве был ссылкой сетки на квадрат на плате.

Таким образом

board = arrary(A = array (1,2,3,4,5,5,6,7,8),
               B = array (12,3,.... etc...
               etc...          
               )

Тогда обшивают [1] , тогда квадрат платы A1.

В действительности Вы использовали бы числа не буквы, чтобы помочь сохранить Вашу логику математики для того, где частям позволяют переместиться в простой.

int[8][8]

0=no piece
1=king
2=queen
3=rook
4=knight
5=bishop
6=pawn

используют положительный ints для белого и отрицательного ints для черного цвета

Я на самом деле не смоделировал бы шахматную доску, я просто смоделирую положение частей. У Вас могут быть границы для шахматной доски затем.

Piece.x= x position of piece
Piece.y= y position of piece

Массив был бы, вероятно, прекрасен. Если бы Вы хотели более удобные средства "пересечения" платы, Вы могли бы легко создать методы к краткому обзору далеко детали реализации структуры данных.

Первоначально, используйте 8 * 8 целочисленных массивов для представления шахматной доски.

можно начать программировать использование этой нотации. Дайте значения точки для частей. Например:

**White**
9 = white queen
5 = white rook
3 = bishop
3 = knight
1 = pawn

**black**
-9 = white queen
-5 = white rook
-3 = bishop
-3 = knight
-1 = pawn

White King: very large positive number
Black King: very large negative number

и т.д. (Отмечают, что точки, данные выше, являются приближениями торгового питания каждой шахматной части)

После того, как Вы разрабатываете основные магистрали своего приложения и ясно понимаете работу используемых алгоритмов, попытайтесь улучшить производительность при помощи разрядных плат.

В разрядных платах, Вы используете восемь 8 разрядных слов для представления плат. Этому представлению нужно управление по каждой шахматной части. В плате на один бит Вы будете хранить положение грача в другом при хранении положения рыцаря... и т.д.

, Разрядные платы могут улучшить производительность приложения очень, потому что управление частями с разрядными платами очень легко и быстро.

, Поскольку Вы указали,

Большая часть chessprograms сегодня, особенно те, которые работают на ЦП на 64 бита, используют растровый подход, чтобы представить шахматную доску и генерировать перемещения. x88 является альтернативным обозначением модели платы для машин без центральных процессоров на 64 бита.

Массив из 120 байт.

Это шахматная доска размером 8x8, окруженная контрольными клетками (например, 255, чтобы указать, что фигура не может перейти на это поле). Стражи имеют глубину два, так что рыцарь не может перепрыгнуть.

Чтобы двигаться вправо, добавьте 1. Для движения влево добавьте -1. Вверх 10, вниз -10, вверх и вправо по диагонали 11 и т. Д. Квадрат A1 - это индекс 21. H1 - это индекс 29. H8 - это индекс 99.

Все сделано для простоты. Но он никогда не будет таким быстрым, как битборды.