Цикълът на играта в Python

Проблем

Програма, която свършва

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

Първото, което идва наум, е while (true), който чете ред и прави всичко вътре. Коридор от 12 клетки: ти си @, гоблинът g те гони, изходът е >:

hero = 4
goblin = 0
while True:
    command = input()
    if command == "q":
        break
    if command == "a":
        hero -= 1
    if command == "d":
        hero += 1
    row = ""
    for x in range(12):
        row += "@" if x == hero else "g" if x == goblin else ">" if x == 11 else "."
    print(row)
    if hero == 11:
        print("Изход!")
        break
    goblin += 1 if goblin < hero else -1
    if abs(hero - goblin) <= 1:
        print("Гоблинът те хвана.")
        break

Играчът пише x (сбъркал е клавиша) и после a:

g...@......>
.g.@.......>
Гоблинът те хвана.

Три неща не са наред:

Преди първата команда екранът е празен: програмата рисува чак след като прочете ред.
Печатната грешка x е ход: гоблинът е стъпил. Програмата не различава „играчът направи нещо“ от „играчът сбърка клавиша“.
Последният кадър е .g.@: между вас има празна клетка, а гоблинът те хваща. Кадърът е отпечатан след твоята стъпка и преди тази на гоблина. Положението, в което играта свърши, никой не го е видял.

И две неща не стават изобщо. Не можеш да нарисуваш екрана наново без ход: след помощта с ? или след инвентара рисуването трябва да се копира. Не можеш да провериш правилото „гоблинът стъпва към героя“, без да пишеш команди и да четеш текст. Причината е една: светът, правилата и рисуването са смесени на едно място.

Идеята

Четири стъпки в кръг

Разделяме ги:

Състоянието е всичко, което светът е, в един обект: героят, гоблинът, изходът, броячът на ходовете, съобщението, краят. Екранът не е част от него. Екранът се смята от него.
draw само чете състоянието и печата кадър. Може да се вика колкото пъти искаш.
handle превежда командата в намерение: move е -1, 1 или 0. Никого не мести.
update сменя света: ходът, героят, гоблинът, краят. Не печата нищо.

Цикълът ги вика в кръг: нарисувай, прочети, обработи, обнови. Това е цикълът на играта (game loop). Има го във всяка игра, от този коридор до Арканум.

class State:
    def __init__(self):
        self.hero = 4
        self.goblin = 0
        self.exit = 11
        self.turn = 0
        self.move = 0
        self.message = ""
        self.over = False


state = State()
while not state.over:
    draw(state)
    command = read()
    handle(state, command)
    update(state)
draw(state)

over спира цикъла, а последното draw след него показва края: изхода или гоблина, със съобщението.

Четенето е отделна функция, защото входът може да свърши:

def read():
    try:
        line = input()
    except EOFError:
        return None
    print(f"> {line}")
    return line

В края на входа input() хвърля EOFError. read го хваща и връща None, а handle го смята за край на играта. Ехото > a е, за да се вижда в изхода коя команда е дошла. Конзолата на играча я показва сама.

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

Без проверката за края на входа всеки език се чупи различно. Java хвърля изключение, Python също. C# е най-коварен: Console.ReadLine() връща null, сравнението command == "q" е невярно, и първият опит не разбира, че входът е свършил: печата кадри с празни ходове, докато гоблинът не стигне героя сам. JavaScript получава undefined и прави същото. Входът свършва по-често, отколкото мислиш: файл с команди, затворен терминал, проверката на сайта.

Виж го

Един ход отблизо

Ето трите функции. В тях е цялата игра:

def draw(s):
    row = ""
    for x in range(s.exit + 1):
        if x == s.hero:
            row += "@"
        elif x == s.goblin:
            row += "g"
        elif x == s.exit:
            row += ">"
        else:
            row += "."
    print(f"Ход {s.turn}  {row}")
    if s.message:
        print(s.message)


def handle(s, command):
    s.move = 0
    s.message = ""
    if command is None:
        s.message = "Входът свърши."
        s.over = True
    elif command == "a":
        s.move = -1
    elif command == "d":
        s.move = 1
    elif command == "q":
        s.message = "Тръгна си."
        s.over = True
    else:
        s.message = f"Не разбирам „{command}“: ходът не мина."


