Предмети, инвентар, плячка в Python

Проблем

Нов меч, без да пипаш кода

В мината героят намира копие. Търговецът продава ризница. Гоблинът пуска отвара. Ако всеки предмет е ред код, new Item("spear", "копие", ...), то всеки нов меч е нова версия на програмата, а балансьорът, който иска да смени цената на ризницата от 90 на 80, чака компилация. Играта има двадесет и два предмета, и ще има още.

Затова данните са отделени от кода. Предметите са таблица в текст: един ред е един предмет, клетките са разделени с |, редовете с # са бележки.

# id|name|kind|price|modifiers
spear|копие|weapon|20|accuracy:5
war_axe|бойна брадва|weapon|80|accuracy:-5
leather|кожена броня|armor|30|defense:2
chain|ризница|armor|90|defense:4,evasion:-5
ring_life|пръстен на живота|ring|70|maxHp:10
ring_agility|пръстен на ловкостта|ring|70|agility:2
potion_heal|отвара за живот|potion|15|-
potion_mana|отвара за мана|potion|15|-
antidote|противоотрова|potion|10|-
ore|сребърна руда|misc|8|-

Урокът е за пет неща около тази таблица: как текстът става обекти; как екипировката (оръжие, броня, пръстен) се събира в показателите; как инвентарът с ограничени места трупа еднаквите отвари; как плячката се хвърля по таблица с тегла; и как магазинът купува и продава за злато. Малката таблица горе има десет предмета; в канона са двадесет и два, но кодът е същият.

Идеята

Таблица в текст, прочетена в обекти

Четецът е три малки функции. parseRows разделя текста на редове, пропуска празните и бележките и разделя клетките по |; ако клетките не са колкото се очакват, спира веднага и казва кой ред е развален. parseMods чете модификаторите (defense:4,evasion:-5, а - значи „няма“). loadItems прави от всеки ред предмет.

@dataclass(frozen=True)
class Mod:
    stat: str
    value: int


class Item:
    def __init__(self, item_id, name, kind, price, mods):
        self.id = item_id
        self.name = name
        self.kind = kind
        self.price = price
        self.mods = mods
        self.stackable = kind == "potion" or kind == "misc"


# Един ред на таблицата е един предмет: id|име|вид|цена|модификатори.
def parse_rows(text, columns):
    rows = []
    for raw in text.split("\n"):
        line = raw.strip()
        if len(line) == 0 or line[0] == "#":
            continue
        cells = line.split("|")
        if len(cells) != columns:
            raise ValueError("очаквани " + str(columns) + " клетки в реда: " + line)
        rows.append(cells)
    return rows


# „-“ значи „няма модификатори“; иначе „показател:стойност“, разделени със запетая.
def parse_mods(text):
    mods = []
    if text == "-":
        return mods
    for part in text.split(","):
        pieces = part.split(":")
        mods.append(Mod(pieces[0], int(pieces[1])))
    return mods


def load_items(text):
    items = {}
    for c in parse_rows(text, 5):
        items[c[0]] = Item(c[0], c[1], c[2], int(c[3]), parse_mods(c[4]))
    return items

items = load_items(ITEMS_TEXT)
for item in items.values():
    print(item.name + " (" + item.kind + ") " + str(item.price) + " злато: " + mods_text(item.mods))
print("общо: " + str(len(items)))
try:
    load_items(BAD_ROW)
except ValueError as e:
    print(e)

копие (weapon) 20 злато: accuracy +5
бойна брадва (weapon) 80 злато: accuracy -5
кожена броня (armor) 30 злато: defense +2
ризница (armor) 90 злато: defense +4, evasion -5
пръстен на живота (ring) 70 злато: maxHp +10
пръстен на ловкостта (ring) 70 злато: agility +2
отвара за живот (potion) 15 злато: -
отвара за мана (potion) 15 злато: -
противоотрова (potion) 10 злато: -
сребърна руда (misc) 8 злато: -
общо: 10
очаквани 5 клетки в реда: ring_life|пръстен на живота|ring|70

Програмата печата предметите по реда на таблицата и накрая подава ред с липсваща клетка (цената): четецът го спира с точното съобщение. Развалена таблица трябва да спира играта при старт, а не посред бой, когато играчът първи стъпи на предмета.

dict пази реда на вмъкване. Таблицата е низ с три кавички, а strip() маха водещия и крайния нов ред.

Ето четецът в канона. Там всяка таблица има свои колони (оръжията са 10 клетки, бронята 7), затова parseRows взема броя им и името на таблицата за съобщението:

def parse_rows(text, columns, table_name):
    rows = []
    for raw_line in text.split('\n'):
        line = trim_spaces(raw_line)
        if len(line) == 0 or line[0] == '#':
            continue
        cells = line.split('|')
        if len(cells) != columns:
            raise RuntimeError(table_name + ': expected ' + str(columns) + ' cells in: ' + line)
        rows.append(cells)
    return rows


def parse_mods(text):
    mods = []
    for part in split_list(text):
        pieces = part.split(':')
        mods.append(SimpleNamespace(stat=pieces[0], value=to_int(pieces[1])))
    return mods

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

