98821

Карточная игра

Курсовая

Информатика, кибернетика и программирование

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

Русский

2015-11-07

1.91 MB

9 чел.

Министерство образования Республики Беларусь

Учреждение образования «Белорусский государственный  университет                                      информатики   и радиоэлектроники»

Факультет компьютерных систем и сетей

Кафедра программного обеспечения информационных технологий

Дисциплина: ОСиСП

                     ПОЯСНИТЕЛЬНАЯ ЗАПИСКА

                               к курсовому проекту

Тема: «Карточная игра»»

БГУИР КП  1-40 01 01  120  ПЗ

Выполнила: студентка гр. 151002

Шлеведа В.О.

Проверил:

Синицын С.И.

                                    

                                  Минск, 2014

СОДЕРЖАНИЕ

Введение………………………………………………………………….....4

1. Аналитический обзор литературы………………………………...…....6

 1.1. Сравнение аналогов...……………….……………….…………….....6

 1.2. Назначение разработки………….……………………………….…..8

 1.3. Состав выполняемых функций………………………………………8

 1.4. Требования к временным характеристикам………………………...8

 1.5. Требования к составу и параметрам технических и программных средств………………………………………………………………………8

 1.6. Требования к информационной и программной совместимости…9

 1.7. Обоснование выбора языка и сред разработки…………………….9

2. Моделирование предметной области и разработка функциональных требований……………...…………………………………………………11

 2.1. Описание функциональности ПС………………………………….11

3. Разработка программного средства…………………………………...13

 3.1. Класс Karta…………………………………………………………..13

 3.2. Класс main…………………………………………………………...13

 3.3. Класс start……………………………………………………………13

4. Тестирование…………………………………………………………...18

5. Методика использования разработанного программного средства...22

Заключение……………………………………………………………..…27

Список литературы……………………………………………………….28

Листинг программы………………………………………………………29


ВВЕДЕНИЕ

Рынок компьютерных игр сегодня активно развивается и позволяет получать большую прибыль. Тот скачок в развитии, который был произошел в этой области за последнее время, просто впечатляет! Стратегии создания и продвижения игр, качественные графика и звук, возможность скачать игры бесплатно или найти игры онлайн - все это делает их очень популярными у людей разных возрастов. Современный рынок PC-игр представлен разнообразными жанрами для любых возрастов и каждый найдет игру по себе, невзирая на то, любитель вы или профессиональный геймер. С помощью игр тренируются логическое мышление, внимание и скорость реакции.

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

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

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

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

Темой моего курсового проекта является карточная игра «Fool». Это типичный пример коммерческой (интеллектуальной) карточной игры. Случайность в ней присутствует в значительно меньшей степени, чем в азартных карточных играх. Игра является одной из самых популярных карточных игр на постсоветском пространстве. По популярности она опережает даже покер и преферанс. Игра помогает занять время, развлекает пользователей, но, в то же время, требует умственных затрат, построения логических цепочек и рассуждений, внимательности, тренирует память пользователя. Игра мне кажется занимательной, интересной и легкой для понимания. Немаловажно, что игра «Fool» довольно широко распространена среди людей разного возраста.

Продуман привлекательный удобный пользовательский интерфейс.

В качестве языка программирования выбран язык C#

  1.  АНАЛИТИЧЕСКИЙ ОБЗОР ЛИТЕРАТУРЫ

  1.  Сравнение аналогов

   Игра «Fool» является одной из самых распространенных семейных игр. Колода, употребляющаяся при игра, - 36 карт. Самая старшая карта в колоде – туз, самая младшая – «шестерка».

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

Рис. 1.1. Начало игры


         Далее каждый из игроков должен рассмотреть свои карты и выстроить в порядке возрастания их достоинства, т.е. слева будут находится карты наименьшего достоинства, а справа - наибольшего.
    Ходить в этой карточной игре допускается любой картой, но в начале игры рекомендуется избавляться от самых мелких и ненужных карт. Ходить можно как с одной карты, так и с парных, например, с двух или трех «шестерок». Противник должен "побить" заходные карты. Бьются карты в масть, картой более старшего достоинства либо козырем. Козырь можно побить только козырем, более старшим по достоинству.
          Ведущий игру (заходящий) может подкидывать карты того же достоинства, что и те, которыми он отбивается. Эти карты игрок тоже должен "побить".
         Если игрок не может "побить" предложенные ему карты, он должен их забрать. Игроки, у которых на руках менее шести карт добирают из колоды. При этом ход переходит к следующему игроку.
         Если игрок "побил" все предложенные карты, то эти карты идут в отбой (выходят из игры). Все игроки добирают карты из колоды до шести.
   Игра заканчивается, когда все игроки, кроме одного, остались без карт (при этом в колоде также не должно остаться карт).
   Тот же единственный, кто остался с картами на руках – проигравший (Рис. 1.2).

Рис. 1.2. Конец игры.

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

  1.  Во многих существующих аналогах, например, Russian durak 3.0 для Android, «Дурак» от МедиаХауз, отсутствует возможность смены языка. Как правило, игру можно вести только на русском языке. В разработанном мной приложении, существует возможность выбора языка пользовательского интерфейса (русский/английский языки).
  2.  В приложениях часто не предусмотрены подсказки для пользователя. Играя впервые, пользователь может не разобраться, какую клавишу следует нажать для выполнения какого-либо действия в игре. В игре «Fool» пользователь может включить или отключить подсказки по своему желанию.
  3.  В некоторых приложениях, как, например, Durbetsel, после завершения партии сразу же начинается новая, без запроса у пользователя. При выходе из игры, пользователю засчитывается поражение, что, на мой взгляд, не является корректным.
  4.  Помимо очевидных недостатков, алгоритм ведения игры компьютером в большинстве приложений весьма примитивный: компьютер ходит всегда с младшей карты, подбрасывает все возможные карты, если есть такая возможность и стремится никогда не забирать карты. Такая тактика легко просчитывается, и более опытный игрок всегда выигрывает виртуального противника и быстро теряет интерес к игре.

  1.  Назначение разработки:

Основное назначение программного средства заключается в предоставлении пользователю возможности вести игру «Fool» с виртуальным противником по классическим правилам. В случае необходимости, пользователь может настраивать приложение по своему усмотрению.

  1.  Состав выполняемых функций

Программное средство предоставляет функции реализующие следующие возможности:

- Просмотр правил игры

- Выбор языка интерфейса (русский или английский)

- Включение/выключение подсказок

- Выбор колоды

- Ведение игры с виртуальным противником неограниченное количество раз.

  1.  Требования к временным характеристикам

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

  1.  Требования к составу и параметрам технических и программных средств

Для работы программного средства требуются следующие аппаратные средства:

процессор с тактовой частотой 1ГГц или выше;

минимальный объем свободного места на жёстком диске - 3 Мб;

минимальный размер ОЗУ - 128Мб.

  1.  Требования к информационной и программной совместимости

Системные требования:

-Windows Me/NT/2000/XP/Vista/7/8 ;

-DirectX 9.0

  1.  Обоснование выбора языка и сред разработки

Я использовала среду разработки Microsoft Visual Studio 2013 RC. Выбрала, прежде всего, потому, что программное средство создавалось для Microsoft Windows.

Немного о самой среде разработки.

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

.NET Framework — программная платформа, выпущенная компанией Microsoft в 2002 году. Основой платформы является общеязыковая среда исполнения Common Language Runtime (CLR), которая подходит для разных языков программирования. Функциональные возможности CLR доступны в любых языках программирования, использующих эту среду.

Архитектура .NET.