def update(s):
    if s.move == 0:
        return
    s.turn += 1
    s.hero = max(0, s.hero + s.move)
    if s.hero == s.exit:
        s.message = f"Изход! Избяга за {s.turn} хода."
        s.over = True
        return
    if abs(s.hero - s.goblin) > 1:
        s.goblin += 1 if s.goblin < s.hero else -1
    if abs(s.hero - s.goblin) <= 1:
        s.message = "Гоблинът те хвана."
        s.over = True

state = State()
while not state.over:
    draw(state)
    command = read()
    handle(state, command)
    update(state)
draw(state)


def draw(s):
    row = ""
    for x in range(s.exit + 1):
        if x == s.hero:
            row += "@"
        elif x == s.goblin:
            row += "g"
        elif x == s.exit:
            row += ">"
        else:
            row += "."
    print(f"Ход {s.turn}  {row}")
    if s.message:
        print(s.message)


def handle(s, command):
    s.move = 0
    s.message = ""
    if command is None:
        s.message = "Входът свърши."
        s.over = True
    elif command == "a":
        s.move = -1
    elif command == "d":
        s.move = 1
    elif command == "q":
        s.message = "Тръгна си."
        s.over = True
    else:
        s.message = f"Не разбирам „{command}“: ходът не мина."


def update(s):
    if s.move == 0:
        return
    s.turn += 1
    s.hero = max(0, s.hero + s.move)
    if s.hero == s.exit:
        s.message = f"Изход! Избяга за {s.turn} хода."
        s.over = True
        return
    if abs(s.hero - s.goblin) > 1:
        s.goblin += 1 if s.goblin < s.hero else -1
    if abs(s.hero - s.goblin) <= 1:
        s.message = "Гоблинът те хвана."
        s.over = True

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

Ход 1 е минал: героят е на клетка 5, гоблинът на клетка 1. Целият свят е обектът със състоянието, а цикълът е пак горе.
draw минава по 12-те клетки и печата кадъра .g...@.....>. Само чете състоянието: в панела нищо не се сменя.
read чака. Светът стои, докато играчът не натисне Enter. Пристига редът „a“.
handle само превежда командата в намерение: move = -1. Още никой не е мръднал.
update сменя света. Броячът на ходовете става 2, а героят стъпва от 5 на 4. Не е изходът, затова ходът продължава.
Гоблинът е на 3 клетки, затова стъпва към героя: от 1 на 2. Вече са 2: не е хванат, играта продължава.
Отново горе draw печата ..g.@......>: кадърът идва след целия ход, затова играчът вижда къде е гоблинът наистина.

С командите d, a, x и седем пъти d програмата печата:

Ход 0  g...@......>
> d
Ход 1  .g...@.....>
> a
Ход 2  ..g.@......>
> x
Ход 2  ..g.@......>
Не разбирам „x“: ходът не мина.
> d
Ход 3  ...g.@.....>
> d
Ход 4  ....g.@....>
> d
Ход 5  .....g.@...>
> d
Ход 6  ......g.@..>
> d
Ход 7  .......g.@.>
> d
Ход 8  ........g.@>
> d
Ход 9  ........g..@
Изход! Избяга за 9 хода.

На x кадърът се рисува наново, но ходът остава 2 и гоблинът стои: update вижда move = 0 и не прави нищо. Това става, защото draw не пипа света. Гоблинът стъпва след героя, а кадърът идва след целия ход, затова виждаш точно къде е. На изхода гоблинът не стъпва: играта свършва преди неговата стъпка.

Правилата вече могат да се проверят без екран и без писане на команди. Сглобяваш състояние на ръка, викаш update и гледаш числата:

near = State()
near.hero = 5
near.goblin = 3
near.move = -1
update(near)
print(near.hero, near.goblin, near.message)

far = State()
far.move = 1
update(far)
print(far.hero, far.goblin, far.turn)

4 3 Гоблинът те хвана.
5 1 1

Това е тест на правилото „гоблинът хваща, ако е до теб“. В истинска игра такива проверки са стотици. С първия опит не можеше да се напише нито една.

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

Защо handle не мести героя направо? В коридора би могъл. Но в Арканум едно и също a значи „наляво“ на картата, „назад“ в менюто и „нищо“ в диалога. Командата се разбира от екрана, а светът се сменя от правилата. И второ: команда, която не е ход (печатна грешка, отваряне на инвентара, помощ), не трябва да движи света. Затова намерението се записва отделно, а update решава дали изобщо има ход.