Таблиците се различават по колони, затова канонът има по един кратък четец на вид (loadItems чете петте таблици една след друга), но общото е едно: parseRows. Нов вид данни (врагове, умения, диалози) е нова таблица и нов кратък четец, а не нов начин за четене.

Ето и самите данни от играта: имената са на четири езика, после идват цената и модификаторите.

# Данните са таблици в текст: един ред е един запис, клетките са разделени с „|“. Редовете с „#“
# отпред са бележки. Кодът ги чете при старт в обекти; за нов меч не се пипа код, а таблица.
# Модификаторите са „показател:стойност“, разделени със запетая; „-“ значи „нищо“.
WEAPONS_DATA = """
# id|bg|en|de|es|вид щета|мин|макс|цена|модификатори
fists|юмруци|fists|Fäuste|puños|blunt|1|2|0|-
hand_axe|ръчна брадва|hand axe|Handaxt|hacha de mano|slash|4|7|20|-
spear|копие|spear|Speer|lanza|pierce|3|6|20|accuracy:5
staff|тояга|staff|Stab|bastón|blunt|2|4|10|maxMana:4
war_axe|бойна брадва|war axe|Streitaxt|hacha de guerra|slash|6|10|80|accuracy:-5
longbow|дълъг лък|longbow|Langbogen|arco largo|pierce|5|8|80|accuracy:10
mace|боздуган|mace|Streitkolben|maza|blunt|5|8|60|-
rune_staff|рунна тояга|rune staff|Runenstab|bastón rúnico|blunt|3|6|75|maxMana:10
silver_sword|сребърен меч|silver sword|Silberschwert|espada de plata|slash|7|11|120|accuracy:5
"""

ARMORS_DATA = """
# id|bg|en|de|es|цена|модификатори
robe|роба|robe|Robe|túnica|5|maxMana:2
leather|кожена броня|leather armor|Lederrüstung|armadura de cuero|30|defense:2
chain|ризница|chain mail|Kettenhemd|cota de malla|90|defense:4,evasion:-5
scale|люспеста броня|scale armor|Schuppenpanzer|armadura de escamas|110|defense:5
"""

RINGS_DATA = """
# id|bg|en|de|es|цена|модификатори
ring_strength|пръстен на силата|ring of strength|Ring der Stärke|anillo de fuerza|70|strength:2
ring_agility|пръстен на ловкостта|ring of agility|Ring des Geschicks|anillo de destreza|70|agility:2
ring_life|пръстен на живота|ring of life|Ring des Lebens|anillo de vida|70|maxHp:10
ring_mana|пръстен на маната|ring of mana|Ring des Manas|anillo de maná|70|maxMana:8
"""

POTIONS_DATA = """
# id|bg|en|de|es|цена|действие|сила
potion_heal|отвара за живот|healing potion|Heiltrank|poción de vida|15|heal|20
potion_mana|отвара за мана|mana potion|Manatrank|poción de maná|15|mana|15
antidote|противоотрова|antidote|Gegengift|antídoto|10|cure|0
"""

MISC_DATA = """
# id|bg|en|de|es|цена
ore|сребърна руда|silver ore|Silbererz|mineral de plata|8
gold|злато|gold|Gold|oro|0
"""

# Плячката: за всяка таблица редове с тегло. „none“ е „нищо“; бройката е от мин до макс.
LOOT_DATA = """
# таблица|предмет|тегло|мин|макс
vermin|none|60|0|0
vermin|potion_heal|25|1|1
vermin|antidote|15|1|1
goblin|none|40|0|0
goblin|potion_heal|30|1|1
goblin|potion_mana|10|1|1
goblin|spear|10|1|1
goblin|leather|10|1|1
beast|none|70|0|0
beast|potion_heal|30|1|1
leader|ring_agility|100|1|1
bones|none|50|0|0
bones|mace|20|1|1
bones|potion_heal|30|1|1
cult|potion_mana|40|1|1
cult|potion_heal|40|1|1
cult|rune_staff|20|1|1
golem|ore|100|1|2
warden|none|100|0|0
"""

SHOP_DATA = """
# какво продава магазинът, в този ред
potion_heal
potion_mana
antidote
leather
chain
war_axe
longbow
mace
rune_staff
ring_life
ring_mana
"""

# Опитът, нужен за всяко ниво: XP_TABLE[ниво] е общият опит, с който се стига това ниво.
XP_DATA = '0|0|20|55|105|170|250|345|455|580|720'

Идеята

Екипировка: база плюс предметите

Героят има три слота: weapon, armor, ring. В слот стои id на предмет или празен низ. Показателят не се пази готов: той се смята всеки път като база (числото на героя) плюс сумата от модификаторите на всичко сложено. Така свалянето на пръстен не иска „върни старото число“, а просто пак смята.

SLOTS = ["weapon", "armor", "ring"]


