Как се мисли игра

Проблем

Откъде започва една игра?

Искаш да напишеш игра. Например надбягване със зар: фигурка тръгва от поле 0, хвърляш зар и тя върви напред, докато стигне поле 20.

Отваряш редактора и... какво пишеш най-напред? Менюто? Зара? Дъската? Ако започнеш от всичко наведнъж, след час имаш много код, който още не се пуска.

Помага да зададеш на играта пет въпроса, преди да пишеш код.

Идеята

Пет въпроса за всяка игра

1. Състояние. Кои числа описват света сега? При надбягването е полето на фигурката и номерът на хода. При шаха е къде стои всяка фигура и кой е на ход.
2. Правила. Какво е позволено и какво става след него? „Фигурката върви толкова полета, колкото е зарът.“
3. Вход. Какво идва отвън? Изборът на играча или числото на зара.
4. Цикъл. Ход след ход: вход, обновяване на състоянието, показване. После пак.
5. Край. Кога играта свършва и кой печели? „Фигурката е на поле 20.“

Отговорите са почти готовият код: състоянието са променливи, правилата са методи, входът е Console.ReadLine() или Random, цикълът е while или for, а краят е условието на цикъла.

Виж го

Ход след ход

Random random = new Random(42);
int field = 0;
for (int turn = 1; field < 20; turn++)
{
    int roll = random.Next(1, 7);
    field = Math.Min(field + roll, 20);
    Console.WriteLine("Ход " + turn + ": зар " + roll + ", поле " + field);
}
Console.WriteLine("Финал! Фигурката стигна поле 20.");

Стъпка по стъпка, с думи

1. Генератор със семе 42 и фигурка на поле 0.
2. Ход 1: вход е зарът 5, състоянието става поле 5, екранът показва реда.
3. Ход 2: вход е зарът 1, състоянието става поле 6, екранът показва реда.
4. Ход 3: вход е зарът 1, състоянието става поле 7, екранът показва реда.
5. Ход 4: вход е зарът 4, състоянието става поле 11, екранът показва реда.
6. Ход 5: вход е зарът 2, състоянието става поле 13, екранът показва реда.
7. Ход 6: вход е зарът 2, състоянието става поле 15, екранът показва реда.
8. Ход 7: вход е зарът 5, състоянието става поле 20, екранът показва реда. Поле 20: условието field < 20 вече е невярно.
9. Цикълът свърши, защото полето стигна 20. Това е краят на играта.

Цялата игра е един цикъл. На всеки ход идва вход (зарът), състоянието се обновява (новото поле) и се показва (един ред на екрана). Условието на цикъла е краят: докато полето е под 20, има следващ ход.

Math.Min пази фигурката на дъската: ако зарът я изпрати след 20, тя спира на 20.

По-точно, за любопитните

• Тази игра е ходова: нищо не се случва, докато не дойде следващият вход. Така са шахът, картите и повечето игри в този раздел.
• Игрите в реално време (стрелба, състезания с коли) също имат цикъл, но той не чака играча. Той се върти 60 пъти в секунда: прочита клавишите, които са натиснати в момента, мести всичко според изминалото време и рисува кадъра. Ако играчът не натисне нищо, светът пак се движи.

Идеята

Същото семе, същата игра

Ако хвърлянията са истински случайни, всяко пускане е различна игра. Как тогава ще провериш, че играта работи? Не знаеш какво да очакваш.

Затова в тези уроци Random получава начално число, семе. Едно и също семе дава една и съща поредица, всеки път:

Java

Random first = new Random(42);
Random second = new Random(42);
for (int i = 0; i < 5; i++) {
    int a = first.nextInt(6) + 1;
    int b = second.nextInt(6) + 1;
    System.out.println(a + " и " + b);
}

Изход

3 и 3
4 и 4
1 и 1
3 и 3
1 и 1

C#

Random first = new Random(42);
Random second = new Random(42);
for (int i = 0; i < 5; i++)
{
    int a = first.Next(1, 7);
    int b = second.Next(1, 7);
    Console.WriteLine(a + " и " + b);
}