Программа для .NET Framework, написанная на любом поддерживаемом языке программирования, сначала переводится компилятором в единый для .NET промежуточный байт-код Common Intermediate Language (CIL) (ранее назывался Microsoft Intermediate Language, MSIL). В терминах .NET получается сборка, англ. assembly. Затем код либо исполняется виртуальной машиной Common Language Runtime (CLR), либо транслируется утилитой NGen.exe в исполняемый код для конкретного целевого процессора. Использование виртуальной машины предпочтительно, так как избавляет разработчиков от необходимости заботиться об особенностях аппаратной части. В случае использования виртуальной машины CLR, встроенный в неё JIT-компилятор «на лету» (just in time) преобразует промежуточный байт-код в машинные коды нужного процессора. Современная технология динамической компиляции позволяет достигнуть высокого уровня быстродействия. Виртуальная машина CLR также сама заботится о базовой безопасности, управлении памятью и системе исключений, избавляя разработчика от части работы.

Архитектура .NET Framework описана и опубликована в спецификации Common Language Infrastructure (CLI), разработанной Microsoft и утверждённой ISO и ECMA. В CLI описаны типы данных .NET, формат метаданных о структуре программы, система исполнения байт-кода и многое другое.

Объектные классы .NET, доступные для всех поддерживаемых языков программирования, содержатся в библиотеке Framework Class Library (FCL). В FCL входят классы Windows Forms, ADO.NET, ASP.NET, Language Integrated Query, Windows Presentation Foundation, Windows Communication Foundation и другие. Ядро FCL называется Base Class Library (BCL).

В качестве языка программирования выбран язык С#, как основной язык разработки приложений для платформы Microsoft .NET Framework. C# - объектно-ориентированный язык, имеет статическую типизацию, поддерживает полиморфизм, перегрузку операторов (в том числе операторов явного и неявного приведения типа), делегаты, атрибуты, события, свойства, обобщенные типы и методы, итераторы, анонимные функции с поддержкой замыканий, LINQ, исключения, комментарии в формате XML.

  1.  МОДЕЛИРОВАНИЕ ПРЕДМЕТНОЙ ОБЛАСТИ И РАЗРАБТКА ФУНКЦИОНАЛЬНЫХ ТРЕБОВАНИЙ

  1.  Описание функциональности ПС

На рисунке 2.1 приведено описание последовательности действий, которые может осуществлять программное средство.

Рис. 2.1. Варианты действий

Детализация функций настройки:

- Пользователь может выбрать только один из дух языков. По умолчанию устанавливается английский язык интерфейса;

- Пользователь может выбрать только один из двух вариантов рисунка «рубашки» карт. По умолчанию устанавливается первый вариант рисунка;

- Пользователь может отключить или включить отображение подсказок в игре. По умолчанию подсказки включены.

Детализация функций игры:

- Пользователь может просматривать только свои карты.

- Козырь для текущей партии выбирается случайно.

- Пользователю отображается информация о текущем количестве карт в колоде и козыре.

- Пользователь выбирает карту, чтобы походить или отбиться с помощью клавиш мыши.

- Пользователь уведомляет противника, что больше ходить не будет с помощью клавиши «Space».

- Пользователь передает право хода сопернику, чтобы отбить «заходные» карты, с помощью клавиши «Enter».

- Пользователь забирает «заходные» карты с помощью клавиши «Space».

- Пользователь передает право хода сопернику, отбив «заходные» карты с помощью клавиши «Enter».

- Пользователь не может подбрасывать карты, отличающиеся по значению от «заходной» или от карт, которыми отбился соперник.

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

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

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

- После завершения игры пользователю предлагается начать новую партию или выйти из игры.

- Пользователь может покинуть игру в любой момент.

  1.  РАЗРАБОТКА ПРОГРАММНОГО СРЕДСТВА

  1.  Класс Karta

Класс является базовым для всех карт в игре. Обладает полями для хранения информации является ли карта козырной – «trump», значение карты – «ves», масть карты – «mast», находится ли карта в колоде – «vkolode», находится ли карта в игре – «vigre» и полем «face», хранящее информацию о визуальном представлении карты.

  Класс содержит конструктор public Karta(). В нем определяется высота и ширина карты, а также загружается из файла картинка для визуального отображения карты.

  1.  Класс main

Стартовая точка программы. Внутри метода Main() происходит вызов класса Start(), в работу включается системный метод Run(). Этот метод запускает бесконечный цикл, где и происходит выполнение всей программы. Пока программа работает, бесконечный цикл функционирует; как только пользователь закрывает программу, работа бесконечного цикла автоматически прекращается. После запуска метода Run() управление работой приложения передается в класс Start() .

  1.  Класс start

Класс, представляющий собой всю игру и управляющий всем игровым процессом.

Основные поля класса:

  Karta[] koloda – колода из 36 карт    

   int trump – козырная масть    

   int col_kart – общее количество карт

   int col_vigre  - количество карт в игре

   bool can_go1 – принадлежит ли ход пользователю

   bool sdano – состоялась ли раздача    

   bool can_go2  - принадлежит ли ход компьютеру.    

   string[] helper - подсказки

   string[] info – статус игры    

   List<Karta> my_carts – карты пользователя

   List<Karta> enemy_cards  - карты компьютера

   List<Karta> cards_table – карты на столе

А так же другие поля для корректной работы с клавиатурой, временные переменные и флаги.

Класс содержит конструктор public start(),в котором определяются шрифт, положение визуальных элементов форм на экране монитора, пути к картинкам для игры,  текст окон с подсказками, загрузка иконки приложения.

Методы класса:

  1.  public void Menu() – метод загружает стартовый экран игры. При запуске программы язык интерфейса этого экрана по умолчанию – английский, если же до этого были произведены настройки, то интерфейс может быть на русском либо английском языке. На экран выводятся 3 кнопки «new game», «settings» и «quit».

  1.  void EndProgram(object sender, EventArgs e) – метод вызывается по нажатию на кнопку «quit» на стартовом экране. Закрывает приложение.

  1.  void StartGame(object z, EventArgs x) – метод вызывается для начала новой партии при нажатии на кнопку «new game» на стартовом экране либо при выборе пользователя «start a new game» после завершения очередной партии. Открывает фоновое изображение для игры, случайно определяет козырь, загружает изображения для карт в колоде, ставит в соответствие каждой карте определенный вес (от 0 для шестерки до 8 для туза) и масть (0 – для «пики», 1 – для «трефы», 2 – для «бубны», 3 – для «червы»). Вызывается метод Igra().

  1.  void StolKoloda() – метод отображает для пользователя текущую козырную масть, подсказки, ведет счет количества карт в игре.

  1.  void Igra() – основной метод, реализующий ведение всей партии. Вызывает методы StolKoloda() и IgraSortirovka(). Пока у игроков есть карты или есть несданные карты в колоде вызывает метод IgraMagia(). Когда карт в игре больше нет, то определяет результат партии( «win», «lost», «Drawn game») и выводит диалоговое окно с предложением начать новую партию или вернуться к стартовому экрану.

  1.  void IgraMagia() – метод добавляет +20 к весу карты компьютера, если она является козырной, находит карты компьютера с минимальным весом, заходит этими картами на игрока и передает возможность хода игроку.
  2.  void IgraSortirovka() – метод случайно выбирает карты из колоды для пользователя и компьютера. В начале партии сдается по 6 карт. Далее при завершении хода, проверяется, если в колоде есть карты, а на руках у пользователя/компьютера карт меньше 6. В этом случае раздаются случайные карты из колоды, пока их количество у каждого из игроков не будет равно 6.