class Hero:
    def __init__(self, name, items):
        self.name = name
        self.items = items
        self.base_stats = {}
        self.equipment = {}
        self.hp = 0
        for slot in SLOTS:
            self.equipment[slot] = ""

    # Базата плюс бонусът от всичко, което е сложено.
    def gear_bonus(self, stat):
        total = 0
        for slot in SLOTS:
            item_id = self.equipment[slot]
            if len(item_id) == 0:
                continue
            for mod in self.items[item_id].mods:
                if mod.stat == stat:
                    total += mod.value
        return total

    def stat(self, stat):
        return self.base_stats.get(stat, 0) + self.gear_bonus(stat)

    # Животът не може да е над новия максимум.
    def clamp_hp(self):
        if self.hp > self.stat("maxHp"):
            self.hp = self.stat("maxHp")

    def equip(self, item_id):
        item = self.items[item_id]
        old = self.equipment[item.kind]
        self.equipment[item.kind] = item_id
        self.clamp_hp()
        return old

    def unequip(self, slot):
        self.equipment[slot] = ""
        self.clamp_hp()

equip поставя предмета в слота на неговия вид (item.kind) и връща стария, за да може да се върне в торбата. Има един неочакван момент: ако пръстенът даваше +10 най-много живот и го свалиш, текущият живот може да остане над новия максимум. clampHp го връща надолу.

items = load_items(ITEMS_TEXT)
hero = Hero("Ива", items)
hero.base_stats["maxHp"] = 30
hero.base_stats["defense"] = 1
hero.base_stats["accuracy"] = 70
hero.hp = hero.stat("maxHp")
print(hero.name + ": " + stats(hero))

for item_id in ["spear", "leather", "ring_life"]:
    hero.equip(item_id)
    print("+ " + items[item_id].name + ": " + stats(hero))
hero.hp = hero.stat("maxHp")
print("лекуване: " + stats(hero))

hero.equip("war_axe")
print("+ " + items["war_axe"].name + ": " + stats(hero))
hero.unequip("ring")
print("- " + items["ring_life"].name + ": " + stats(hero))

Ива: hp 30/30, defense 1, accuracy 70
+ копие: hp 30/30, defense 1, accuracy 75
+ кожена броня: hp 30/30, defense 3, accuracy 75
+ пръстен на живота: hp 30/40, defense 3, accuracy 75
лекуване: hp 40/40, defense 3, accuracy 75
+ бойна брадва: hp 40/40, defense 3, accuracy 65
- пръстен на живота: hp 30/30, defense 3, accuracy 65

Редовете следват героя: копието добавя 5 към точността, кожената броня 2 към защитата, пръстенът 10 към най-много живот (но текущият живот още е 30/40: максимумът расте, а животът не). След лекуването бойната брадва заема мястото на копието и точността пада от 75 на 65 (−5 вместо +5). А свалянето на пръстена връща най-много живот на 30, и clampHp сваля и текущия до 30.

Идеята

Инвентар: места и купчини

Торбата има ограничен брой места (в играта 10). Предметът заема място. Но десет отвари за живот не са десет места: еднаквите отвари и рудата се трупат на едно. В таблицата това са видовете potion и misc (stackable). Оръжията и бронята не се трупат: два меча са две места.

class Inventory:
    def __init__(self, capacity, items):
        self.capacity = capacity
        self.items = items
        self.slots = []

    def count(self, item_id):
        total = 0
        for slot in self.slots:
            if slot.id == item_id:
                total += slot.count
        return total

    def can_add(self, item_id, count):
        item = self.items[item_id]
        if item.stackable and self.count(item_id) > 0:
            return True
        needed = 1 if item.stackable else count
        return len(self.slots) + needed <= self.capacity

    def add(self, item_id, count):
        if not self.can_add(item_id, count):
            return False
        item = self.items[item_id]
        if item.stackable:
            for slot in self.slots:
                if slot.id == item_id:
                    slot.count += count
                    return True
            self.slots.append(Slot(item_id, count))
            return True
        for _ in range(count):
            self.slots.append(Slot(item_id, 1))
        return True

    def remove(self, item_id, count):
        left = count
        kept = []
        for slot in self.slots:
            if slot.id == item_id and left > 0:
                taken = min(left, slot.count)
                slot.count -= taken
                left -= taken
            if slot.count > 0:
                kept.append(slot)
        self.slots = kept

    def remove_at(self, index):
        slot = self.slots[index]
        slot.count -= 1
        if slot.count <= 0:
            del self.slots[index]

Всичко се решава в canAdd: ако предметът се трупа и вече има такъв, място не трябва; иначе трябват толкова нови места, колкото са нужни. add пита canAdd първо и ако не става, не прави нищо (не слага половин купчина). Резултатът е true или false, и така извикващият знае дали да каже „няма място“.

def label(name, count):
    return name + " x" + str(count) if count > 1 else name


def fill_text(bag):
    return "(" + str(len(bag.slots)) + "/" + str(bag.capacity) + ")"


def print_bag(bag):
    print("Торбата:")
    for i in range(len(bag.slots)):
        slot = bag.slots[i]
        print(str(i + 1) + ") " + label(bag.items[slot.id].name, slot.count))


def add_and_show(bag, item_id, count):
    added = bag.add(item_id, count)
    print("+ " + label(bag.items[item_id].name, count) + ": " + ("готово" if added else "няма място") + " " + fill_text(bag))