Изход

5 и 5
1 и 1
1 и 1
4 и 4
2 и 2

Python

from random import Random

first = Random(42)
second = Random(42)
for i in range(5):
    a = first.randint(1, 6)
    b = second.randint(1, 6)
    print(f"{a} и {b}")

Изход

6 и 6
1 и 1
1 и 1
6 и 6
3 и 3

JavaScript

function makeRandom(seed) {
  return () => {
    seed = (seed + 0x9e3779b9) | 0;
    let z = seed;
    z = Math.imul(z ^ (z >>> 16), 0x85ebca6b);
    z = Math.imul(z ^ (z >>> 13), 0xc2b2ae35);
    return ((z ^ (z >>> 16)) >>> 0) / 4294967296;
  };
}

const first = makeRandom(42);
const second = makeRandom(42);
for (let i = 0; i < 5; i++) {
  const a = Math.floor(first() * 6) + 1;
  const b = Math.floor(second() * 6) + 1;
  console.log(`${a} и ${b}`);
}

Изход

2 и 2
6 и 6
1 и 1
5 и 5
1 и 1

Двата генератора с 42 дават едни и същи числа. Пусни програмата пак и ще са същите. Затова примерите и задачите тук имат точен изход, който може да се провери.

Виж изхода и в другите табове. Всеки език има свой генератор: от едно и също семе те дават различни числа. Затова примерите със случайни числа имат изход за всеки език.

По-точно, за любопитните

• Когато играта е готова за истински играчи, махаш семето: new Random(). Тогава генераторът сам избира семе от часовника и всяка игра е различна.

• Честа практика е семето да се отпечата в началото на играта. Ако играч намери бъг, с неговото семе можеш да изиграеш точно същата игра.

Идеята

Първо най-малката работеща версия

Програмата от сцената е цяла игра в десетина реда. Тя няма двама играчи, нито меню, нито правила освен „върви напред“. Но върви от началото до края и показва, че цикълът и краят са верни.

Оттам играта расте с по едно правило. Второто правило: фигурката трябва да стигне поле 20 точно. Ако зарът я изпрати по-далеч, тя отскача назад с толкова полета, колкото е прехвърлила. От 17 със зар 5 тя стига 20 и се връща на 18.

Ново правило се добавя, само когато предишното работи. Ако нещо се счупи, знаеш, че е в последното, което си писал.

Идеята

Логиката връща, екранът печата

Правилото „точно 20“ е в метод, който връща новото поле. Краят е метод, който връща true или false:

Java

static int move(int field, int roll) {
    int next = field + roll;
    if (next > 20) {
        return 20 - (next - 20);
    }
    return next;
}

static boolean isFinished(int field) {
    return field == 20;
}

Random random = new Random(7);
int field = 0;
int turn = 0;
while (!isFinished(field)) {
    turn++;
    int roll = random.nextInt(6) + 1;
    field = move(field, roll);
    System.out.println("Ход " + turn + ": зар " + roll + ", поле " + field);
}
System.out.println("Точно на 20 след " + turn + " хода");

Изход

Ход 1: зар 5, поле 5
Ход 2: зар 3, поле 8
Ход 3: зар 4, поле 12
Ход 4: зар 5, поле 17
Ход 5: зар 5, поле 18
Ход 6: зар 5, поле 17
Ход 7: зар 5, поле 18
Ход 8: зар 6, поле 16
Ход 9: зар 1, поле 17
Ход 10: зар 1, поле 18
Ход 11: зар 1, поле 19
Ход 12: зар 1, поле 20
Точно на 20 след 12 хода

C#

static int Move(int field, int roll)
{
    int next = field + roll;
    if (next > 20)
    {
        return 20 - (next - 20);
    }
    return next;
}

static bool IsFinished(int field)
{
    return field == 20;
}