(Блок-схема алгоритма метода приведена в приложении 1)

  1.  void IgraGo() – метод вызывается в начале очередной партии и передает право хода пользователю, выводя соответствующие подсказки, если они включены.

  1.  void EnterCick(object sender, KeyEventArgs e) – метод вызывается по нажатию клавиши enter или space. Если нажата клавиша «enter», а право хода принадлежит пользователю, то компьютер должен принять решение, может ли он отбить карты на столе. Для этого просматривается каждая неотбитая карта на столе, и для нее компьютер ищет из своих карт карту такой же масти с минимальным весом, но большим, чем у карты на столе. Если карты такой же масти с большим весом нет, то компьютер ищет среди своих карт минимальный козырь. Если карты найдены, то они выкладываются компьютером на стол и право хода переходит пользователю. Иначе выводится надпись «беру», и все карты на столе забирает компьютер, а право хода остается за пользователем.

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

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

  1.  void ClockTick(object sender, EventArgs e) – метод отключает видимость надписи «беру», если она была ранее после начала нового хода.
  2.  void StolUp(object z, MouseEventArgs x) – метод вызывается по нажатию левой кнопки мыши по карте. Если ход принадлежит пользователю, то таким образом он выбирает карты, чтобы заходить. Если ход принадлежит компьютеру, то нажатием кнопки мышки пользователь должен выбрать карту, которой хочет отбиваться и выделить карту соперника, которую будет отбивать. Если выделенная карта на руках пользователя имеет вес больший (учитывая козыри), чем выделенная карта на столе, то она выкладывается на стол.

  1.  void GoEndMouseClick(object sender, MouseEventArgs e) – метод вызывается по нажатию левой клавиши мыши по кнопке выхода. Открывает экран меню.

  1.  void ChangeProgram(object z, EventArgs x) -  метод вызывается по нажатию кнопки «setting» в главном меню. Открывается соответствующее окно с предоставлением выбора колоды, языка игры и включением/отключением подсказок. По умолчанию язык настроек – английский. Если до этого был установлен русский язык интерфейса, то это окно будет отображаться на русском. Для выбора языка интерфейса используются 2 элемента RadioButton.

При нажатии левой кнопкой мыши на панель с понравившейся колодой, цвет фона панели становится золотым, подтверждая выбор пользователя.

Для включения/отключения подсказок используется CheckBox.

 

  1.  void SaveAll(object z, MouseEventArgs x) – метод вызывается по нажатию левой кнопки мыши на кнопку для сохранения всех произведенных изменений в настройках.

Схема алгоритма метода приведена на рисунке 3.1.

Рис. 3.1. – алгоритм метода SaveAll


  1.  ТЕСТИРОВАНИЕ ПРОГРАММНОГО СРЕДСТВА

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

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

Проведенные тесты программного средства и ожидаемые результаты приведены в таблице 4.1.

Таблица 4.1. Тестирование программного средства

Модуль

Структура теста

Ожидаемый результат

1

2

3

4

1

Стартовое меню

Запуск .exe файла приложения

Нажать на кнопку «Quit»

Нажать на кнопку «Settings»

Нажать на кнопку «New game»

Отображение окна стартового меню

Выход из приложения

Отображение окна с настройками игры

Отображение окна игрового стола. Отображение козыря, в колоде 24 карты, у пользователя 6 открытых карт, у компьютера 6 закрытых карт.

Продолжение таблицы 4.1. – тестирование программного средства

2

Меню настроек

Нажать на отображение рисунка колоды

Нажать на текст «русский» / «English»

Нажать на текст «help»

Нажать на кнопку выхода из настроек

Подсвечивание золотым цветом выбранной колоды; рисунок второй колоды подсвечивается серым цветом

Устанавливается точка напротив выбранного языка

Установка/снятие галочки напротив текста

Отображение окна стартового меню на языке, выбранном в настройках

3

Режим игры

Нажать на кнопку выхода из игры

Нажать левой кнопкой мыши на одну из открытых карт(«заходная» карта)

Нажать левой кнопкой мыши на карту, равную по весу «заходной».

Нажать левой кнопкой мыши на карту, неравную по весу «заходной».

Нажать на клавишу «enter» во время хода пользователя

Отображение окна стартового меню

Перенос выбранной карты на стол

Перенос выбранной карты на стол

Игнорирование действия

Компьютер забирает «заходные карты» (при этом на 5 секунд появляется окошко с текстом «Беру») или выкладывает на стол карты, бьющие «заходные»

Продолжение таблицы 4.1. – тестирование программного средства

Нажать на клавишу «space» во время хода пользователя

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

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

Нажать на клавишу «enter» во время хода компьютера

Нажать на клавишу «space» во время хода компьютера

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

Выбранная карта переносится на стол

Игнорирование действия

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

Все карты на столе переносятся в руки пользователя. Компьютеру из колоды переходят недостающие карты.


Продолжение таблицы 4.1. – тестирование программного средства

Попытка пользователем подкинуть карты, суммарным количеством больше 6

У пользователя в руках накопилось больше 11 карт одновременно.

У пользователя в руках меньше 12 карт одновременно

После завершения игры в диалоговом окне нажать «Да»

После завершения игры в диалоговом окне нажать «Нет»

Игнорирование действия

Появление вертикального «скролла» для прокрутки мышью.

Вертикальный «скролл» для прокрутки мышью не отображается

Очистка стола, новое начисление 6 открытых карт пользователю и 6 закрытых карт компьютеру, отображение козыря, в колоде 24 карты. Первый ход делает пользователь.

Отображение стартового окна


  1.  МЕТОДИКА ИСПОЛЬЗОВАНИЯ РАЗРАБОТАННОГО ПРОГРАММНОГО СРЕДСТВА

При запуске программного приложение, пользователь видит перед собой экран главного меню (рис 5.1). Он может перейти в настройки игры, непосредственно начать игру либо выйти из приложения.

 

Рис 5.1 -  стартовое меню игры

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

Далее пользователю предлагается на выбор два варианта колоды карт для игры. По щелчку мыши активируется одна из колод.

Также пользователь может включить или отключить подсказки во время игры (отображаются в правом нижнем углу). По умолчанию подсказки включены. При первом использовании программного приложения рекомендуется оставить подсказки включенными.

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

На рисунке 5.3 экран стартового меню после внесения изменений в настройки игры – выбран русский язык пользовательского интерфейса игры.

Рис 5.2. – меню настроек

Рис 5.3. – стартовое меню на русском языке

Для того, чтобы начать новую игру, пользователь нажимает кнопку «New game» / «Новая игра». Открывается новое окно (Рис. 5.4). Пользователь видит перед собой 6 открытых карт, полученных случайным образом из колоды и отсортированных по весу. 6 карт соперника, которые остаются закрытыми для пользователя, оставшуюся колоду карт из 24 карт, масть являющуюся козырной для текущей партии и полученной случайно.

Если в настройках пользователь не отключил отображение подсказок, то в нижнем правом углу окна отображается окошко с информацией о том, какие клавиши могут быть нажаты пользователем в текущий момент для совершения определенных действий. Например, когда ход принадлежит пользователю, он может предоставить право отбиться сопернику, нажав клавишу «enter», или завершить ход, нажав клавишу «space».

Рис. 5.4 – начало игры

После этого право хода переходит компьютеру. Пользователь может либо забрать все карты на столе, нажав клавишу «space», либо отбить карты соперника с помощью манипуляций мышью (Рис. 5.5). После того как все карты соперника будут отбиты, пользователь должен нажать клавишу «enter» для передачи права хода компьютеру, который либо подбрасывает на стол новые карты, либо завершает ход.

После завершения хода, количество карт пользователя и компьютера дополняется до 6 (если на момент завершения хода карт осталось меньше 6) из колоды, если в ней есть карты.

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

Рис 5.5 – пользователь отбивает карты соперника

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

 

Рис. 5.6 – пользователь одержал победу

После завершения игры пользователю открывается диалоговое окно с результатами партии (Рис. 5.6 – 5.7). Ему предлагается начать новую игру с компьютером или выйти из игры к стартовому окну.

Рис. 5.7 – Пользователь проиграл

ЗАКЛЮЧЕНИЕ

В результате выполнения данной курсовой работы было разработанное игровое приложение «Карточная игра «Fool». Проект был выполнен в среде разработки Visual Studio 2013.

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

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