Пробвай

Подреди цикъла

Подреди редовете на цикъла:

while not state.over:
draw(state)
command = read()
update(state)
handle(state, command)

Пробвай

Предвиди изхода

Същата програма получава командите a, x, a. Правилата са тези:

def handle(s, command):
    s.move = 0
    s.message = ""
    if command is None:
        s.message = "Входът свърши."
        s.over = True
    elif command == "a":
        s.move = -1
    elif command == "d":
        s.move = 1
    elif command == "q":
        s.message = "Тръгна си."
        s.over = True
    else:
        s.message = f"Не разбирам „{command}“: ходът не мина."


def update(s):
    if s.move == 0:
        return
    s.turn += 1
    s.hero = max(0, s.hero + s.move)
    if s.hero == s.exit:
        s.message = f"Изход! Избяга за {s.turn} хода."
        s.over = True
        return
    if abs(s.hero - s.goblin) > 1:
        s.goblin += 1 if s.goblin < s.hero else -1
    if abs(s.hero - s.goblin) <= 1:
        s.message = "Гоблинът те хвана."
        s.over = True

Отговор

Ход 0  g...@......>
> a
Ход 1  .g.@.......>
> x
Ход 2  ..g@.......>
Гоблинът те хвана.

Ход 0  g...@......>
> a
Ход 1  .g.@.......>
> x
Ход 1  .g.@.......>
Не разбирам „x“: ходът не мина.
> a
Ход 2  .g@........>
Гоблинът те хвана.

Ход 0  g...@......>
> a
Ход 1  .g.@.......>
> x
Ход 1  .g.@.......>
Не разбирам „x“: ходът не мина.
> a
Ход 2  ..@........>
Гоблинът те хвана.

Пробвай

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

Колега реши, че гоблинът трябва да се движи „на всеки кадър“, и премести стъпката му от update в draw. С командите d, x, x, d програмата печата:

Ход 0  .g..@......>
> d
Ход 1  ..g..@.....>
> x
Ход 1  ...g.@.....>
Не разбирам „x“: ходът не мина.
> x
Ход 1  ....g@.....>
Не разбирам „x“: ходът не мина.
> d
Ход 2  .....g@....>
Ход 2  .....g@....>
Входът свърши.

Още на кадър 0 гоблинът е на клетка 1. На двете печатни грешки ходът стои 1, а гоблинът тича. Накрая е до героя и нищо не става. На кой ред е грешката?

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

Идеята

Ход и кадър

Коридорът е походов: светът стои, докато не дойде команда. Един ход, един кадър. Конзолата дава цял ред чак след Enter и четенето чака, затова играта в конзолата е походова по природа. Така са шахът, roguelike игрите (Rogue, NetHack) и боевете в много стратегии.

Игра в реално време не чака. Светът се движи по часовник: ако не правиш нищо, гоблинът пак идва. Цикълът се върти десетки пъти в секунда: поглежда дали има натиснат клавиш (без да чака), обновява света за изминалото време и рисува. Едно рисуване е кадър (frame), а една стъпка на света е отделно нещо.

Четирите части са същите. Сменя се кой върти цикъла: редът на играча или часовникът. И там разделянето на draw и update е още по-важно: бърз монитор рисува 144 кадъра в секунда, но светът трябва да стъпва с еднакво темпо на всеки компютър.

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

Фиксиран такт. Ако светът стъпва „колкото време е минало от миналия кадър“, физиката зависи от кадрите: при бавен кадър стрелата прескача стената, а два компютъра никога не дават същото. Затова светът стъпва на равни парчета, например 50 ms. Минатото време се натрупва (accumulator), и цикълът прави толкова стъпки, колкото парчета са се събрали. Остатъкът чака следващия кадър.

Тук часовникът е измислен (списък с моментите на кадрите), за да е изходът един и същ. Бързият компютър рисува на неравни интервали, бавният рядко:

def run(name, times):
    step = 50
    acc = 0
    x = 0
    last = times[0]
    for now in times:
        acc += now - last
        last = now
        steps = 0
        while acc >= step:
            x += 3
            steps += 1
            acc -= step
        print(f"{name} {now} ms: стъпки {steps}, x = {x}, остатък {acc} ms")