Random random = new Random(7);
int field = 0;
int turn = 0;
while (!IsFinished(field))
{
    turn++;
    int roll = random.Next(1, 7);
    field = Move(field, roll);
    Console.WriteLine("Ход " + turn + ": зар " + roll + ", поле " + field);
}
Console.WriteLine("Точно на 20 след " + turn + " хода");

Изход

Ход 1: зар 3, поле 3
Ход 2: зар 6, поле 9
Ход 3: зар 4, поле 13
Ход 4: зар 1, поле 14
Ход 5: зар 3, поле 17
Ход 6: зар 5, поле 18
Ход 7: зар 1, поле 19
Ход 8: зар 6, поле 15
Ход 9: зар 6, поле 19
Ход 10: зар 6, поле 15
Ход 11: зар 3, поле 18
Ход 12: зар 6, поле 16
Ход 13: зар 3, поле 19
Ход 14: зар 1, поле 20
Точно на 20 след 14 хода

Python

def move(field, roll):
    new_field = field + roll
    if new_field > 20:
        return 20 - (new_field - 20)
    return new_field


def is_finished(field):
    return field == 20


random = Random(7)
field = 0
turn = 0
while not is_finished(field):
    turn += 1
    roll = random.randint(1, 6)
    field = move(field, roll)
    print(f"Ход {turn}: зар {roll}, поле {field}")
print(f"Точно на 20 след {turn} хода")

Изход

Ход 1: зар 3, поле 3
Ход 2: зар 2, поле 5
Ход 3: зар 4, поле 9
Ход 4: зар 6, поле 15
Ход 5: зар 1, поле 16
Ход 6: зар 1, поле 17
Ход 7: зар 5, поле 18
Ход 8: зар 1, поле 19
Ход 9: зар 3, поле 18
Ход 10: зар 5, поле 17
Ход 11: зар 1, поле 18
Ход 12: зар 5, поле 17
Ход 13: зар 2, поле 19
Ход 14: зар 1, поле 20
Точно на 20 след 14 хода

JavaScript

function move(field, roll) {
  const next = field + roll;
  if (next > 20) {
    return 20 - (next - 20);
  }
  return next;
}

function isFinished(field) {
  return field === 20;
}

const random = makeRandom(7);
let field = 0;
let turn = 0;
while (!isFinished(field)) {
  turn++;
  const roll = Math.floor(random() * 6) + 1;
  field = move(field, roll);
  console.log(`Ход ${turn}: зар ${roll}, поле ${field}`);
}
console.log(`Точно на 20 след ${turn} хода`);

Изход

Ход 1: зар 1, поле 1
Ход 2: зар 3, поле 4
Ход 3: зар 6, поле 10
Ход 4: зар 4, поле 14
Ход 5: зар 3, поле 17
Ход 6: зар 2, поле 19
Ход 7: зар 5, поле 16
Ход 8: зар 2, поле 18
Ход 9: зар 2, поле 20
Точно на 20 след 9 хода

Нито Move, нито IsFinished печата нещо. Те само смятат. Печатането е в Main.

Защо така? Метод, който връща число, можеш да извикаш с каквито стойности искаш и да провериш резултата: Move(17, 5) трябва да е 18. Метод, който печата, проверяваш само с очи. А ако утре играта мине от конзолата в прозорец, правилата остават същите, сменя се само показването.

Пробвай

Къде ще стъпи фигурката?

Какво ще отпечата програмата?

static int Move(int field, int roll)
{
    int next = field + roll;
    if (next > 20)
    {
        return 20 - (next - 20);
    }
    return next;
}

static bool IsFinished(int field)
{
    return field == 20;
}

Console.WriteLine(Move(10, 4));
Console.WriteLine(Move(17, 3));
Console.WriteLine(Move(18, 5));

Отговор

14
20
23

14
20
20

14
20
17

14
23
17

Провери

Пробвай

Намери грешката

Фигурката трябва да върви напред, а програмата печата поле 0 на всеки ход:

Изход