СПИСОК ИСПОЛЬЗУЕМОЙ ЛИТЕРАТУРЫ

  1.  Wikipedia.com [Электронный ресурс]
  2.  microsoft.com  [Электронный ресурс]
  3.  Т.Павловская «С#. Программирование на языке высокого уровня»
  4.  Герберт Шилдт "C# 4.0. Полное руководство"
  5.  Конспект лекций по курсу «Объектно-ориентированное программирование», БГУИР кафедра информатики
  6.  ГОСТ 19.701-90. ЕСПД. Схемы алгоритмов, программ, данных и систем. Условные обозначение и правила выполнения.


ЛИСТИНГ ПРОГРАММЫ

using System;

using System.Drawing;

using System.Windows.Forms;

using System.Collections.Generic;

using System.Threading;

using System.IO;

class start : Form

{

   Karta[] koloda = new Karta[36];

   

   RadioButton[] leng = new RadioButton[2];

   public static string adrec = @Application.StartupPath;

   int trump;

   CheckBox hp = new CheckBox();

   RichTextBox help = new RichTextBox();

   int my_num = 99;

   int enemy_num = 99;

   int col_kart;

   int col_vigre = 0;

   int makx = 0;

   bool nacrt = false;

   bool can_go1 = false;

   bool sdano = false;

   bool can_go = false;

   bool can_go2 = false;

   bool ed = false;

   bool end = false;

   string[] helper = new string[4];

   string[] info = new string[3];

   List<int> my_kart_only = new List<int>();

   PictureBox face = new PictureBox();

   PictureBox mast = new PictureBox();

   List<int> moe = new List<int>();

   List<Karta> my_carts= new List<Karta>();

   List<Karta> enemy_cards = new List<Karta>();

   List<Karta> cards_table = new List<Karta>();

   TableLayoutPanel table = new TableLayoutPanel();

   FlowLayoutPanel his = new FlowLayoutPanel();

   FlowLayoutPanel my = new FlowLayoutPanel();

   

   FlowLayoutPanel f = new FlowLayoutPanel();

   FlowLayoutPanel s = new FlowLayoutPanel();

   FileInfo iff = new FileInfo(adrec + "\\setting.txt");

   string h = "";

   string m = "";

   int left_center;

   int top_center;

   PictureBox go_end = new PictureBox();

   PictureBox up = new PictureBox();

   Label col = new Label();

   public start()

   {

       this.Font = new Font("Comic Sans MS", 8f, FontStyle.Regular);       

       go_end.Width = 50;

       go_end.Height = 60;

       go_end.Image = new Bitmap(adrec+"\\img\\go_menu.jpg");

       go_end.Left = SystemInformation.PrimaryMonitorSize.Width - 50;

       go_end.BorderStyle = BorderStyle.FixedSingle;

       go_end.MouseClick += new MouseEventHandler(GoEndMouseClick);

       helper[0] = "Enter : opponent begins to beat your cards.\r\n";

       helper[1] = "Space : finish the course, I advise no more.\r\n";

       helper[3] = "Space : take a card, I can not recapture.\r\n";

       helper[2] = "Enter : reflected the enemy card, clear the table if the opponent does not throw.\r\n";

       

       left_center = SystemInformation.PrimaryMonitorSize.Width / 2;

       top_center = SystemInformation.PrimaryMonitorSize.Height / 2;

       his.Top = 30;

       his.Width = SystemInformation.PrimaryMonitorSize.Width - ((left_center / 3) * 2); ;

       his.BackgroundImage = new Bitmap(adrec + "\\img\\game2.jpg");

       his.Height = 116;

       his.Left = left_center / 3;

       his.AutoScroll = true;

       table.Top = top_center - 100;

       table.BackgroundImage = new Bitmap(adrec+"\\img\\game2.jpg");

       table.Left = left_center/3;

       table.RowCount = 2;

       table.Width = SystemInformation.PrimaryMonitorSize.Width - ((left_center / 3) * 2);

       table.Height = 300;

       

       my.AutoScroll = true;

       my.BackgroundImage = new Bitmap(adrec + "\\img\\game2.jpg");

       my.Top = SystemInformation.PrimaryMonitorSize.Height-166;

       my.Width = SystemInformation.PrimaryMonitorSize.Width-((left_center / 3)*2);

       my.Height = SystemInformation.PrimaryMonitorSize.Height - my.Top-30;

       my.FlowDirection = FlowDirection.LeftToRight;

       my.Left = left_center / 3;

       

       help.Enabled  = false;

       help.Left = my.Width + my.Left + 20;

       help.Top = SystemInformation.PrimaryMonitorSize.Height - 130;

       help.Height = 130;

       help.Multiline = true;

       help.Width = SystemInformation.PrimaryMonitorSize.Width - help.Left;

       face.Image = new Bitmap(adrec + "\\img\\face.jpg");

       face.Width = 71;

       face.Height = 96;

       face.Top = top_center - (face.Height / 2);

       face.Left = (SystemInformation.PrimaryMonitorSize.Width / 100) * 3;

       up.Text = "The enemy took cards.";

       up.Width = 200;

       up.Height = 50;

       up.Left = left_center-(up.Width/2);

       up.Top = top_center - (up.Height/2);

       up.Image = new Bitmap(adrec+"\\img\\up.jpg");

       

       mast.Width = 30;

       mast.Height = 30;

       mast.Top = top_center - ((face.Height / 2)-10);

       mast.Left = face.Left+(face.Width/3);

       mast.BorderStyle = BorderStyle.None;

       col.Left = mast.Left;

       col.Top = mast.Top + mast.Height + 20;

       col.BackColor = Color.White;

       col.Width = 30;

       col.TextAlign = ContentAlignment.MiddleCenter;

       col.ForeColor = Color.Black;

       this.Icon = new Icon(adrec+"\\ico.ico");

       this.KeyUp += new KeyEventHandler(EnterCick);

      this.KeyUp += new KeyEventHandler(StartKeyUp);

       this.Width = SystemInformation.PrimaryMonitorSize.Width;

       this.Height = SystemInformation.PrimaryMonitorSize.Height;

       this.StartPosition = FormStartPosition.CenterScreen;

       this.FormBorderStyle = FormBorderStyle.None;

       this.Text = "FOOL";

       this.MouseWheel += new MouseEventHandler(UpDow);

       Menu();

   }

   

   public void Menu()

   {

       Bitmap b = new Bitmap(SystemInformation.PrimaryMonitorSize.Width, SystemInformation.PrimaryMonitorSize.Height);

       Graphics zz;

       zz = Graphics.FromImage(b);

       zz.DrawImage(new Bitmap(adrec + "\\img\\back.jpeg"), 0, 0, SystemInformation.PrimaryMonitorSize.Width, SystemInformation.PrimaryMonitorSize.Height);

       this.BackgroundImage = b;

       this.BackgroundImageLayout = ImageLayout.Stretch;

       if (iff.Exists == false)

       {

           StreamWriter txt_st = iff.CreateText();

           txt_st.WriteLine("Language: English ;");

           txt_st.WriteLine("Type of card: 1 ;");

           txt_st.WriteLine("Help: true ;");

           txt_st.Close();

       }

       int mas = 0;

       StreamReader txt = iff.OpenText();

       while (mas <3 && (info[mas] = txt.ReadLine()) != null)

       {

           mas++;

           

       }

       txt.Close();

       if (info[0].Replace("Language","") == ": Русский ;")

       {

           helper[0] = "Enter  : враг начинает бить ваши карты.\r\n";

           helper[1] = "Space  : закончить мой ход.\r\n";

           helper[3] = "Space  : беру карты, не могу отбить.\r\n";

           helper[2] = "Enter  : отбил карты противника, очистить стол, если он больше не подбросит.\r\n";

 

       }

       else

       {

           helper[0] = "Enter : opponent begins to beat your cards.\r\n";

           helper[1] = "Space : finish the course, I advise no more.\r\n";

           helper[3] = "Space : take a card, I can not recapture.\r\n";

           helper[2] = "Enter : reflected the enemy card, clear the table if the opponent does not throw.\r\n";

       }

       Button[] m_v = new Button[3];

       for (int x = 0; x < 3; x++)

       {

           m_v[x] = new Button();

           if (info[0].Replace("Language", "") == ": Русский ;")

           { m_v[x].BackgroundImage = new Bitmap(adrec + "\\img\\m_v" + x + "_ru.jpg"); }

           else m_v[x].BackgroundImage = new Bitmap(adrec + "\\img\\m_v" + x + ".jpg");

           m_v[x].Width = 200;

           m_v[x].Height = 50;

           m_v[x].Left = (SystemInformation.PrimaryMonitorSize.Width / 2) - (m_v[x].Width / 2);

           this.Controls.Add(m_v[x]);

       }

    

       m_v[0].Top = SystemInformation.PrimaryMonitorSize.Height / 2;

       m_v[1].Top = m_v[0].Top + m_v[0].Height + 30;

       m_v[2].Top = m_v[1].Top + m_v[1].Height + 30;

       m_v[1].Click += new EventHandler(ChangeProgram);

       m_v[2].Click += new EventHandler(EndProgram);

       m_v[0].Click += new EventHandler(StartGame);

   }

   