run("бърз", [0, 16, 40, 45, 110, 126, 150])
run("бавен", [0, 90, 150])

бърз 0 ms: стъпки 0, x = 0, остатък 0 ms
бърз 16 ms: стъпки 0, x = 0, остатък 16 ms
бърз 40 ms: стъпки 0, x = 0, остатък 40 ms
бърз 45 ms: стъпки 0, x = 0, остатък 45 ms
бърз 110 ms: стъпки 2, x = 6, остатък 10 ms
бърз 126 ms: стъпки 0, x = 6, остатък 26 ms
бърз 150 ms: стъпки 1, x = 9, остатък 0 ms
бавен 0 ms: стъпки 0, x = 0, остатък 0 ms
бавен 90 ms: стъпки 1, x = 3, остатък 40 ms
бавен 150 ms: стъпки 2, x = 9, остатък 0 ms

На 150 ms и двата са направили по 3 стъпки и стрелата е на 9. Кадрите са различни, светът е същият. Остатъкът се ползва и за рисуването: при 10 ms от 50 стрелата се рисува 20% по пътя към следващата си позиция (интерполация), за да не трепти.

Четене без чакане и сурови клавиши. Терминалът сам държи реда, докато не натиснеш Enter. Програмата получава нищо, докато не дойде целият ред. За реално време терминалът трябва да мине в „суров“ режим (raw mode), в който всеки клавиш идва веднага, а програмата трябва да пита „има ли клавиш?“, без да чака.

В Windows има msvcrt.kbhit() и msvcrt.getwch(). В Linux и macOS терминалът се превключва с tty.setcbreak, а select.select([sys.stdin], [], [], 0) пита дали има вход, без да чака. Модулът curses прави и двете: с nodelay(True) методът getch() връща -1, когато нищо не е натиснато.

Арканум остава походова. Същият код трябва да върви в браузъра, в проверката (командите идват от файл) и в терминала на всеки. Редът текст работи навсякъде. Суровият режим не съществува за файл.

Идеята

Семе и повторяемост

Играта има нужда от случайност: удар или пропуск, каква плячка пада, накъде тръгва вълкът. Но грешка, която зависи от случайността, не може да се повтори. Затова генераторът има семе (seed): от едно и също семе излизат едни и същи числа.

Това е генераторът на Арканум:

# mulberry32: малък генератор със семе. Само 32-битови цели числа (маска & 0xFFFFFFFF и ръчно
# imul), затова дава една и съща поредица на всеки език.
MASK32 = 0xFFFFFFFF


# Math.imul от JavaScript: произведението, от което остават само долните 32 бита.
def imul(a, b):
    return (a * b) & MASK32


# „x >>> 0“ от JavaScript: число към 32 бита без знак (нечисло и безкрайност стават 0).
def to_uint32(value):
    if value != value or value == float('inf') or value == float('-inf'):
        return 0
    return int(value) & MASK32


class Random:
    def __init__(self, seed):
        self.state = seed & MASK32

    def next32(self):
        self.state = (self.state + 0x6D2B79F5) & MASK32
        z = self.state
        z = imul(z ^ (z >> 15), z | 1)
        z = (z ^ (z + imul(z ^ (z >> 7), z | 61))) & MASK32
        return (z ^ (z >> 14)) & MASK32

    # От 0 до n-1, без дробни числа.
    def next_int(self, n):
        return self.next32() % n

    # От min до max, двете включени.
    def range(self, low, high):
        return low + self.next_int(high - low + 1)

    def chance(self, percent):
        return self.next_int(100) < percent

Генераторът помни едно-единствено число, state. Всяко next32() го мести с една голяма константа и разбърква битовете му. next_int(n) взима остатъка при деление на n, тоест число от 0 до n − 1. Зар d20 е range(1, 20). Хвърляме го пет пъти със семе 2026, после пак със 2026, после със 7:

def roll(seed):
    dice = Random(seed)
    line = f"семе {seed}:"
    for _ in range(5):
        line += f" {dice.range(1, 20)}"
    print(line)

roll(2026)
roll(2026)
roll(7)

семе 2026: 16 19 3 17 18
семе 2026: 16 19 3 17 18
семе 7: 13 11 15 11 16

Същото семе, същите числа. На четирите езика.

def range(self, low, high):
    return low + self.next_int()

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

