Метод программирования: Как создать простую карточную игру

Ответ Мачека хорош в том, что касается создания колоды.

Вы также спрашивали о других сущностях.

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

Чтобы реализовать человека-игрока, вы взаимодействуете с экраном / мышью / клавиатурой; для реализации игроков, управляемых машиной, у вас есть рука, и вы можете видеть некоторые центральные карты на столе (все игроки должны знать о центральном столе, на котором хранятся все карты, которые будут на столе).

Отсюда логика зависит от того, в какую игру вы играете.

Как только ваш «Игрок» (ИИ) получит ход (например, для вашего объекта игрока вызывается метод takeTurn ), он должен изучить свои карты и принять правильные решения - взять карты из складывает на стол или кладет карты из руки на стол. (На столе почти наверняка есть как минимум два стека, к которым игрок может получить доступ - «Draw» и «Discard».)

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

Когда каждый игрок закончит свой ход, он должен вернуться. Он не может напрямую вызвать следующего игрока (иначе вы начнете наращивать стек), поэтому вам нужна какая-то форма управления ходом, которая может вызывать игроков по порядку.Этот централизованный контроль также не позволяет игрокам знать друг о друге, в этом им на самом деле не должно быть (одна из лучших тактик объектно-ориентированного проектирования состоит в том, что каждый объект должен знать как можно меньше о других объектах).

... Все еще думаю ... Я могу добавить еще ...

Не беспокойтесь о поиске пакета AI

Вы узнаете больше и получите большее удовлетворение, написав код «AI» себя.

Начните с простого, просто подумайте:

• состояние игры - какие карты были сыграны или просмотрены, какие карты видны всем игрокам
• стратегия - как компьютерный игрок реагирует на его текущая рука и ее знание игрового состояния

, как только вы это заработаете, вы сможете разработать более сложные стратегии:

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

, тогда, если вы хотите получить действительно изощренный, вы можете начать изучать моделирование оппонента

Я не уверен, какую карточную игру вы хотите создать, но наиболее распространенный способ создания такого рода ИИ - это создание дерева возможных вариантов. Я не Думаю, есть библиотека, чтобы сделать это как таковое, но Ruby может легко создавать деревья.

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

Если у вас нет всей информации (например, вы не можете видеть карты оппонентов) вы моделируете это. Под моделированием я подразумеваю предположение. Среднее значение всех имитаций / предположений даст вам хорошее представление о том, какое дерево ches, вероятно, будут лучшими.

Если вы можете сделать все, что у вас хорошо получается (а это действительно хорошее упражнение), о котором написаны сотни статей об ИИ, Google станет вашим другом. Единственная проблема с подходом, который я описал, заключается в том, что он может быть очень медленным, но есть много умных методов для его ускорения, таких как таблицы транспонирования, альфа-бета-обрезка и т. Д., Которые я пока не рекомендую вам искать.

Вместо того, чтобы втиснуть все это в комментарий, я добавляю это как примечание для людей, которые могут найти его полезным. Собственный Ruby 1.9 Array # shuffle! и Array # shuffle на самом деле использует алгоритм перемешивания Knuth-Fisher-Yates .

ruby-1.9.1-p376 / array.c

/*
 *  call-seq:
 *     array.shuffle!        -> array
 *  
 *  Shuffles elements in _self_ in place.
 */

static VALUE
rb_ary_shuffle_bang(VALUE ary)
{
    long i = RARRAY_LEN(ary);

    rb_ary_modify(ary);
    while (i) {
    long j = rb_genrand_real()*i;
    VALUE tmp = RARRAY_PTR(ary)[--i];
    RARRAY_PTR(ary)[i] = RARRAY_PTR(ary)[j];
    RARRAY_PTR(ary)[j] = tmp;
    }
    return ary;
}


/*
 *  call-seq:
 *     array.shuffle -> an_array
 *  
 *  Returns a new array with elements of this array shuffled.
 *     
 *     a = [ 1, 2, 3 ]           #=> [1, 2, 3]
 *     a.shuffle                 #=> [2, 3, 1]
 */

static VALUE
rb_ary_shuffle(VALUE ary)
{
    ary = rb_ary_dup(ary);
    rb_ary_shuffle_bang(ary);
    return ary;
}

Что-то очень простое для начала:

class CardGame
  DECK = %w[A 2 3 4 5 6 7 8 9 T J Q K].product(%w[c d h s]).map(&:join)

  def initialize(decks=1)
    @decks = decks
  end

  def shuffle
    @playing_deck = (DECK*@decks).shuffle
  end

  def deal(players=1, cards=5)
    shuffle
    @dealt = Array.new(players) { Array.new }

    @dealt.map { |hand| cards.times { hand << @playing_deck.pop } }
  end

  def display
    @dealt.each_with_index { |cards, i| puts "Player #{i+1}: #{cards.join(' | ')}" }
    puts "Cards used: #{@dealt.flatten.size}"
    puts "Cards remaining: #{@playing_deck.size}"
  end

  private :shuffle   
end

game1 = CardGame.new   
game1.deal   
game1.display    
puts 
game1.deal(4)  
game1.display   
puts   
game2 = CardGame.new(2)   
game2.deal(6,10)   
game2.display