   void EndProgram(object sender, EventArgs e)

   {

       Application.Exit();

   }

   void StartGame(object z, EventArgs x)

   {

       sdano = false;

       enemy_cards.Clear();

       cards_table.Clear();

       my_carts.Clear();

       my.Controls.Clear();

       table.Controls.Clear();

       his.Controls.Clear();

       ed = false;

       col_kart = 36;

       h = "";

       m = "";

       nacrt = false;

       Random choose_trump = new Random();

       trump = choose_trump.Next(4);

       this.Controls.Clear();

       Bitmap b = new Bitmap(SystemInformation.PrimaryMonitorSize.Width, SystemInformation.PrimaryMonitorSize.Height);

       Graphics zz;

       zz = Graphics.FromImage(b);

       zz.DrawImage(new Bitmap(adrec + "\\img\\game.jpg"), 0, 0, SystemInformation.PrimaryMonitorSize.Width, SystemInformation.PrimaryMonitorSize.Height);

       this.Controls.Add(go_end);

       this.BackgroundImage = b;

       string imag = "1";

       string roz = ".png";

       if (info[1].Replace("Type of card", "") == ": 2 ;") {

           imag = "2";

           roz = ".jpg";

       }

       for (int i = 0; i < 36; i++)

       {

           

           Graphics res;

           koloda[i] = new Karta();

           koloda[i].vigre = true;

           if (imag == "2") {

               koloda[i].img.BorderStyle = BorderStyle.FixedSingle;

           }

           koloda[i].img.MouseClick += new MouseEventHandler(StolUp);

           koloda[i].img.Image = new Bitmap(71,96);

           res = Graphics.FromImage(koloda[i].img.Image);

           res.DrawImage(new Bitmap(adrec + "\\img\\"+imag+"\\"+(i + 1).ToString() + roz),0,0,71,96);

           koloda[i].vkolode = true;

           koloda[i].ves = (i - (i % 4)) / 4;

           koloda[i].img.Width = 71;

           koloda[i].img.Height = 96;

           koloda[i].img.Name = i.ToString();

           

           switch (i + 1)

               {

                   case 1:

                   case 5:

                   case 9:

                   case 13:

                   case 17:

                   case 21:

                   case 25:

                   case 29:

                   case 33: koloda[i].mast = 0; break;

                   case 2:

                   case 6:

                   case 10:

                   case 14:

                   case 18:

                   case 22:

                   case 26:

                   case 30:

                   case 34: koloda[i].mast = 1; break;

                   case 3:

                   case 7:

                   case 11:

                   case 15:

                   case 19:

                   case 23:

                   case 27:

                   case 31:

                   case 35: koloda[i].mast = 2; break;

                   case 4:

                   case 8:

                   case 12:

                   case 16:

                   case 20:

                   case 24:

                   case 28:

                   case 32:

                   case 36: koloda[i].mast = 3; break;

               }

       if (koloda[i].mast == trump) { koloda[i].trump = true; }

           

       }

       Igra();

   }

   void StolKoloda() {

       col_vigre = 0;

       for (int s = 0; s < koloda.Length; s++)

       {

           if (koloda[s].vigre) { col_vigre++; }

       }

       if (!ed)

       {

           Bitmap opa =  new Bitmap(adrec+"\\img\\mast_"+trump.ToString()+".png");

           mast.Image = opa;

           if (info[2].Replace("Help", "") == ": true ;")

           {

               this.Controls.Add(help);

           }

           this.Controls.Add(up);

           up.Visible = false;

           this.Controls.Add(my);

           this.Controls.Add(col);

           this.Controls.Add(mast);

           this.Controls.Add(face);

           this.Controls.Add(his);

           this.Controls.Add(table);

           ed = true;

       }

   }

   void Igra() {

       bool mono = true;

       StolKoloda();

       IgraSortirovka();

           if (my_carts.Count > 0 && enemy_cards.Count > 0)

           {

               if (!sdano) { IgraGo(); }

               else if (sdano)

               {

                   moe.Clear();

                   IgraMagia();

               }

           }

           else if (col_vigre > 0)

           {

               if (my_carts.Count == 0 && enemy_cards.Count > 0) {

                   mono = false;

                   if (info[0].Replace("Language", "") == ": English ;")

               {

                   h = "Game over";

                   m = "You win. Start a new game?";

               }

               else

               {

                   h = "Конец игры";

                   m = "Вы победили. Начать новую игру?";

               }

               }

               else {

                   mono = false;

                   if (info[0].Replace("Language", "") == ": English ;")

                   {

                       h = "Game over";

                       m = "You lost. Start a new game?";

                   }

                   else

                   {

                       h = "Конец игры";

                       m = "Вы проиграли. Начать новую игру?";

                   }

                   

               }

           }

           else {

               mono = false;

               if (info[0].Replace("Language", "") == ": English ;")

                   {

                       h = "Game over";

                       m = "Drawn game. Start a new game?";

                   }

                   else

                   {

                       h = "Конец игры";

                       m = "Ничья. Начать новую игру?";

                   }

           }

       

           DialogResult oo = new DialogResult();

           

           if (!mono)

           {

               mono = true;

               oo = MessageBox.Show(m, h, MessageBoxButtons.YesNo);

               if (oo == DialogResult.Yes)

               {

                   this.Controls.Clear();

                   StartGame(new Object(), new EventArgs());

               }

               else if (oo == DialogResult.No)

               {

                   this.Controls.Clear();

                   Menu();

               }

           }

   }

   void IgraMagia()

   {

       int min = 99;

       int ves1;

       help.Text = helper[2];

       help.Text += "\r\n" + helper[3];

       

       int ex = 0;

       List<int> num = new List<int>();

       for (int id = 0; id < enemy_cards.Count; id++)

       {

           if (enemy_cards[id].mast == trump) {

               ves1 = enemy_cards[id].ves + 20;

           }

           else ves1 = enemy_cards[id].ves;

           if (ves1 < min) {

               min = enemy_cards[id].ves;

               ex = id;

           

           }

       }

       num.Add(ex);

       for (int id = 0; id < enemy_cards.Count; id++)

       {

           if(enemy_cards[ex].ves == enemy_cards[id].ves &&id != ex && my_carts.Count > num.Count){

               num.Add(id);

           }

       }

       for (int end = 0; end < num.Count; end++) {

           

           table.Controls.Add(enemy_cards[num[end]].img,end,0);

           his.Controls.Remove(enemy_cards[num[end]].face);

           enemy_cards[num[end]].img.Top = top_center;

           cards_table.Add(enemy_cards[num[end]]);

           enemy_cards[num[end]].img.Left = enemy_cards[num[end]].face.Left;

       }

       can_go2 = true;

       num.Sort();

           int ccol = 0;

       for (int end = 1; ccol < num.Count; end++)

       {

           ccol ++;

           enemy_cards.RemoveAt(num[num.Count-end]);

       }

   }

