За последние 24 часа нас посетили 18102 программиста и 1649 роботов. Сейчас ищут 1560 программистов ...

Логическая игра "Реверси" (решение)

Тема в разделе "Решения, алгоритмы", создана пользователем [vs], 14 янв 2010.

  1. [vs]

    [vs] Суперстар
    Команда форума Модератор

    С нами с:
    27 сен 2007
    Сообщения:
    10.559
    Симпатии:
    632
    Отличное управжнение - создание игры. Думаю, тем, кто хочет написать многопользовательскую он-лайн игру, неплохо потренироваться на более простых играх.
    Вот было свободное время - написал Реверси. В игру встроен трехуровневый ИИ. В принципе, можно использовать (!)матрицу любого размера и формы и играть (!) с любым количеством игроков на одной доске. Вот только интерфес было писать уже лень :)
    Код (PHP):
    1. <?php
    2. /*
    3.         Классическая логическая игра "Реверси".
    4.         ИИ с тремя уровнями сложности.
    5.         (c)2010 Vasilii B. Shpilchin
    6. */
    7.  
    8. // Пример матрицы
    9. $matrix[0] = array(0,0,0,0,0,0,0,0);
    10. $matrix[1] = array(0,0,0,0,0,0,0,0);
    11. $matrix[2] = array(0,0,0,0,0,0,0,0);
    12. $matrix[3] = array(0,0,0,'X','O',0,0,0);
    13. $matrix[4] = array(0,0,0,'O','X',0,0,0);
    14. $matrix[5] = array(0,0,0,0,0,0,0,0);
    15. $matrix[6] = array(0,0,0,0,0,0,0,0);
    16. $matrix[7] = array(0,0,0,0,0,0,0,0);
    17.  
    18. // Класс player содержит массивы с координатами
    19. // своих, чужых и свободных полей на матрице.
    20. class player
    21. {
    22.         // Фишки игрока
    23.         public $myself = array();
    24.         // Фишки врага
    25.         public $enemy = array();
    26.         // Свободные поля
    27.         public $free = array();
    28.         // Обозначение своих фишек
    29.         private $c = null;
    30.         // Уровень интеллекта
    31.         private $iq = null;
    32.         // Ссылка на матрицу
    33.         private $matrix;
    34.         
    35.         // Задает цвет игрока (обозначение),
    36.         // уровень интеллекта,
    37.         // и устанавливает ссылку на матрицу
    38.         public function __construct($c, $iq, &$matrix)
    39.         {
    40.                 $this -> c = $c;
    41.                 $this -> iq = $iq;
    42.                 $this -> matrix = &$matrix;
    43.         }
    44.         
    45.         // Ход.
    46.         // Этот метод изменяет матрицу в соответствии с координатами хода.
    47.         // Если не заданых координаты, ход вычисляется методом brain.
    48.         public function go($x = null, $y = null)
    49.         {
    50.                 // Пересчитать массивы своих полей, чужих и свободных
    51.                 $this -> calcArrs();
    52.                 
    53.                 if (is_null($x) || is_null($y))
    54.                 {
    55.                         $go = $this -> brain();
    56.                         // Если нет варианта хода - нечего ходить
    57.                         if (!isset($go[1]))
    58.                         {
    59.                                 return 0;
    60.                         }
    61.                         $x = $go[1];
    62.                         $y = $go[0];
    63.                 }
    64.                 // Походить сюда можно только если ячейка пустая
    65.                 if (isset($this -> free[$y][$x]))
    66.                 {
    67.                         // Влево
    68.                         if (isset($this -> enemy[$y][$x-1]))
    69.                         {
    70.                                 // Движение влево. Сразу проверяется возможность поставить фишку через одну клетку.
    71.                                 for ($xc = $x - 2; $xc >= 0; $xc--)
    72.                                 {
    73.                                         // Если на текущей клетке стоит своя, а справа от нее - чужая, значит линия замкнута.
    74.                                         if (isset($this -> myself[$y][$xc]) && isset($this -> enemy[$y][$xc+1]))
    75.                                         {
    76.                                                 $end = $xc;
    77.                                                 break;
    78.                                         }
    79.                                         // Если вдруг попалась свободная клетка, значит линия обрывается, и в этом направлении
    80.                                         // ход ничего не изменит.
    81.                                         elseif (isset($this -> free[$y][$xc+1]))
    82.                                         {
    83.                                                 break;
    84.                                         }
    85.                                 }
    86.                                 // Если $end не создан, значит нечего менять в этом направлении
    87.                                 if (isset($end))
    88.                                 {
    89.                                         // Заполнение захваченых клеток своими фишками
    90.                                         for ($xc = $x; $xc >= $end; $xc--)
    91.                                         {
    92.                                                 $this -> matrix[$y][$xc] = $this -> c;
    93.                                         }
    94.                                         unset($end);
    95.                                 }
    96.                                 // Расчет изменений в других направлениях аналогичен.
    97.                         }
    98.                         // Вправо
    99.                         if (isset($this -> enemy[$y][$x+1]))
    100.                         {
    101.                                 for ($xc = $x + 2; $xc < 8; $xc++)
    102.                                 {
    103.                                         if (isset($this -> myself[$y][$xc]) && isset($this -> enemy[$y][$xc-1]))
    104.                                         {
    105.                                                 $end = $xc;
    106.                                                 break;
    107.                                         }
    108.                                         elseif (isset($this -> free[$y][$xc-1]))
    109.                                         {
    110.                                                 break;
    111.                                         }
    112.                                 }
    113.                                 if (isset($end))
    114.                                 {
    115.                                         for ($xc = $x; $xc <= $end; $xc++)
    116.                                         {
    117.                                                 $this -> matrix[$y][$xc] = $this -> c;
    118.                                         }
    119.                                         unset($end);
    120.                                 }
    121.                         }
    122.                         // Вверх
    123.                         if (isset($this -> enemy[$y-1][$x]))
    124.                         {
    125.                                 for ($yc = $y - 2; $yc >= 0; $yc--)
    126.                                 {
    127.                                         if (isset($this -> myself[$yc][$x]) && isset($this -> enemy[$yc+1][$x]))
    128.                                         {
    129.                                                 $end = $yc;
    130.                                                 break;
    131.                                         }
    132.                                         elseif (isset($this -> free[$yc+1][$x]))
    133.                                         {
    134.                                                 break;
    135.                                         }
    136.                                 }
    137.                                 if (isset($end))
    138.                                 {
    139.                                         for ($yc = $y; $yc >= $end; $yc--)
    140.                                         {
    141.                                                 $this -> matrix[$yc][$x] = $this -> c;
    142.                                         }
    143.                                         unset($end);
    144.                                 }
    145.                         }
    146.                         // Вниз
    147.                         if (isset($this -> enemy[$y+1][$x]))
    148.                         {
    149.                                 for ($yc = $y + 2; $yc < 8; $yc++)
    150.                                 {
    151.                                         if (isset($this -> myself[$yc][$x]) && isset($this -> enemy[$yc-1][$x]))
    152.                                         {
    153.                                                 $end = $yc;
    154.                                                 break;
    155.                                         }
    156.                                         elseif (isset($this -> free[$yc-1][$x]))
    157.                                         {
    158.                                                 break;
    159.                                         }
    160.                                 }
    161.                                 if (isset($end))
    162.                                 {
    163.                                         for ($yc = $y; $yc <= $end; $yc++)
    164.                                         {
    165.                                                 $this -> matrix[$yc][$x] = $this -> c;
    166.                                         }
    167.                                         unset($end);
    168.                                 }
    169.                         }
    170.                         // Диагональ ПН
    171.                         if (isset($this -> enemy[$y+1][$x+1]))
    172.                         {
    173.                                 for ($yc = $y + 2, $xc = $x + 2; $yc < 8 && $xc < 8; $yc++, $xc++)
    174.                                 {
    175.                                         if (isset($this -> myself[$yc][$xc]) && isset($this -> enemy[$yc-1][$xc-1]))
    176.                                         {
    177.                                                 $end = true;
    178.                                                 $end_y = $yc;
    179.                                                 $end_x = $xc;
    180.                                                 break;
    181.                                         }
    182.                                         elseif (isset($this -> free[$yc-1][$xc-1]))
    183.                                         {
    184.                                                 break;
    185.                                         }
    186.                                 }
    187.                                 if (isset($end))
    188.                                 {
    189.                                         for ($yc = $y, $xc = $x; $yc <= $end_y && $xc <= $end_x; $yc++, $xc++)
    190.                                         {
    191.                                                 $this -> matrix[$yc][$xc] = $this -> c;
    192.                                         }
    193.                                         unset($end);
    194.                                 }
    195.                         }
    196.                         // Диагональ ПВ
    197.                         if (isset($this -> enemy[$y-1][$x+1]))
    198.                         {
    199.                                 for ($yc = $y - 2, $xc = $x + 2; $yc >= 0 && $xc < 8; $yc--, $xc++)
    200.                                 {
    201.                                         if (isset($this -> myself[$yc][$xc]) && isset($this -> enemy[$yc+1][$xc-1]))
    202.                                         {
    203.                                                 $end = true;
    204.                                                 $end_y = $yc;
    205.                                                 $end_x = $xc;
    206.                                                 break;
    207.                                         }
    208.                                         elseif (isset($this -> free[$yc+1][$xc-1]))
    209.                                         {
    210.                                                 break;
    211.                                         }
    212.                                 }
    213.                                 if (isset($end))
    214.                                 {
    215.                                         for ($yc = $y, $xc = $x; $yc >= $end_y && $xc <= $end_x; $yc--, $xc++)
    216.                                         {
    217.                                                 $this -> matrix[$yc][$xc] = $this -> c;
    218.                                         }
    219.                                         unset($end);
    220.                                 }
    221.                         }
    222.                         // Диагональ ЛН
    223.                         if (isset($this -> enemy[$y+1][$x-1]))
    224.                         {
    225.                                 for ($yc = $y + 2, $xc = $x - 2; $yc < 8 && $xc >= 0; $yc++, $xc--)
    226.                                 {
    227.                                         if (isset($this -> myself[$yc][$xc]) && isset($this -> enemy[$yc-1][$xc+1]))
    228.                                         {
    229.                                                 $end = true;
    230.                                                 $end_y = $yc;
    231.                                                 $end_x = $xc;
    232.                                                 break;
    233.                                         }
    234.                                         elseif (isset($this -> free[$yc-1][$xc+1]))
    235.                                         {
    236.                                                 break;
    237.                                         }
    238.                                 }
    239.                                 if (isset($end))
    240.                                 {
    241.                                         for ($yc = $y, $xc = $x; $yc <= $end_y && $xc >= $end_x; $yc++, $xc--)
    242.                                         {
    243.                                                 $this -> matrix[$yc][$xc] = $this -> c;
    244.                                         }
    245.                                         unset($end);
    246.                                 }
    247.                         }
    248.                         // Диагональ ЛВ
    249.                         if (isset($this -> enemy[$y-1][$x-1]))
    250.                         {
    251.                                 for ($yc = $y - 2, $xc = $x - 2; $yc >= 0 && $xc >= 0; $yc--, $xc--)
    252.                                 {
    253.                                         if (isset($this -> myself[$yc][$xc]) && isset($this -> enemy[$yc+1][$xc+1]))
    254.                                         {
    255.                                                 $end = true;
    256.                                                 $end_y = $yc;
    257.                                                 $end_x = $xc;
    258.                                                 break;
    259.                                         }
    260.                                         elseif (isset($this -> free[$yc+1][$xc+1]))
    261.                                         {
    262.                                                 break;
    263.                                         }
    264.                                 }
    265.                                 if (isset($end))
    266.                                 {
    267.                                         for ($yc = $y, $xc = $x; $yc >= $end_y && $xc >= $end_x; $yc--, $xc--)
    268.                                         {
    269.                                                 $this -> matrix[$yc][$xc] = $this -> c;
    270.                                         }
    271.                                         unset($end);
    272.                                 }
    273.                         }
    274.                 }
    275.         }
    276.         
    277.         // Вычисление лучшего хода :-)
    278.         // Лучший ход = ход, при котором захватывается максимум фишек.
    279.         private function brain()
    280.         {
    281.                 // Варианты ходов
    282.                 $ican = array();
    283.                 foreach ($this -> free as $y => $row)
    284.                 {
    285.                         foreach ($row as $x => $t)
    286.                         {
    287.                                 $curr = "$y:$x";
    288.                                 $ican[$curr] = 0;
    289.                                 // Влево
    290.                                 // Расчеты такие же, как при заполнении клеток в методе go.
    291.                                 // Только вместо заполнения происходит расчет количества захватываемых клеток
    292.                                 // по направлениям.
    293.                                 if (isset($this -> enemy[$y][$x-1]))
    294.                                 {
    295.                                         for ($xc = $x - 2; $xc >= 0; $xc--)
    296.                                         {
    297.                                                 if (isset($this -> myself[$y][$xc]) && isset($this -> enemy[$y][$xc+1]))
    298.                                                 {
    299.                                                         $end = $xc;
    300.                                                         break;
    301.                                                 }
    302.                                                 elseif (isset($this -> free[$y][$xc+1]))
    303.                                                 {
    304.                                                         break;
    305.                                                 }
    306.                                         }
    307.                                         if (isset($end))
    308.                                         {
    309.                                                 $ican[$curr] += $x - $end - 1;
    310.                                                 unset($end);
    311.                                         }
    312.                                 }
    313.                                 // Вправо
    314.                                 if (isset($this -> enemy[$y][$x+1]))
    315.                                 {
    316.                                         for ($xc = $x + 2; $xc < 8; $xc++)
    317.                                         {
    318.                                                 if (isset($this -> myself[$y][$xc]) && isset($this -> enemy[$y][$xc-1]))
    319.                                                 {
    320.                                                         $end = $xc;
    321.                                                         break;
    322.                                                 }
    323.                                                 elseif (isset($this -> free[$y][$xc-1]))
    324.                                                 {
    325.                                                         break;
    326.                                                 }
    327.                                         }
    328.                                         if (isset($end))
    329.                                         {
    330.                                                 $ican[$curr] += $end - $x - 1;
    331.                                                 unset($end);
    332.                                         }
    333.                                 }
    334.                                 // Вверх
    335.                                 if (isset($this -> enemy[$y-1][$x]))
    336.                                 {
    337.                                         for ($yc = $y - 2; $yc >= 0; $yc--)
    338.                                         {
    339.                                                 if (isset($this -> myself[$yc][$x]) && isset($this -> enemy[$yc+1][$x]))
    340.                                                 {
    341.                                                         $end = $yc;
    342.                                                         break;
    343.                                                 }
    344.                                                 elseif (isset($this -> free[$yc+1][$x]))
    345.                                                 {
    346.                                                         break;
    347.                                                 }
    348.                                         }
    349.                                         if (isset($end))
    350.                                         {
    351.                                                 $ican[$curr] += $y - $end - 1;
    352.                                                 unset($end);
    353.                                         }
    354.                                 }
    355.                                 // Вниз
    356.                                 if (isset($this -> enemy[$y+1][$x]))
    357.                                 {
    358.                                         for ($yc = $y + 2; $yc < 8; $yc++)
    359.                                         {
    360.                                                 if (isset($this -> myself[$yc][$x]) && isset($this -> enemy[$yc-1][$x]))
    361.                                                 {
    362.                                                         $end = $yc;
    363.                                                         break;
    364.                                                 }
    365.                                                 elseif (isset($this -> free[$yc-1][$x]))
    366.                                                 {
    367.                                                         break;
    368.                                                 }
    369.                                         }
    370.                                         if (isset($end))
    371.                                         {
    372.                                                 $ican[$curr] += $end - $y - 1;
    373.                                                 unset($end);
    374.                                         }
    375.                                 }
    376.                                 // ЛВ
    377.                                 if (isset($this -> enemy[$y-1][$x-1]))
    378.                                 {
    379.                                         for ($yc = $y - 2, $xc = $x - 2; $yc >= 0 && $xc >= 0; $yc--, $xc--)
    380.                                         {
    381.                                                 if (isset($this -> myself[$yc][$xc]) && isset($this -> enemy[$yc+1][$xc+1]))
    382.                                                 {
    383.                                                         $end = $yc;
    384.                                                         break;
    385.                                                 }
    386.                                                 elseif (isset($this -> free[$yc+1][$xc+1]))
    387.                                                 {
    388.                                                         break;
    389.                                                 }
    390.                                         }
    391.                                         if (isset($end))
    392.                                         {
    393.                                                 $ican[$curr] += $y - $end - 1;
    394.                                                 unset($end);
    395.                                         }
    396.                                 }
    397.                                 // ЛН
    398.                                 if (isset($this -> enemy[$y+1][$x-1]))
    399.                                 {
    400.                                         for ($yc = $y + 2, $xc = $x - 2; $yc < 8 && $xc >= 0; $yc++, $xc--)
    401.                                         {
    402.                                                 if (isset($this -> myself[$yc][$xc]) && isset($this -> enemy[$yc-1][$xc+1]))
    403.                                                 {
    404.                                                         $end = $yc;
    405.                                                         break;
    406.                                                 }
    407.                                                 elseif (isset($this -> free[$yc-1][$xc+1]))
    408.                                                 {
    409.                                                         break;
    410.                                                 }
    411.                                         }
    412.                                         if (isset($end))
    413.                                         {
    414.                                                 $ican[$curr] += $end - $y - 1;
    415.                                                 unset($end);
    416.                                         }
    417.                                 }
    418.                                 // ПВ
    419.                                 if (isset($this -> enemy[$y-1][$x+1]))
    420.                                 {
    421.                                         for ($yc = $y - 2, $xc = $x + 2; $yc >= 0 && $xc <= 8; $yc--, $xc++)
    422.                                         {
    423.                                                 if (isset($this -> myself[$yc][$xc]) && isset($this -> enemy[$yc+1][$xc-1]))
    424.                                                 {
    425.                                                         $end = $yc;
    426.                                                         break;
    427.                                                 }
    428.                                                 elseif (isset($this -> free[$yc+1][$xc-1]))
    429.                                                 {
    430.                                                         break;
    431.                                                 }
    432.                                         }
    433.                                         if (isset($end))
    434.                                         {
    435.                                                 $ican[$curr] += $y - $end - 1;
    436.                                                 unset($end);
    437.                                         }
    438.                                 }
    439.                                 // ПН
    440.                                 if (isset($this -> enemy[$y+1][$x+1]))
    441.                                 {
    442.                                         for ($yc = $y + 2, $xc = $x + 2; $yc <= 8 && $xc <= 8; $yc++, $xc++)
    443.                                         {
    444.                                                 if (isset($this -> myself[$yc][$xc]) && isset($this -> enemy[$yc-1][$xc-1]))
    445.                                                 {
    446.                                                         $end = $yc;
    447.                                                         break;
    448.                                                 }
    449.                                                 elseif (isset($this -> free[$yc-1][$xc-1]))
    450.                                                 {
    451.                                                         break;
    452.                                                 }
    453.                                         }
    454.                                         if (isset($end))
    455.                                         {
    456.                                                 $ican[$curr] += $end - $y - 1;
    457.                                                 unset($end);
    458.                                         }
    459.                                 }
    460.                                 // Есди ход бесполезен - удалить этот вариант.
    461.                                 if ($ican[$curr] == 0)
    462.                                 {
    463.                                         unset($ican[$curr]);
    464.                                 }
    465.                         }
    466.                 }
    467.                 // Выбор лучшего варианта хода.
    468.                 // Если iq = 0, выбирается случайный вариант.
    469.                 if ($this -> iq == 0)
    470.                 {
    471.                         $move = array_rand($ican);
    472.                 }
    473.                 else
    474.                 {
    475.                         // Иначе вычисляем лучший вариант
    476.                         asort($ican);
    477.                         end($ican);
    478.                         $best = key($ican);
    479.                         // Если iq=1, просто возвращаем первый лучший вариант
    480.                         if ($this -> iq === 1)
    481.                         {
    482.                                 $move = $best;
    483.                         }
    484.                         // Иначе выбираем случайных из лучший
    485.                         else
    486.                         {
    487.                                 $more = array();
    488.                                 foreach ($ican as $k => $v)
    489.                                 {
    490.                                         if ($v === $ican[$best])
    491.                                         {
    492.                                                 $more[] = $k;
    493.                                         }
    494.                                 }
    495.                                 if (!empty($more))
    496.                                 {
    497.                                         $more = array_values($more);
    498.                                         shuffle($more);
    499.                                         $best = array_shift($more);
    500.                                 }
    501.                                 $move = $best;
    502.                         }
    503.                 }
    504.                 return explode(':', $move);
    505.         }
    506.         
    507.         // Вычисляет удобные массивы.
    508.         // Это делается в целях уменьшения вложености условий в скрипте.
    509.         // Вместо того, чтобы каждый раз проверять, свободна ли клетка,
    510.         // можно просто перебирать массив free.
    511.         public function calcArrs()
    512.         {
    513.                 $this -> myself = array();
    514.                 $this -> enemy = array();
    515.                 $this -> free = array();
    516.                 foreach ($this -> matrix as $y => $row)
    517.                 {
    518.                         foreach ($row as $x => $cell)
    519.                         {
    520.                                 if ($cell === $this -> c)
    521.                                 {
    522.                                         $this -> myself[$y][$x] = 1;
    523.                                 }
    524.                                 elseif ($cell !== 0)
    525.                                 {
    526.                                         $this -> enemy[$y][$x] = 1;
    527.                                 }
    528.                                 else
    529.                                 {
    530.                                         $this -> free[$y][$x] = 1;
    531.                                 }
    532.                         }
    533.                 }
    534.         }
    535. }
    536.  
    537. // Игра двух компьютеров :-)
    538. function print_m(&$matrix)
    539. {
    540.         foreach ($matrix as $row)
    541.         {
    542.                 foreach ($row as $cell)
    543.                 {
    544.                         if ($cell === 0)
    545.                         {
    546.                                 $cell = '.';
    547.                         }
    548.                         echo "$cell ";
    549.                 }
    550.                 echo "\n";
    551.         }
    552.         echo "\r\n";
    553. }
    554.  
    555. $player1 = new player('X', intval($_GET['iq1']), $matrix);
    556. $player2 = new player('O', intval($_GET['iq2']), $matrix);
    557.  
    558. echo '<pre>';
    559. for ($i=1; $i<=(8*8)-4; $i++)
    560. {
    561.         is_int($i/2)?$player2->go():$player1->go();
    562.         print_m($matrix);
    563. }
    564. echo "Счет:\r\n";
    565. $player1 -> calcArrs();
    566. $p1 = 0;
    567. $p2 = 0;
    568. foreach ($player1 -> myself as $arr)
    569. {
    570.         $p1 += array_sum($arr);
    571. }
    572. foreach ($player1 -> enemy as $arr)
    573. {
    574.         $p2 += array_sum($arr);
    575. }
    576. echo "Player1: $p1\r\nPlayer2: $p2";
    577. ?>
    Т.к. при iq=1 у бота ход всегда будет одинаков для конкретной ситуации, если играют два бота с таким iq, резултат будет всегда одинаков.
    Демо: http://team16.ru/revercy.php?iq1=1&iq2=1
     
  2. TheShock

    TheShock Активный пользователь

    С нами с:
    30 май 2009
    Сообщения:
    1.255
    Симпатии:
    0
    Адрес:
    Київ
    is_int($i/2) == !$i%2
    ;)

    уверен, писать это было безумно интересно )

    пс. имхо, всё-таки Гоу и Брейн можно было на несколько методов разбить.
     
  3. Alost

    Alost Активный пользователь

    С нами с:
    7 фев 2009
    Сообщения:
    335
    Симпатии:
    0
    Адрес:
    Город вокруг невы
    стратегия для победы в реверси это больше чем просто за ход брать максимальное кол-во фишек.
    Очень большое значение имеет "занятие" стратегических точек(места откуда твои фишки уже не перебьют).
     
  4. [vs]

    [vs] Суперстар
    Команда форума Модератор

    С нами с:
    27 сен 2007
    Сообщения:
    10.559
    Симпатии:
    632
    Верно. Еще есть невыгодные точки - через клетку от границы поля, т.к. у сопернека может быть возможность занять точку у границы. Но брать максимальное количество - самая простая тактика.
     
  5. nimistar

    nimistar Активный пользователь

    С нами с:
    30 май 2007
    Сообщения:
    919
    Симпатии:
    0
    может использовать вес клетки ? 0 - не желательно, 1 -нестрашно 2 -вкусно ... и использовать вес клеток для принятия решений! ...(это минимум) там более интересна стратегия - в вытеснении противника с края (установка своей на границе поля через одну от противника), то есть есть еще комбинации ..... :) ...и тогда искусственный интеллект будет не победим в своей непогрешимости
     
  6. antonn

    antonn Активный пользователь

    С нами с:
    10 июн 2007
    Сообщения:
    2.996
    Симпатии:
    0
    насколько понимаю реверси это то, во что двоечники часто играют на последних партах - точки у нас называлось :)
    пытался реализовать, в принципе работает, но не оформлено и забил :)
     
  7. Alost

    Alost Активный пользователь

    С нами с:
    7 фев 2009
    Сообщения:
    335
    Симпатии:
    0
    Адрес:
    Город вокруг невы
    Если бы наши двоенчники играли в реверси на задних партах, то передние наверно доказывали теорему ферма.
     
  8. antonn

    antonn Активный пользователь

    С нами с:
    10 июн 2007
    Сообщения:
    2.996
    Симпатии:
    0
    ну возможно я не про реверси. Точки - это где нужно ставить точки (невероятно, да? =)) в узлах клеток, и захватывать области содержащие точки другого участника.
    у меня была одна полностью "отыграная" тетрадь на 64листа в школе (за последний учебный год, еще две от игры в "семечки"), и две А4 тетради на 60 листов в институте (и одна на 120 листов от игр в крестики-нолики 5*5), храню, ностальжи, показательно сколько времени потрачено зря =)

    PS Вот и играл я, и что получилось? сижу теперь я на сайте php и компилю прожки... не повторяйте моих ошибок %)))
     
  9. antonn

    antonn Активный пользователь

    С нами с:
    10 июн 2007
    Сообщения:
    2.996
    Симпатии:
    0
    и еще - сложность игры определяет не кол-во вариаций стратегий, а уровнем соперника. Если оба двоечники - то хоть шахматы, хоть реверси - один фиг двоечники :)