items = load_items(ITEMS_TEXT)
bag = Inventory(4, items)
add_and_show(bag, "potion_heal", 2)
add_and_show(bag, "spear", 1)
add_and_show(bag, "potion_heal", 1)
add_and_show(bag, "potion_mana", 1)
add_and_show(bag, "leather", 1)
add_and_show(bag, "chain", 1)
add_and_show(bag, "potion_heal", 1)
add_and_show(bag, "ore", 1)
print_bag(bag)

bag.remove("potion_heal", 3)
print("- " + label(items["potion_heal"].name, 3) + ": " + fill_text(bag))
bag.remove("spear", 1)
print("- " + items["spear"].name + ": " + fill_text(bag))
add_and_show(bag, "chain", 1)
print_bag(bag)

+ отвара за живот x2: готово (1/4)
+ копие: готово (2/4)
+ отвара за живот: готово (2/4)
+ отвара за мана: готово (3/4)
+ кожена броня: готово (4/4)
+ ризница: няма място (4/4)
+ отвара за живот: готово (4/4)
+ сребърна руда: няма място (4/4)
Торбата:
1) отвара за живот x4
2) копие
3) отвара за мана
4) кожена броня
- отвара за живот x3: (4/4)
- копие: (3/4)
+ ризница: готово (4/4)
Торбата:
1) отвара за живот
2) отвара за мана
3) кожена броня
4) ризница

Ризницата не влиза при пълна торба (4 от 4), а още една отвара за живот влиза: купчината е вече започната. Рудата няма къде. След това remove маха три отвари от купчината и копието, и ризницата влиза на освободеното място. removeAt(i) маха един предмет от място (магазинът го ползва за продажба) и освобождава мястото, когато бройката падне на нула.

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

Купчината пази id и count, а не самия предмет. Определението на предмета (име, цена, модификатори) е едно на целия свят, в таблицата; в торбата стоят само препратки с бройки. Двадесет копия на копието не копират двадесет пъти цената.

Идеята

Плячка с тегла

Какво пуска гоблинът? Не винаги едно и също, а и не с еднакъв шанс: често нищо, понякога отвара, рядко копие. За това всеки враг има таблица с плячка: редове с тегло. Теглото е относително: ред с тегло 30 в таблица с общо 100 пада в 30% от случаите. Редът none значи „нищо“, а бройката е случайна между мин и макс.

# table|item|weight|min|max
goblin|none|40|0|0
goblin|potion_heal|30|1|1
goblin|potion_mana|10|1|1
goblin|spear|10|1|1
goblin|leather|10|1|1
golem|ore|100|1|2

Хвърлянето е кратко. Теглата се събират (общо 100), хвърля се число от 0 до 99, после редовете се минават по ред и от числото се изважда теглото на всеки, докато числото стане по-малко от теглото на текущия ред. Този ред пада. Така широчината на реда е точно шансът му и не трябва нито подредба по тегла, нито проценти, които се събират до 100.

@dataclass(frozen=True)
class Entry:
    item_id: str
    weight: int
    min: int
    max: int


@dataclass(frozen=True)
class Drop:
    id: str
    count: int


def load_loot(text):
    tables = {}
    for c in parse_rows(text, 5):
        if c[0] not in tables:
            tables[c[0]] = []
        tables[c[0]].append(Entry(c[1], int(c[2]), int(c[3]), int(c[4])))
    return tables


def total_weight(entries):
    total = 0
    for entry in entries:
        total += entry.weight
    return total


# Хвърля се число от 0 до общото тегло минус 1; теглата се изваждат едно по едно, докато числото падне в ред.
def roll_loot(rng, entries):
    roll = rng.next_int(total_weight(entries))
    for entry in entries:
        if roll < entry.weight:
            if entry.item_id == "none":
                return None
            return Drop(entry.item_id, rng.range(entry.min, entry.max))
        roll -= entry.weight
    return None

# Хвърля се число от 0 до общото тегло минус 1; теглата се изваждат едно по едно, докато числото падне в ред.
def roll_loot(rng, entries):
    roll = rng.next_int(total_weight(entries))
    for entry in entries:
        if roll < entry.weight:
            if entry.item_id == "none":
                return None
            return Drop(entry.item_id, rng.range(entry.min, entry.max))
        roll  entry.weight
    return None

Програмата убива шест врага със семе 6 и пуска плячката направо в торба с 3 места. Генераторът е Random от канона (същият mulberry32 като в боя), затова изходът е един и същ на четирите езика:

items = load_items(ITEMS_TEXT)
tables = load_loot(LOOT_TEXT)
rng = Random(6)
bag = Inventory(3, items)
for i in range(len(KILLS)):
    drop = roll_loot(rng, tables[KILLS[i]])
    head = "враг " + str(i + 1) + " (" + KILLS[i] + "): "
    if drop is None:
        print(head + "нищо")
        continue
    added = bag.add(drop.id, drop.count)
    print(head + label(items[drop.id].name, drop.count) + " -> " + ("готово" if added else "няма място") + " " + fill_text(bag))
print_bag(bag)

враг 1 (goblin): нищо
враг 2 (goblin): отвара за живот -> готово (1/3)
враг 3 (goblin): копие -> готово (2/3)
враг 4 (golem): сребърна руда x2 -> готово (3/3)
враг 5 (goblin): отвара за мана -> няма място (3/3)
враг 6 (goblin): отвара за живот -> готово (3/3)
Торбата:
1) отвара за живот x2
2) копие
3) сребърна руда x2