   void IgraSortirovka()

   

   {  

       Random all = new Random();

       int ind = 0;

       int por = 0;

       if (sdano)

       {

           for (; my_carts.Count < 6 && col_kart > 0; por++)

           {

               do { ind = all.Next(36); }

               while (!koloda[ind].vkolode);

               col_kart--;

               my_carts.Add(koloda[ind]);

               koloda[ind].vkolode = false;

               my.Controls.Add(koloda[ind].img);

           

           }

           ind = 0;

           por = 0;

           for (; enemy_cards.Count < 6 && col_kart > 0; por++)

           {

               do { ind = all.Next(36); }

               while (!koloda[ind].vkolode);

               col_kart--;

               his.Controls.Add(koloda[ind].face);

               enemy_cards.Add(koloda[ind]);

               koloda[ind].vkolode = false;

           }

       }

       else {          

           for (; enemy_cards.Count < 6 && col_kart > 0; por++)

           {

               do { ind = all.Next(36); }

               while (!koloda[ind].vkolode);

               col_kart--;

               his.Controls.Add(koloda[ind].face);

               enemy_cards.Add(koloda[ind]);

               koloda[ind].vkolode = false;

           }

           ind = 0;

           por = 0;

           for (; my_carts.Count < 6 && col_kart > 0; por++)

           {

               do { ind = all.Next(36); }

               while (!koloda[ind].vkolode);

               col_kart--;

               my_carts.Add(koloda[ind]);

               koloda[ind].vkolode = false;

               my.Controls.Add(koloda[ind].img);

           }

           

       }

       col.Text = col_kart.ToString();

       bool z = false;

       while (!z) {

           z = true;

           for (int h = 0; h < my.Controls.Count-1; h++)

           {

               var po1 = my.Controls.GetChildIndex(my.Controls[h]);

               var po2 = my.Controls.GetChildIndex(my.Controls[h]);

               if (Convert.ToInt32(my.Controls[h].Name) > Convert.ToInt32(my.Controls[h+1].Name))

               {

                   my.Controls.SetChildIndex(my.Controls[h], po2);

                   my.Controls.SetChildIndex(my.Controls[h + 1], po1);

                   z = false;

               }

           }

       }

   }

   void IgraGo() {

       my_kart_only.Clear();

       can_go1 = true;

       help.Text = helper[0];

       help.Text += "\r\n"+helper[1];

       makx = enemy_cards.Count;

 

   

   }

   void EnterCick(object sender, KeyEventArgs e)

   {

       for (int l = 0; l < cards_table.Count; l++)

       {

           cards_table[l].img.BorderStyle = BorderStyle.None;

       }

       if (can_go && cards_table.Count > 0)

       {

           List<int> del = new List<int>();

           bool next = true;

           if (e.KeyCode == Keys.Enter)

           {

               int stol_kol = cards_table.Count;

               for (int stol = 0; stol < stol_kol && next; stol++)

               {

                   bool clon = false;

                   int min = 99;

                   int id = 0;

                   int min_koz = 99;

                   for (int w = 0; w < my_kart_only.Count; w++)

                   {

                       

                       if (my_kart_only[w].ToString() == cards_table[stol].img.Name)

                       {

                           clon = true;

                       }

                   }

                   if (clon&&my_kart_only.Count>0)

                   {

                       for (int hands = 0; hands < enemy_cards.Count; hands++)

                       {

                           if (enemy_cards[hands].ves < min_koz && enemy_cards[hands].trump && min == 99 && !cards_table[stol].trump)

                           {

                               min_koz = enemy_cards[hands].ves;

                               id = hands;

                           }

                           if (cards_table[stol].ves < enemy_cards[hands].ves && enemy_cards[hands].ves < min && enemy_cards[hands].mast == cards_table[stol].mast)

                           {

                               min = enemy_cards[hands].ves;

                               id = hands;

                           }

                       }

                       if (min == 99) { min = min_koz; }

                       if (min != 99)

                       {

                           my_kart_only.RemoveAt(0);

                           his.Controls.Remove(enemy_cards[id].face);

                           table.Controls.Add(enemy_cards[id].img,table.GetColumn(cards_table[stol].img),1);

                           enemy_cards[id].img.Top = top_center - 60;

                           enemy_cards[id].img.Left = cards_table[stol].img.Left;

                           cards_table.Add(enemy_cards[id]);

                           enemy_cards.RemoveAt(id);

                           can_go1 = true;

                           end = true;

                       }

                       else

                       {

                           can_go1 = true;

                           next = false;

                           for (int ex = 0; ex < cards_table.Count; ex++)

                           {

                               his.Controls.Add(cards_table[ex].face);

                               cards_table[ex].face.Top = 0;

                               cards_table[ex].face.Left = (600 + (ex * 50) + 50);

                               enemy_cards.Add(cards_table[ex]);

                           }

                           table.Controls.Clear();

                           up.Visible = true;

                           System.Windows.Forms.Timer clock = new System.Windows.Forms.Timer();

                           clock.Interval = 3000;

                           clock.Start();

                           clock.Tick += new EventHandler(ClockTick);

                           cards_table.Clear();

                           end = false;

                           Igra();

                       

                       }

                   }

               }

           }

       }

       else if (can_go2)

       {

           if (cards_table.Count % 2 == 0 && e.KeyCode == Keys.Enter && moe.Count == cards_table.Count)

           {

               bool doc = Win();

               if (!doc)

               {

                   for (int n = 0; n < cards_table.Count; n++)

                   {

                       cards_table[n].vigre = false;

                   }

                   for (int h = 0; h < my_carts.Count; h++)

                   {

                       my_carts[h].img.BorderStyle = BorderStyle.None;

                   }

                   table.Controls.Clear();

                   cards_table.Clear();

                   can_go = true;

                   sdano = false;

                   can_go1 = true;

                   can_go2 = false;

                   moe.Clear();

                   Igra();

               }

               else

               {

                   List<int> num = new List<int>();

                   for (int n = 0; n < moe.Count; n++)

                   {

                       for (int id = 0; id < enemy_cards.Count; id++)

                       {

                          if (enemy_cards[id].ves == koloda[moe[n]].ves&&num.Count<=my_carts.Count)

                           {

                               num.Add(id);

                               table.Controls.Add(enemy_cards[id].img,table.Controls.Count,0);

                               his.Controls.Remove(enemy_cards[id].face);

                               cards_table.Add(enemy_cards[id]);

                           }

                       }

                   }

                   can_go2 = true;

                   num.Sort();

                   int ccol = 0;

                   for (int end = 1; ccol < num.Count; end++)

                   {

                       ccol++;

                       enemy_cards.RemoveAt(num[num.Count - end]);

                   }

               

               }

           }

           else if (e.KeyCode == Keys.Space)

           {

               for (int h = 0; h < my_carts.Count; h++)

               {

                   my_carts[h].img.BorderStyle = BorderStyle.None;

               }

               for (int re = 0; re < cards_table.Count; re++)

               {

                   my.Controls.Add(cards_table[re].img);

                   cards_table[re].img.Top = SystemInformation.PrimaryMonitorSize.Height - cards_table[re].img.Height;

                   my_carts.Add(cards_table[re]);

               }

               table.Controls.Clear();

               cards_table.Clear();

               can_go = false;

               sdano = true;

               can_go1 = false;

               moe.Clear();

               Igra();

           }

       }

   }

   void ClockTick(object sender, EventArgs e)

   {

       up.Visible = false;

       

   }