Защо не вграденият Random? Всеки език има свой алгоритъм. Java ползва линеен конгруентен генератор с 48 бита, .NET друг, Python Mersenne Twister, а Math.random() в JavaScript изобщо не приема семе. Едно и също семе дава различни числа на различните езици, а в JavaScript не можеш да го зададеш. mulberry32 е десетина реда, затова е написан четири пъти по един и същ начин.

Числата трябва да са 32-битови без знак навсякъде. Цялото число в Python расте без край, затова всяка сметка се реже с & 0xFFFFFFFF, а imul е умножението на JavaScript, от което остават долните 32 бита.

Идеята

Само цели числа

Семето не стига. Вземи едно и също деление на четирите езика:

print(-7 // 2)
print(10 / 2)

-4
5.0

На четирите езика изходът е такъв:

Език	цяло деление на −7 на 2	10 / 2 с дроб
Java	`-3`	`5.0`
C#	`-3`	`5`
Python	`-4`	`5.0`
JavaScript	`-3`	`5`

Python закръгля цялото деление надолу, а другите към нулата. Дробното число се печата с .0 или без. Един различен знак в изхода, и боят на Python вече не е същият като на Java. Затова каноните смятат само с цели числа, делят изрично и не делят отрицателни числа. Сортирането винаги има второ правило, а колекциите пазят реда на добавяне.

Наградата е голяма. Със семето, командите и версията на играта едно минаване е функция: същият вход дава същия изход. Играч пише: „На ход 412 вълкът ме удари през стената.“ Ако играта пази семето и командите му, пускаш ги и стигаш точно до ход 412, колкото пъти трябва, под дебъгер. Проверката на сайта прави същото: записаните команди и семе 2026 дават на четирите езика байт по байт един и същ изход.

Идеята

Истинският цикъл на Арканум

Ето цикъла на играта, без съкращения:

# Цикълът на играта: нарисувай → прочети команда → обработи → обнови света → приложи промените
# в стека. Повтаря, докато стекът не опустее.
def main(io, options):
    global LANG
    seed = 2026 if options.seed is None else to_uint32(options.seed)
    if options.lang != 'bg' and options.lang != 'en' and options.lang != 'de' and options.lang != 'es':
        raise RuntimeError('unknown language: ' + str(options.lang) + ' (use bg, en, de or es)')
    LANG = options.lang
    if options.memory_saves:
        io.save('3', tampered_save())
    load_data()
    simulate_count = 0 if options.simulate is None else options.simulate
    if simulate_count > 0:
        simulate(io, simulate_count, seed)
        return
    terminal = PlainTerminal(io) if options.plain is True else AnsiTerminal(io)
    game = Game(io, seed)
    buffer = CellBuffer(SCREEN_WIDTH, SCREEN_HEIGHT)
    game.stack.push(TitleScreen(game))
    game.stack.apply()
    while not game.stack.is_empty():
        buffer.clear()
        game.stack.draw(buffer)
        terminal.present(buffer)
        line = io.read_line()
        if line is None:
            io.write(t('ui.endOfInput') + '\n')
            return
        terminal.echo(line)
        game.raw_input = trim_spaces(line)
        top = game.stack.top()
        top.handle(game.raw_input.lower())
        top.update()
        game.stack.apply()
    io.write(t('ui.goodbye') + '\n')

Ред по ред:

game.stack.push(TitleScreen(game)) слага първия екран. Целият свят е в game, както в коридора е в state.
Цикълът върви, докато в стека от екрани има нещо. Изходът от менюто маха всички екрани и играта свършва. Това е темата на следващия урок.
Нарисувай. Екраните рисуват в буфер от клетки (знак и цвят), а терминалът решава как да го покаже: като обикновен текст или с цветове. Това е в урока за рисуването в конзолата.
Прочети. Ако входът е свършил, играта казва „край на входа“ и спира. Същото като нашето None. Ехото на реда е като нашето > a.
Обработи и обнови. Само екранът най-отгоре получава командата: картата, боят или менюто.
Приложи. Петата стъпка, която коридорът няма. Екраните искат промени в стека, докато обработват (започни бой, затвори менюто), а те се прилагат чак в края на хода. Защо не веднага, е в урока за екраните, които връщат отговор.

Къде е ходът на света? В коридора е в update. В Арканум картата вика world_turn() от своя handle, само когато героят наистина е направил нещо: стъпил, отворил врата, изчакал. На печатна грешка или на i за инвентара светът не мърда. Това е нашето „move е 0, няма ход“:

# Ходът на света след хода на героя: ефектите, бавното възстановяване, враговете, засадата.
def world_turn(self):
    level = self.level()
    hero = self.hero
    self.turn += 1
    self.stats.turns += 1
    compute_fov(level, hero.x, hero.y)
    tick_effects(hero, self)
    if not hero.is_alive():
        self.hero_died()
        return
    if self.turn % 3 == 0 and not hero.has_effect('bleed') and not hero.has_effect('poison'):
        hero.heal(1)
        if hero.mana < hero.max_mana():
            hero.mana += 1
    for enemy in list(level.enemies):
        if not enemy.is_alive():
            continue
        enemy_turn_on_map(self, level, enemy)
        visible = level.visible[enemy.y][enemy.x]
        tick_effects(enemy, self if visible else self.quiet)
        if not enemy.is_alive():
            enemy.dead = True
            if visible:
                self.say(t('map.bledOut', {'name': enemy.name}))
            # Изкървелият враг извън боя не хвърля плячка: нищо не го е обрало.
            self.enemy_killed(enemy, SimpleNamespace(gold=0, drop=None))
    self.prune_dead()
    compute_fov(level, hero.x, hero.y)
    for enemy in level.enemies:
        if enemy.state == 'chase' and distance(enemy.x, enemy.y, hero.x, hero.y) <= 1:
            self.start_battle(enemy)
            return

Броячът на ходовете, ефектите (кървенето тече всеки ход), бавното възстановяване на всеки трети ход, ходът на всеки враг, враговете, които са изкървели. И краят, точно като гоблина: враг, който гони и е до героя, започва бой. В боя ходовете са по друго правило, по бързина, затова всеки екран сам решава кога е ход, а update на картата само преизчислява какво се вижда.

Упражнение

Гоблинът спи

Реши задачата в редактора си.

Спящият гоблин. Гоблинът в началото спи и се рисува като z. Събужда се, когато героят е на 3 клетки или по-близо. В хода, в който се събуди, не мърда, а после гони както досега и се рисува като g. Цикълът не се променя: трябват ти едно поле в състоянието, един знак в draw и няколко реда в update.

Входът:

d
d
a
a
a
a

Ход 0  z...@......>
> d
Ход 1  z....@.....>
> d
Ход 2  z.....@....>
> a
Ход 3  z....@.....>
> a
Ход 4  z...@......>
> a
Ход 5  g..@.......>
> a
Ход 6  .g@........>
Гоблинът те хвана.

Още задачи

Изчакай. Добави команда s: героят стои, но ходът минава и гоблинът стъпва. Как ще различиш „стой“ от „печатна грешка“ в handle?
Запис на командите. Пази всяка прочетена команда в списък и в края го запиши във файл, по една команда на ред. Пусни програмата пак с този файл като вход: изходът трябва да е същият. Така работи повторението на боя в Арканум.
Два гоблина. Втори гоблин тръгва от клетка 11 и пази изхода. Кой стъпва пръв, когато и двамата са до героя?

Тест

Провери се

1. Защо в коридора draw само чете състоянието и не сменя нищо?Защото иначе програмата не се компилираЗа да може екранът да се рисува наново колкото пъти трябва, без светът да мръднеЗащото печатането е бавно

2. Играчът пише x в коридора. Какво става?Гоблинът стъпва, защото всяка команда е ходПрограмата спира с грешкаИзлиза съобщение, броячът на ходовете и гоблинът не мърдат

3. Защо играта в конзолата е походова?Защото походовите игри са по-лесни за писанеЗащото конзолата дава цял ред чак след Enter и четенето чакаЗащото конзолата рисува само 1 кадър в секунда

4. Играч съобщава: „На ход 412 вълкът ме удари през стената.“ Какво ти трябва, за да видиш същото?Нищо: случайността не може да се повториСнимка на екранаСемето и командите му: със същата версия на играта те дават същото минаване

5. Цикъл в реално време стъпва физиката през 50 ms. От миналия кадър са останали 10 ms, а новият кадър идва след 120 ms. Колко стъпки прави физиката?1, защото кадърът е един2, и остават 30 ms3, защото 120 / 50 се закръгля нагоре

Цикълът на играта

Бисквитки