Първият гоблин не пуска нищо. Вторият пуска отвара, третият копие, големът руда по две (торбата вече е пълна, 3 от 3). Петият гоблин пуска отвара за мана, но няма място за нова купчина: в играта тя би останала на пода, а тук просто не влиза. Шестият пуска отвара за живот: вече има такава в торбата и тя се трупа, макар торбата да е пълна.

Случайното е само числото; теглата определят колко често. Да проверим: същата таблица, но 1000 убити гоблина, и се брои кой ред колко пъти е паднал.

entries = load_loot(LOOT_TEXT)["goblin"]
rng = Random(2026)
counts = {}
for i in range(1000):
    drop = roll_loot(rng, entries)
    key = "none" if drop is None else drop.id
    counts[key] = counts.get(key, 0) + 1
total = total_weight(entries)
for entry in entries:
    print(entry.item_id + ": " + str(counts.get(entry.item_id, 0)) + " (очаквани " + str(entry.weight * 1000 // total) + ")")

none: 396 (очаквани 400)
potion_heal: 300 (очаквани 300)
potion_mana: 117 (очаквани 100)
spear: 91 (очаквани 100)
leather: 96 (очаквани 100)

Очакваните бройки са теглата × 10, и получените са близо до тях, но рядко са точно равни. Това е вероятност, а не разпределение по график. При по-малко убити врагове разликата е по-голяма (шест врага са твърде малко за каквото и да е), затова един добър баланс се проверява с хиляди убити врагове: последният урок прави точно това с цялата игра.

Виж го

Хвърлянето в действие

Ето същите шест убити врагове по ходове. Лентата е таблицата: колкото по-широк е редът, толкова по-често пада. Показалецът отива на хвърленото число, изваждането на теглата се вижда отдолу, а предметът излиза от своя ред и влиза в торбата: на ново място, на старото място (трупа се) или не влиза, ако торбата е пълна.

# Хвърля се число от 0 до общото тегло минус 1; теглата се изваждат едно по едно, докато числото падне в ред.
def roll_loot(rng, entries):
    roll = rng.next_int(total_weight(entries))
    for entry in entries:
        if roll < entry.weight:
            if entry.item_id == "none":
                return None
            return Drop(entry.item_id, rng.range(entry.min, entry.max))
        roll -= entry.weight
    return None


def can_add(self, item_id, count):
    item = self.items[item_id]
    if item.stackable and self.count(item_id) > 0:
        return True
    needed = 1 if item.stackable else count
    return len(self.slots) + needed <= self.capacity


def add(self, item_id, count):
    if not self.can_add(item_id, count):
        return False
    item = self.items[item_id]
    if item.stackable:
        for slot in self.slots:
            if slot.id == item_id:
                slot.count += count
                return True
        self.slots.append(Slot(item_id, count))
        return True
    for _ in range(count):
        self.slots.append(Slot(item_id, 1))
    return True

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

Таблицата на гоблина е текст: 5 реда, всеки с тегло, общо 100. Теглото е ширината на реда в лентата: тегло 30 от 100 са 30% шанс. Торбата има 3 места.
Враг 1 (goblin): хвърля се число от 0 до 99 и се получава 1. Теглата се изваждат едно по едно: 1 < 40. Числото пада в реда „нищо“ (тегло 40 от 100).
„нищо“ е ред като всеки друг (тегло 40): плячка няма и торбата не се пипа.
Враг 2 (goblin): хвърля се число от 0 до 99 и се получава 56. Теглата се изваждат едно по едно: 56 ≥ 40 → 16 → 16 < 30. Числото пада в реда „отвара за живот“ (тегло 30 от 100).
Отвара за живот отива в торбата на ново място (1/3).
Враг 3 (goblin): хвърля се число от 0 до 99 и се получава 89. Теглата се изваждат едно по едно: 89 ≥ 40 → 49 → 49 ≥ 30 → 19 → 19 ≥ 10 → 9 → 9 < 10. Числото пада в реда „копие“ (тегло 10 от 100).
Копие отива в торбата на ново място (2/3).
Враг 4 (golem): хвърля се число от 0 до 99 и се получава 1. Теглата се изваждат едно по едно: 1 < 100. Числото пада в реда „сребърна руда“ (тегло 100 от 100).
Сребърна руда x2 отива в торбата на ново място (3/3).
Враг 5 (goblin): хвърля се число от 0 до 99 и се получава 76. Теглата се изваждат едно по едно: 76 ≥ 40 → 36 → 36 ≥ 30 → 6 → 6 < 10. Числото пада в реда „отвара за мана“ (тегло 10 от 100).
Торбата е пълна (3/3), а отвара за мана няма с какво да се трупа: canAdd връща false и add не прави нищо (в играта предметът остава на пода).
Враг 6 (goblin): хвърля се число от 0 до 99 и се получава 56. Теглата се изваждат едно по едно: 56 ≥ 40 → 16 → 16 < 30. Числото пада в реда „отвара за живот“ (тегло 30 от 100).
Отвара за живот вече има в торбата, затова се трупа на същото място (отвара за живот x2); заетите места остават 3/3.
След 6 убити врагове торбата е пълна. Случайно е само числото; теглата казват колко често пада всеки ред, а торбата решава какво се побира.

Кодът до сцената е rollLoot, canAdd и add от програмата. На всяка стъпка светят редовете, които работят в този момент.

Идеята

Магазин: купуване и продаване

Магазинът е най-късото от петте неща, защото всичко за него е вече построено. Купуването е три проверки по ред: стига ли златото, има ли място в торбата, после се плаща и предметът се добавя. Продаването маха едно от мястото и дава половината от цената, закръглена надолу.

# Продажбата дава половината от цената, закръглена надолу.
def sell_price(item):
    return item.price // 2


def buy(player, items, item_id):
    item = items[item_id]
    result = "готово"
    if player.gold < item.price:
        result = "не стига златото"
    elif not player.bag.can_add(item_id, 1):
        result = "няма място"
    else:
        player.gold -= item.price
        player.bag.add(item_id, 1)
    return "купува " + item.name + " (" + str(item.price) + "): " + result + ", злато " + str(player.gold)


def sell(player, items, slot_number):
    slot = player.bag.slots[slot_number - 1]
    item = items[slot.id]
    price = sell_price(item)
    player.bag.remove_at(slot_number - 1)
    player.gold += price
    return "продава " + item.name + " (" + str(price) + "): готово, злато " + str(player.gold)

items = load_items(ITEMS_TEXT)
player = Player(100, Inventory(3, items))
print(buy(player, items, "potion_heal"))
print(buy(player, items, "potion_heal"))
print(buy(player, items, "chain"))
print(buy(player, items, "leather"))
print(buy(player, items, "war_axe"))
print(sell(player, items, 2))
print(buy(player, items, "potion_mana"))
print(buy(player, items, "antidote"))
print(buy(player, items, "leather"))
print(sell(player, items, 1))

купува отвара за живот (15): готово, злато 85
купува отвара за живот (15): готово, злато 70
купува ризница (90): не стига златото, злато 70
купува кожена броня (30): готово, злато 40
купува бойна брадва (80): не стига златото, злато 40
продава кожена броня (15): готово, злато 55
купува отвара за мана (15): готово, злато 40
купува противоотрова (10): готово, злато 30
купува кожена броня (30): няма място, злато 30
продава отвара за живот (7): готово, злато 37

Редът на проверките е важен. Ризницата за 90 не се купува със 70 злато, нито бойната брадва за 80 с 40. На деветия ред героят има злато за кожена броня (30), но торбата е пълна: проверката за злато минава, canAdd отказва и златото не се взима. Продажбата на кожената броня дава 15 (30 / 2), а на отвара за живот 7 (15 / 2, закръглено надолу): купуване и веднага продаване никога не е печалба.

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

def sell_price(item):
    return item.price // 2

Идеята

В играта

Това, което построихме, е същото като в канона, само по-малко. Ето истинския инвентар:

# Инвентарът има ограничен брой места. Еднаквите отвари и рудата се трупат на едно място.
class Inventory:
    def __init__(self, capacity):
        self.capacity = capacity
        self.slots = []

    def count(self, item_id):
        total = 0
        for slot in self.slots:
            if slot.id == item_id:
                total += slot.count
        return total

    def can_add(self, item_id, count):
        item = ITEMS[item_id]
        if item.stackable and self.count(item_id) > 0:
            return True
        needed = 1 if item.stackable else count
        return len(self.slots) + needed <= self.capacity

    def add(self, item_id, count):
        if not self.can_add(item_id, count):
            return False
        item = ITEMS[item_id]
        if item.stackable:
            for slot in self.slots:
                if slot.id == item_id:
                    slot.count += count
                    return True
            self.slots.append(SimpleNamespace(id=item_id, count=count))
            return True
        for i in range(count):
            self.slots.append(SimpleNamespace(id=item_id, count=1))
        return True

    def remove(self, item_id, count):
        left = count
        kept = []
        for slot in self.slots:
            if slot.id == item_id and left > 0:
                taken = min(left, slot.count)
                slot.count -= taken
                left -= taken
            if slot.count > 0:
                kept.append(slot)
        self.slots = kept

    def remove_at(self, index):
        slot = self.slots[index]
        slot.count -= 1
        if slot.count <= 0:
            del self.slots[index]

Екипировката в канона е част от Creature: gearBonus събира модификаторите по слотовете и се вмъква между базата и ефектите (виж урока за героите и враговете):

def gear_bonus(self, stat):
    total = 0
    for slot in self.equipment.keys():
        item_id = self.equipment[slot]
        if item_id == '':
            continue
        for mod in ITEMS[item_id].mods:
            if mod.stat == stat:
                total += mod.value
    return total

def weapon(self):
    weapon_id = self.equipment['weapon']
    return ITEMS['fists' if weapon_id == '' else weapon_id]

Слагането на предмет от торбата сменя старото със новото на същото място, за да не се разбърква редът на предметите:

# Слага предмета от инвентара; старият заема неговото място в инвентара.
def equip_from_inventory(hero, index):
    slot = hero.inventory.slots[index]
    item = ITEMS[slot.id]
    if item.kind != 'weapon' and item.kind != 'armor' and item.kind != 'ring':
        return ''
    old = hero.equipment[item.kind]
    hero.inventory.remove_at(index)
    hero.equipment[item.kind] = item.id
    if old != '':
        hero.inventory.slots.insert(index, SimpleNamespace(id=old, count=1))
    if hero.hp > hero.max_hp():
        hero.hp = hero.max_hp()
    if hero.mana > hero.max_mana():
        hero.mana = hero.max_mana()
    return item.id

И хвърлянето на плячка, което познаваш:

# Плячка с тегла: тегло 30 от общо 100 значи 30% шанс.
def roll_loot(rng, table_id):
    entries = LOOT_TABLES[table_id]
    total = 0
    for entry in entries:
        total += entry.weight
    roll = rng.next_int(total)
    for entry in entries:
        if roll < entry.weight:
            if entry.item_id == 'none':
                return None
            return SimpleNamespace(id=entry.item_id, count=rng.range(entry.min, entry.max))
        roll -= entry.weight
    return None

Разликите от нашата програма:

Една таблица по вид. Оръжията, бронята, пръстените, отварите и другото са всеки със свои колони; нашата таблица е една, за да се чете лесно.
Имена на четири езика. Всеки ред в канона носи името на bg, en, de и es; nm(item) избира по езика на играта. Тук името е една клетка.
Глобален ITEMS. Канонът пази предметите в един глобален речник и ги търси по id. Ние ги подаваме на Inventory и Hero, за да се виждат зависимостите и да се тества лесно.
Торба с 10 места. Героят в канона има Inventory(10); тук местата са 3 и 4, за да се вижда кога се пълнят.
Злато и отвари. Златото не е предмет в торбата, а число при героя (враговете пускат злато отделно от плячката). Отварите имат действие (heal, mana, cure) и drinkPotion ги пие в боя и на картата; тук ги само трупаме.
Плячката пада на земята. Убитият враг оставя предмета на пода (dropItem), а героят го вдига с g; при пълна торба предметът остава на пода и играчът вижда „торбата е пълна“. В нашата програма плячката влиза направо в торбата, а пълна торба връща false.

Пробвай

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

Три реда с тегла 50, 30 и 20 и шест хвърлени числа. Какво печата програмата?

def pick(ids, weights, roll):
    for i in range(len(ids)):
        if roll < weights[i]:
            return ids[i]
        roll -= weights[i]
    return ids[len(ids) - 1]


ids = ["none", "potion_heal", "spear"]
weights = [50, 30, 20]
rolls = [0, 49, 50, 79, 80, 99]
for roll in rolls:
    print(str(roll) + ": " + pick(ids, weights, roll))

Отговор

0: none
49: none
50: potion_heal
79: potion_heal
80: spear
99: spear

0: none
49: none
50: none
79: potion_heal
80: potion_heal
99: spear

0: none
49: potion_heal
50: potion_heal
79: spear
80: spear
99: spear

Пробвай

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

Колега пренаписа проверката в canAdd, и сега торбата с 2 места събира три предмета, а отвара не влиза в пълна торба:

items = load_items(ITEMS_TEXT)
bag = Inventory(2, items)
add_and_show(bag, "spear", 1)
add_and_show(bag, "potion_heal", 1)
add_and_show(bag, "potion_mana", 1)
add_and_show(bag, "potion_heal", 1)

+ копие: готово (1/2)
+ отвара за живот: готово (2/2)
+ отвара за мана: готово (3/2)
+ отвара за живот: няма място (3/2)

Кой ред е развален?

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

По-точно

По-точно: вероятности, дялове и слабите места

Тегла, не проценти. Теглата не трябва да се събират до 100. Таблица 3, 1, 1 е същото като 60, 20, 20. Сборът е делителят и се смята наново при всяко хвърляне, затова нов ред се добавя, без да се пипа останалото. Процентите би трябвало да се събират до 100 след всяка промяна, а теглата не.

Изваждане или събиране. Може да се хвърли число и да се сравнява със суми (40, 70, 80, 90, 100): ред i пада, когато числото е под i-тата сума. Изваждането е същото без втори масив. За големи таблици сборовете се пазят наготово и се търси двоично; за тези от игрите е излишно.

„Нищо“ е ред. none с тегло 40 е ред като всеки друг: с едно число таблицата дава 0% или 90% „нищо“. А таблицата на водача (leader) в канона има само един ред с тегло 100: пръстенът пада винаги.

Всичко или нищо. Всяка промяна на торбата минава през add, който първо пита canAdd. Така „половин купчина“ или „три предмета в две места“ не може да се случи. Упражнението по-долу защитава именно това.

Закръгляне. цена / 2 с цяло деление отрязва остатъка, затова продажбата никога не дава повече от половината. В Python и JavaScript цялото деление е // и Math.floor; те работят правилно, защото цените не са отрицателни.

Случайност и повторяемост. Хвърлянето не знае колко ще падне; знае само как да отговори на числото. Генераторът е със семе (mulberry32), затова със същото семе и същите убийства плячката е същата на четирите езика и при записано минаване. Това ще ни трябва и за записа, и за симулацията.

Упражнение

Купчини с горна граница

Реши задачата в редактора си. Тръгни от програмата за инвентара.

В играта десет отвари на едно място са прекалено много. Добави горна граница на купчината: най-много 5 от един предмет на място. Какво се променя:

купчина, която стигне 5, е пълна; още от същото отива на ново място;
add трябва да е всичко или нищо: ако всички не се побират (в стари купчини и в нови места), не се слага нищо;
не-трупащите предмети са на място по един, както досега.

Нужни са room (колко още влиза в стари купчини), поправено canAdd и add, който първо допълва старите купчини, а после прави нови. Торбата е с 3 места, а сценарият е този:

def add_and_show(bag, item_id, count):
    added = bag.add(item_id, count)
    parts = []
    for slot in bag.slots:
        parts.append(label(bag.items[slot.id].name, slot.count))
    print("+ " + label(bag.items[item_id].name, count) + ": " + ("готово" if added else "няма място") + " " + fill_text(bag) + " [" + ", ".join(parts) + "]")


items = load_items(ITEMS_TEXT)
bag = Inventory(3, items)
add_and_show(bag, "potion_heal", 4)
add_and_show(bag, "potion_heal", 3)
add_and_show(bag, "potion_mana", 2)
add_and_show(bag, "potion_heal", 3)
add_and_show(bag, "potion_heal", 1)
add_and_show(bag, "potion_mana", 4)

Изходът е:

+ отвара за живот x4: готово (1/3) [отвара за живот x4]
+ отвара за живот x3: готово (2/3) [отвара за живот x5, отвара за живот x2]
+ отвара за мана x2: готово (3/3) [отвара за живот x5, отвара за живот x2, отвара за мана x2]
+ отвара за живот x3: готово (3/3) [отвара за живот x5, отвара за живот x5, отвара за мана x2]
+ отвара за живот: няма място (3/3) [отвара за живот x5, отвара за живот x5, отвара за мана x2]
+ отвара за мана x4: няма място (3/3) [отвара за живот x5, отвара за живот x5, отвара за мана x2]

Редовете показват и границите: втората стъпка допълва старата купчина до 5 и отваря ново място за останалите 2; четвъртата допълва вече започнатата купчина и не иска ново място; последната (още 4 отвари за мана при купчина от 2) не слага нищо, макар 3 от тях да влизат, защото четвъртата няма къде.

Още задачи

Продай боклука. Добави sellJunk(player, items): продава всичко от вид misc и връща колко злато е получено.
Най-доброто оръжие. Когато героят вземе оръжие, да го сложи само ако сборът на модификаторите му е по-голям от сбора на сложеното сега.
Късмет. Дай на rollLoot параметър luck: колкото е по-голям, с толкова се намалява теглото на реда none (но не под 0), а другите остават. Какво става с шансовете на останалите?

Тест

Провери се

1. Защо предметите на играта са таблица в текст, а не new Item(...) в кода?Нов предмет или промяна на цена е един ред в таблицата: кодът не се пипа, а балансът се настройва, без да се пренаписва логикаТекстът се чете по-бързо от обектитеТака предметите не могат да се променят по време на играта

Данните и правилата са различни неща. Правилата (как се слага предмет, как се трупа) са код и се пишат веднъж; предметите са данни и са много, и се менят често. Таблицата в текст ги държи на едно място, а ги чете един четец (parseRows).

2. Героят е с 40 живот и пръстен на живота (+10 най-много живот). Животът му е пълен: 40/40. Сваля пръстена. Колко живот има след това?30/30: най-много животът е пак 30, а clampHp сваля текущия до него40/30: животът остава, а най-много пада40/40: свалянето не пипа живота

3. Торбата има 4 места и всичките са заети. В нея има отвара за живот. Може ли да се добави още една такава отвара?Не: няма свободно мястоСамо ако предметът е оръжиеДа: еднаквите отвари се трупат на едно място, а canAdd пита първо за вече започната купчина

canAdd първо проверява stackable и дали такъв предмет вече е в торбата: тогава броят расте на същото място и свободно място не трябва. Без тази проверка пълната торба би отказвала отвари, които биха се побрали.

4. Таблицата на гоблина е: нищо 40, отвара за живот 30, отвара за мана 10, копие 10, кожена броня 10. Хвърлено е 85. Кой предмет пада?копиекожена броняотвара за мана

5. отвара за живот струва 15. За колко я продава героят в магазина?8: половината, закръглена нагоре15: магазинът изкупува на същата цена7: половината от цената, закръглена надолу

Продажбата дава цена / 2 с цяло деление, т.е. 15 / 2 = 7. Така купуване и веднага продаване винаги губи злато и играчът не може да печели, като върти един и същ предмет.

6. При 1000 убити гоблина програмата брои 396 пъти „нищо“, а не точно 400. Защо?Теглата са вероятности, а не точни бройки: всяко хвърляне е независимо, затова броят се колебае около очакванияГенераторът е счупен и пропуска числаПървите хвърляния се губят

Предмети, инвентар, плячка

Бисквитки