   void StolUp(object z, MouseEventArgs x) {

       int lasth = 99;

       PictureBox ths = (PictureBox)z;

       bool ok = false;

       bool okey = false;

       bool zero = false;

       int lastm = 99;

       for (int ax = 0; ax < moe.Count; ax++) {

           if (moe[ax] == Convert.ToInt32(ths.Name)) { zero = true; }

       

       }

       for (int f = 0; f < my_carts.Count; f++) { if (ths.Name == my_carts[f].img.Name) { ok = true; lastm = my_num; my_num = Convert.ToInt32(ths.Name); } }

       for (int f = 0; f < cards_table.Count; f++) { if (!zero && ths.Name == cards_table[f].img.Name) { okey = true; lasth = enemy_num; enemy_num = Convert.ToInt32(ths.Name); } }

           if (can_go1 && ok)

           {

               bool yes = false;

               for (int num = 0; num < cards_table.Count; num++)

               {

                   if (makx>0 && cards_table[num].ves == koloda[Convert.ToInt32(ths.Name)].ves && cards_table[num].img.Name != ths.Name) { yes = true; }

                  

               }

               if (cards_table.Count == 0) { yes= true;}

               

               if (yes)

               {

                   makx--;

                   table.Controls.Add(ths,table.Controls.Count,0);

                   

                   ths.Top =  top_center;

                   my.Controls.Remove(ths);

                   cards_table.Add(koloda[Convert.ToInt32(ths.Name)]);

                   can_go = true;

                   my_kart_only.Add(Convert.ToInt32(ths.Name));

                   for (int id = 0; id < my_carts.Count; id++)

                   {

                       if (my_carts[id].img.Name == ths.Name) { my_carts.RemoveAt(id); }

                   }

               }

     

           }

           else if (can_go2 && ok || can_go2 && okey)

           {

               if (enemy_num != 99&&okey) {

                   if (lasth != 99) { koloda[lasth].img.BorderStyle = BorderStyle.None; }

                   koloda[enemy_num].img.BorderStyle = BorderStyle.Fixed3D;

               }

               if (my_num != 99 && ok)

               {

                   if (lastm != 99) { koloda[lastm].img.BorderStyle = BorderStyle.None; }

                   koloda[my_num].img.BorderStyle = BorderStyle.Fixed3D;

               }

               if (my_num != 99 && enemy_num != 99 && koloda[my_num].ves > koloda[enemy_num].ves && koloda[my_num].mast == koloda[enemy_num].mast || my_num != 99 && enemy_num != 99 && koloda[my_num].mast == trump && koloda[enemy_num].mast != trump)

               {

                   moe.Add(enemy_num);

                   moe.Add(my_num);

                   table.Controls.Add(koloda[my_num].img,table.GetColumn(koloda[enemy_num].img),1);

                   my.Controls.Remove(koloda[my_num].img);

                   cards_table.Add(koloda[my_num]);

                   for (int i = 0; i < my_carts.Count; i++)

                   {

                       if (Convert.ToInt32(my_carts[i].img.Name) == my_num)

                       {

                           my_carts.RemoveAt(i);

                       }

                   }

                   koloda[my_num].img.BorderStyle = BorderStyle.None;

                   koloda[enemy_num].img.BorderStyle = BorderStyle.None;

                   my_num = 99;

                   enemy_num = 99;

               }

               

           }

   }

  void StartKeyUp(object sender, KeyEventArgs e)

   {

       if (e.KeyCode == Keys.Space && end)

       {

           end = false;

           can_go = false;

           can_go1 = false;

           

           for (int y = 0; y < cards_table.Count; y++)

           {

               cards_table[y].vigre = false;

               table.Controls.Clear();

           }

           cards_table.Clear();

           if (can_go1 == true)

           { sdano = false; }

           else sdano = true;

           Igra();

       }

   }

   bool Win()

   {

       bool z = false;

       for (int n = 0; n < moe.Count;n++)

       {

           for (int id = 0; id < enemy_cards.Count; id++)

           {

               if (enemy_cards[id].ves == koloda[moe[n]].ves)

               {

                   z= true;

               }

           }

       }

       return z;

   }

   void UpDow(object sender, MouseEventArgs e)

   {

       if (col_vigre > 0)

       {

           if (e.Delta > 0)

           {

               if (my.VerticalScroll.Value >= 20)

               {

                   my.VerticalScroll.Value = my.VerticalScroll.Value - 20;

               }

               else my.VerticalScroll.Value = 0;

           }

           else if (e.Delta < 0)

           {

               my.VerticalScroll.Value = my.VerticalScroll.Value + 20;

           }

       }

   }

   void GoEndMouseClick(object sender, MouseEventArgs e)

   {

       this.Controls.Clear();

       Menu();

   }

   void ChangeProgram(object z, EventArgs x) {

       

       this.Controls.Clear();

       PictureBox back = new PictureBox();

       back.Left = SystemInformation.PrimaryMonitorSize.Width / 5;

       back.Top = SystemInformation.PrimaryMonitorSize.Height / 5;

       back.Width = SystemInformation.PrimaryMonitorSize.Width - (back.Left*2);

       back.Height = SystemInformation.PrimaryMonitorSize.Height - (back.Top*2);

       back.BorderStyle = BorderStyle.FixedSingle;

       back.Image = new Bitmap(SystemInformation.PrimaryMonitorSize.Width-(back.Left*2),SystemInformation.PrimaryMonitorSize.Height-(back.Top*2));

       Graphics back_img = Graphics.FromImage(back.Image);

       back_img.DrawImage(new Bitmap(adrec+"\\img\\change.jpg"),0,0,SystemInformation.PrimaryMonitorSize.Width-(back.Left*2),SystemInformation.PrimaryMonitorSize.Height-(back.Top*2));

       PictureBox rem = new PictureBox();

       rem.Top = back.Top;

       rem.Left = back.Left;

       rem.Width = 30;

       rem.Height = 30;

       rem.Image = new Bitmap(adrec+"\\img\\rem.jpg");

       rem.MouseClick += new MouseEventHandler(SaveAll);

       this.Controls.Add(rem);

       string[] zn = new string[3];

       this.ForeColor = Color.White;

       nacrt = true;

       s.WrapContents = f.WrapContents = false;

       s.Width = f.Width = 200;

       s.Height = f.Height = 120;

       s.Top= f.Top = 160+back.Top;

       s.Left = back.Left + 60;

       f.Left = s.Left + s.Width + 20;

       s.BackColor = f.BackColor = Color.Gray;

       s.Scroll += new ScrollEventHandler(SScroll);

       f.Scroll += new ScrollEventHandler(SScroll);

       if (info[1].Replace("Type of card","") == ": 1 ;") {

           f.BackColor = Color.Gold;

       }

       else if (info[1].Replace("Type of card", "") == ": 2 ;")

       { s.BackColor = Color.Gold; }

       for (int d = 1; d < 36; d++) {

           Bitmap w = new Bitmap((adrec + "\\img\\1\\" + d.ToString() + ".png"));

           PictureBox  ww = new PictureBox();

           ww.MouseClick += new MouseEventHandler(FMouseClick);

           ww.Width = 71;

           ww.Height = 96;

           ww.Image = w;

           f.Controls.Add(ww);

           w = new Bitmap((adrec + "\\img\\2\\" + d.ToString() + ".jpg"));

           ww = new PictureBox();

           ww.MouseClick += new MouseEventHandler(SMouseClick);

           ww.Width = 71;

           ww.Height = 96;

           ww.BorderStyle = BorderStyle.FixedSingle;

           ww.Image = w;

           

           s.Controls.Add(ww);

       }

           s.AutoScroll = f.AutoScroll = true;

       

       this.Controls.Add(s);

       this.Controls.Add(f);

       leng[0] = new RadioButton();

       leng[1] = new RadioButton();

       leng[0].Parent = back;

       leng[1].Parent = back;

       leng[0].Text = "Русcкий";

       leng[1].Text = "English";

       leng[0].Left = back.Left + 65;

       leng[1].Left = leng[0].Left +leng[0].Width+20;

       leng[0].Top = back.Top + 60;

       leng[1].Top = leng[0].Top;

       leng[0].BackgroundImage = leng[1].BackgroundImage = new Bitmap(adrec+"\\img\\radio.jpg");

       leng[0].TextAlign = ContentAlignment.MiddleCenter;

       leng[1].TextAlign = ContentAlignment.MiddleCenter;

       this.Controls.Add(leng[0]);

       this.Controls.Add(leng[1]);

       if (info[0].Replace("Language", "") == ": English ;")

       {

           zn[0] = "select a language game";

           zn[1] = "select a style cards";

           zn[2] = "Help (lower right corner)";

           leng[1].Select();

       }

       else if (info[0].Replace("Language", "") == ": Русский ;")

       {

           zn[0] = "Выберите язык игры";

           zn[1] = "Выберите рисунок карт";

           zn[2] = "Справка (правый нижный угол).";

           leng[0].Select();

       }

       back_img.DrawString(zn[0], new Font("Comic Sans MS", 13F, FontStyle.Regular), new SolidBrush(Color.White), 65, 30);

       back_img.DrawString(zn[1], new Font("Comic Sans MS", 13F, FontStyle.Regular), new SolidBrush(Color.White), 65, 120);

       if (info[2].Replace("Help", "") == ": true ;")

       {

           hp.Checked = true;

       }

       hp.Top = s.Top + s.Height + 50;

       hp.Width = 250;

       hp.BackColor = Color.Black;

       hp.Left = s.Left;

       hp.Text = zn[2];

       hp.BackgroundImageLayout = ImageLayout.Stretch;

       hp.BackgroundImage = new Bitmap(adrec + "\\img\\che.jpg");

       this.Controls.Add(hp);

       

       this.Controls.Add(back);

   }

   