Ход 1: зар 3, поле 0
Ход 2: зар 6, поле 0
Ход 3: зар 4, поле 0

На кой ред е грешката?

Избери реда с грешката.

1Random random = new Random(7);2int field = 0;3for (int turn = 1; turn <= 3; turn++)4{5 int roll = random.Next(1, 7);6 Move(field, roll);7 Console.WriteLine("Ход " + turn + ": зар " + roll + ", поле " + field);8}

Провери

Пробвай

Кога свършва играта?

Кое липсва, за да е краят точно на поле 20?

static bool IsFinished(int field)
{
    return field  20;
}

Провери

Упражнение

Три малки игри

Реши задачите в редактора си. Логиката е в методи, които връщат стойност, а печатането е в Main.

1. Надбягване за двама. Ана и Борис хвърлят по ред, с new Random(3). Важи правилото „точно 20“ с Move от урока. Полетата им са в масив int[2]. Който стигне 20 пръв, печели.

Изход

Ана: зар 2, поле 2
Борис: зар 5, поле 5
Ана: зар 6, поле 8
Борис: зар 2, поле 7
Ана: зар 4, поле 12
Борис: зар 2, поле 9
Ана: зар 2, поле 14
Борис: зар 6, поле 15
Ана: зар 3, поле 17
Борис: зар 3, поле 18
Ана: зар 4, поле 19
Борис: зар 5, поле 17
Ана: зар 5, поле 16
Борис: зар 1, поле 18
Ана: зар 1, поле 17
Борис: зар 6, поле 16
Ана: зар 1, поле 18
Борис: зар 6, поле 18
Ана: зар 5, поле 17
Борис: зар 3, поле 19
Ана: зар 2, поле 19
Борис: зар 4, поле 17
Ана: зар 3, поле 18
Борис: зар 1, поле 18
Ана: зар 6, поле 16
Борис: зар 3, поле 19
Ана: зар 4, поле 20
Печели Ана

2. Познай числото. Програмата избира тайно число от 1 до 100 с new Random(2026). Играчът пише догадки, по една на ред. След всяка програмата казва „По-голямо е“, „По-малко е“ или „Позна“. Накрая казва от колко опита. Подсказката е метод string Hint(int guess, int secret), който връща текста.

Вход

50
25
12
18
16

Изход

50: По-малко е
25: По-малко е
12: По-голямо е
18: По-малко е
16: Позна
Позна от 5 опита

Входът е различен за всеки език, защото генераторите им избират различно тайно число от едно и също семе.

3. Кой спечели морския шах? Първият ред е броят на дъските. Всяка дъска е три реда по три знака: X, O или . за празно поле. Напиши метод char Winner(char[,] board), който връща X, O или ., ако няма три еднакви в ред, колона или диагонал.

Вход

3
XOX
OXO
OOX
XXO
OOO
X.X
XOX
XOO
OXX

Изход

Печели X
Печели O
Няма победител

Още задачи

• Капани. Поле 13 връща фигурката на поле 5. Добави правилото в Move и пусни надбягването пак.
• Отпечатай семето. Направи семето променлива, отпечатай го в началото и пусни играта с три различни семена.
• Морски шах за двама. Играчите пишат ред и колона на хода си. След всеки ход покажи дъската и провери с Winner дали играта е свършила.

Тест

Провери се

1. Кое е състоянието на надбягването със зар?

Методът, който мести фигуркатаЧислото на зараПолето, на което е фигурката, и номерът на хода

2. Защо в играта пише new Random(42), а не new Random()?

Така всяко пускане дава същите хвърляния и играта може да се провериБез число Random не работиТака числата са по-случайни

3. Защо правилото за местене е метод, който връща новото поле, а не метод, който печата?

Така правилото се проверява и ползва отделно от екранаМетодите не могат да печататТака е по-бързо

4. Коя е добрата първа версия на игра?

Всички правила наведнъж, за да не се пренаписваПърво менюто и цветоветеНай-малката, която върви от началото до края, после правило по правило

Провери

Започни урока отначало