   void SaveAll(object z, MouseEventArgs x) {

       string res = "";

       if (leng[1].Checked)

       {

           res = "Language: English ;\r\n";

       }

       else {

           res = "Language: Русский ;\r\n";

       }

       if (f.BackColor == Color.Gold) {

           res += "Type of card: 1 ;\r\n";

       }

       else {

           res+= "Type of card: 2 ;\r\n";

       }

       if (hp.Checked)

       {

           res += "Help: true ;";

       }

       else {

           res += "Help: false ;";

       }

       StreamWriter rez = iff.CreateText();

       rez.Write(res);

       rez.Close();

       this.Controls.Clear();

       Menu();

   }

   void SMouseClick(object sender, MouseEventArgs e)

   {

       s.BackColor = Color.Gold;

       f.BackColor = Color.Gray;

   }

   void FMouseClick(object sender, MouseEventArgs e)

   {

       f.BackColor = Color.Gold;

       s.BackColor = Color.Gray;

   }

   void SScroll(object sender, ScrollEventArgs e)

   {

       if (nacrt) {

           f.HorizontalScroll.Value = s.HorizontalScroll.Value;

           s.HorizontalScroll.Value = f.HorizontalScroll.Value;

       }

   }

}

class main { static void Main() { Application.Run(new start()); } }

class Karta

{

   public bool trump = false;

   public PictureBox img = new PictureBox();

   public int ves = 0;

   public bool vkolode = true;

   public int mast;

   public bool vigre = false;

   public PictureBox face = new PictureBox();

   public Karta()

   {

       face.Image = new Bitmap(start.adrec + "\\img\\face.jpg");

       face.Width = 71;

       face.Height = 96;

   }

}


 

А также другие работы, которые могут Вас заинтересовать

40119. Математическая модель и схема статического МОБ в денежном выражении. Методологические вопросы построения МОБ 56 KB
  Расчеты проводимые при разработке МОБ: объемы производства продуктов при изготовлении которых участвует данный вид продукции; объемы потребления данного вида продукции для непроизводственных целей по различным каналам; норма расхода данного продукта для цели производственного и непроизводственного потребления по различным направлениям использования продукции и по различным видам. Схема МОБ представляет собой синтез 2х таблиц: первая характеризует детальную структуру затрат на производство в разрезе отдельных видов продукции а др. ...
40120. Свойства коэффициентов прямых материальных затрат в МОБ. Определение косвенных и полных материальных затрат 40.5 KB
  Свойства коэффициентов прямых материальных затрат в МОБ. Определение косвенных и полных материальных затрат. Коэффициент пропорциональности затрат к выпуску в денежном выражении коэффициент прямых материальных затрат. Матрица А ={ij} является матрицей коэффициентов прямых затрат.
40121. Основные понятия теории баз данных: объект, свойство, связь. Диаграмма «сущность-связей». Логическая, физическая, концептуальная схемы базы данных 53.5 KB
  Основные понятия теории баз данных: объект свойство связь. Логическая физическая концептуальная схемы базы данных Информационная система – это система реализующая автоматический сбор обработку и манипулирование данными и включающая в себя технические средства обработки данных программное обеспечение и соответствующий персонал. Структурирование данных – это введение согласований о способах представления данных. База данных – поименованная совокупность данных отражающая состояние объектов и их отношений в рассматриваемой области.
40122. Реляционная модель данных. Основные понятия: отношение, кортеж, домен. Получение нормальных форм отношений из диаграммы «сущность-связь». Реляционная алгебра и ее основные понятия 78 KB
  Реляционная модель данных отличается удобным для пользователя табличным представлением и доступом к данным. Она является совокупностью простейших двумерных таблиц – отношений. В реляционной модели достигается гораздо более высокий уровень абстракции данных, чем в иерархической или сетевой. Это обеспечивается за счет использования математической теории отношений (реляционная алгебра).
40123. Реляционная алгебра, основные операторы реляционной алгебры. Связь языка SQL с операторами реляционной алгебры 100.5 KB
  Основная идея реляционной алгебры состоит в том что коль скоро отношения являются множествами то средства манипулирования отношениями могут базироваться на традиционных теоретикомножественных операциях дополненных некоторыми специальными операциями специфичными для баз данных совокупность которых образует полную алгебру отношений. В состав теоретикомножественных операций входят операции: Объединения отношений. При выполнении операции объединения двух отношений производится отношение включающее все кортежи входящие хотя бы в одно из...
40124. Реляционная модель данных. Теория нормализации. Нормальные формы: первая, вторая, третья, Бойса-Кодда 50 KB
  Реляционная модель данных отличается удобным для пользователя табличным представлением и доступом к данным. В реляционной модели достигается гораздо более высокий уровень абстракции данных чем в иерархической или сетевой. К числу достоинств реляционного подхода можно отнести: – наличие небольшого набора абстракций которые позволяют сравнительно просто моделировать большую часть распространенных предметных областей и допускают точные формальные определения оставаясь интуитивно понятными; – наличие простого и в то же время мощного...
40125. Физическая организация баз данных. Файлы: последовательные, с прямым доступом, с хеш-адресацией, индексно-последовательные, В-деревья 78 KB
  Предполагается что для доступа к iой записи нужно просмотреть все i1 записи. Последовательный доступ с фиксированной длиной записи. Картинка i = 0 i 1L Если записи располагаются в оперативной памяти то это массив. Если записи расположены на диске то порядок ввода вывода данных зависит от языка программирования.
40126. Вычислительная машина 97.5 KB
  Машина Шикарда умела складывать и вычитать шестизначные числа оповещая звонком о переполнении. Оригинальная машина была утеряна до двадцатого столетия но в 1960 году была построена её точная работающая копия. Машина Паскаля позволяла выполнять не только сложение но и другие операции однако при этом требовала применения довольно неудобной процедуры повторных сложений.
40127. Операционная система 39.5 KB
  С 1990х наиболее распространенными операционными системами являются ОС семейства Microsoft Windows и UNIXподобные системы. Windows 2000 в полной мере использует возможности машин с несколькими процессорами. Windows 2000 способна закрепить каждый поток за отдельным процессором и тогда два потока исполняются действительно одновременно. Ядро Windows 2000 полностью поддерживает распределение процессорного времени между потоками и управление ими на таких системах.