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

Проблем

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

В мината героят намира копие. Търговецът продава ризница. Гоблинът пуска отвара. Ако всеки предмет е ред код, 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 прави от всеки ред предмет.

class Item {
  constructor(id, name, kind, price, mods) {
    this.id = id;
    this.name = name;
    this.kind = kind;
    this.price = price;
    this.mods = mods;
    this.stackable = kind === "potion" || kind === "misc";
  }
}

// Един ред на таблицата е един предмет: id|име|вид|цена|модификатори.
function parseRows(text, columns) {
  const rows = [];
  for (const raw of text.split("\n")) {
    const line = raw.trim();
    if (line.length === 0 || line[0] === "#") continue;
    const cells = line.split("|");
    if (cells.length !== columns) {
      throw new Error("очаквани " + columns + " клетки в реда: " + line);
    }
    rows.push(cells);
  }
  return rows;
}

// „-“ значи „няма модификатори“; иначе „показател:стойност“, разделени със запетая.
function parseMods(text) {
  const mods = [];
  if (text === "-") return mods;
  for (const part of text.split(",")) {
    const pieces = part.split(":");
    mods.push({ stat: pieces[0], value: parseInt(pieces[1], 10) });
  }
  return mods;
}

function loadItems(text) {
  const items = new Map();
  for (const c of parseRows(text, 5)) {
    items.set(c[0], new Item(c[0], c[1], c[2], parseInt(c[3], 10), parseMods(c[4])));
  }
  return items;
}

const items = loadItems(ITEMS_TEXT);
for (const item of items.values()) {
  console.log(item.name + " (" + item.kind + ") " + item.price + " злато: " + modsText(item.mods));
}
console.log("общо: " + items.size);
try {
  loadItems(BAD_ROW);
} catch (e) {
  console.log(e.message);
}

копие (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

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

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

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

function parseRows(text, columns, tableName) {
  const rows = [];
  for (const rawLine of text.split('\n')) {
    const line = trimSpaces(rawLine);
    if (line.length === 0 || line.charAt(0) === '#') continue;
    const cells = line.split('|');
    if (cells.length !== columns) {
      throw new Error(tableName + ': expected ' + columns + ' cells in: ' + line);
    }
    rows.push(cells);
  }
  return rows;
}

function parseMods(text) {
  const mods = [];
  for (const part of splitList(text)) {
    const pieces = part.split(':');
    mods.push({ stat: pieces[0], value: toInt(pieces[1]) });
  }
  return mods;
}

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

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

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

// Данните са таблици в текст: един ред е един запис, клетките са разделени с „|“. Редовете с „#“
// отпред са бележки. Кодът ги чете при старт в обекти; за нов меч не се пипа код, а таблица.
// Модификаторите са „показател:стойност“, разделени със запетая; „-“ значи „нищо“.
const 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
`;

const 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
`;

const 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
`;

const 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
`;

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

// Плячката: за всяка таблица редове с тегло. „none“ е „нищо“; бройката е от мин до макс.
const 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
`;

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

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

Идеята

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

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

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

class Hero {
  constructor(name, items) {
    this.name = name;
    this.items = items;
    this.baseStats = new Map();
    this.equipment = new Map();
    this.hp = 0;
    for (const slot of SLOTS) this.equipment.set(slot, "");
  }

  // Базата плюс бонусът от всичко, което е сложено.
  gearBonus(stat) {
    let total = 0;
    for (const slot of SLOTS) {
      const itemId = this.equipment.get(slot);
      if (itemId.length === 0) continue;
      for (const mod of this.items.get(itemId).mods) {
        if (mod.stat === stat) total += mod.value;
      }
    }
    return total;
  }

  stat(stat) {
    return (this.baseStats.get(stat) ?? 0) + this.gearBonus(stat);
  }

  // Животът не може да е над новия максимум.
  clampHp() {
    if (this.hp > this.stat("maxHp")) this.hp = this.stat("maxHp");
  }

  equip(itemId) {
    const item = this.items.get(itemId);
    const old = this.equipment.get(item.kind);
    this.equipment.set(item.kind, itemId);
    this.clampHp();
    return old;
  }

  unequip(slot) {
    this.equipment.set(slot, "");
    this.clampHp();
  }
}

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

const items = loadItems(ITEMS_TEXT);
const hero = new Hero("Ива", items);
hero.baseStats.set("maxHp", 30);
hero.baseStats.set("defense", 1);
hero.baseStats.set("accuracy", 70);
hero.hp = hero.stat("maxHp");
console.log(hero.name + ": " + stats(hero));

for (const itemId of ["spear", "leather", "ring_life"]) {
  hero.equip(itemId);
  console.log("+ " + items.get(itemId).name + ": " + stats(hero));
}
hero.hp = hero.stat("maxHp");
console.log("лекуване: " + stats(hero));

hero.equip("war_axe");
console.log("+ " + items.get("war_axe").name + ": " + stats(hero));
hero.unequip("ring");
console.log("- " + items.get("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 {
  constructor(capacity, items) {
    this.capacity = capacity;
    this.items = items;
    this.slots = [];
  }

  count(itemId) {
    let total = 0;
    for (const slot of this.slots) {
      if (slot.id === itemId) total += slot.count;
    }
    return total;
  }

  canAdd(itemId, count) {
    const item = this.items.get(itemId);
    if (item.stackable && this.count(itemId) > 0) return true;
    const needed = item.stackable ? 1 : count;
    return this.slots.length + needed <= this.capacity;
  }

  add(itemId, count) {
    if (!this.canAdd(itemId, count)) return false;
    const item = this.items.get(itemId);
    if (item.stackable) {
      for (const slot of this.slots) {
        if (slot.id === itemId) {
          slot.count += count;
          return true;
        }
      }
      this.slots.push(new Slot(itemId, count));
      return true;
    }
    for (let i = 0; i < count; i++) this.slots.push(new Slot(itemId, 1));
    return true;
  }

  remove(itemId, count) {
    let left = count;
    const kept = [];
    for (const slot of this.slots) {
      if (slot.id === itemId && left > 0) {
        const taken = Math.min(left, slot.count);
        slot.count -= taken;
        left -= taken;
      }
      if (slot.count > 0) kept.push(slot);
    }
    this.slots = kept;
  }

  removeAt(index) {
    const slot = this.slots[index];
    slot.count -= 1;
    if (slot.count <= 0) this.slots.splice(index, 1);
  }
}

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

function label(name, count) {
  return count > 1 ? name + " x" + count : name;
}

function fillText(bag) {
  return "(" + bag.slots.length + "/" + bag.capacity + ")";
}

function printBag(bag) {
  console.log("Торбата:");
  for (let i = 0; i < bag.slots.length; i++) {
    const slot = bag.slots[i];
    console.log((i + 1) + ") " + label(bag.items.get(slot.id).name, slot.count));
  }
}

function addAndShow(bag, itemId, count) {
  const added = bag.add(itemId, count);
  console.log("+ " + label(bag.items.get(itemId).name, count) + ": " + (added ? "готово" : "няма място") + " " + fillText(bag));
}

const items = loadItems(ITEMS_TEXT);
const bag = new Inventory(4, items);
addAndShow(bag, "potion_heal", 2);
addAndShow(bag, "spear", 1);
addAndShow(bag, "potion_heal", 1);
addAndShow(bag, "potion_mana", 1);
addAndShow(bag, "leather", 1);
addAndShow(bag, "chain", 1);
addAndShow(bag, "potion_heal", 1);
addAndShow(bag, "ore", 1);
printBag(bag);

bag.remove("potion_heal", 3);
console.log("- " + label(items.get("potion_heal").name, 3) + ": " + fillText(bag));
bag.remove("spear", 1);
console.log("- " + items.get("spear").name + ": " + fillText(bag));
addAndShow(bag, "chain", 1);
printBag(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.

function loadLoot(text) {
  const tables = new Map();
  for (const c of parseRows(text, 5)) {
    if (!tables.has(c[0])) tables.set(c[0], []);
    tables.get(c[0]).push({ itemId: c[1], weight: parseInt(c[2], 10), min: parseInt(c[3], 10), max: parseInt(c[4], 10) });
  }
  return tables;
}

function totalWeight(entries) {
  let total = 0;
  for (const entry of entries) total += entry.weight;
  return total;
}

// Хвърля се число от 0 до общото тегло минус 1; теглата се изваждат едно по едно, докато числото падне в ред.
function rollLoot(rng, entries) {
  let roll = rng.nextInt(totalWeight(entries));
  for (const entry of entries) {
    if (roll < entry.weight) {
      if (entry.itemId === "none") return null;
      return { id: entry.itemId, count: rng.range(entry.min, entry.max) };
    }
    roll -= entry.weight;
  }
  return null;
}

// Хвърля се число от 0 до общото тегло минус 1; теглата се изваждат едно по едно, докато числото падне в ред.
function rollLoot(rng, entries) {
  let roll = rng.nextInt(totalWeight(entries));
  for (const entry of entries) {
    if (roll < entry.weight) {
      if (entry.itemId === "none") return null;
      return { id: entry.itemId, count: rng.range(entry.min, entry.max) };
    }
    roll  entry.weight;
  }
  return null;
}

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

const items = loadItems(ITEMS_TEXT);
const tables = loadLoot(LOOT_TEXT);
const rng = new Random(6);
const bag = new Inventory(3, items);
for (let i = 0; i < KILLS.length; i++) {
  const drop = rollLoot(rng, tables.get(KILLS[i]));
  const head = "враг " + (i + 1) + " (" + KILLS[i] + "): ";
  if (drop === null) {
    console.log(head + "нищо");
    continue;
  }
  const added = bag.add(drop.id, drop.count);
  console.log(head + label(items.get(drop.id).name, drop.count) + " -> " + (added ? "готово" : "няма място") + " " + fillText(bag));
}
printBag(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 убити гоблина, и се брои кой ред колко пъти е паднал.

const entries = loadLoot(LOOT_TEXT).get("goblin");
const rng = new Random(2026);
const counts = new Map();
for (let i = 0; i < 1000; i++) {
  const drop = rollLoot(rng, entries);
  const key = drop === null ? "none" : drop.id;
  counts.set(key, (counts.get(key) ?? 0) + 1);
}
const total = totalWeight(entries);
for (const entry of entries) {
  console.log(entry.itemId + ": " + (counts.get(entry.itemId) ?? 0) + " (очаквани " + Math.floor((entry.weight * 1000) / total) + ")");
}

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

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

Виж го

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

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

// Хвърля се число от 0 до общото тегло минус 1; теглата се изваждат едно по едно, докато числото падне в ред.
function rollLoot(rng, entries) {
  let roll = rng.nextInt(totalWeight(entries));
  for (const entry of entries) {
    if (roll < entry.weight) {
      if (entry.itemId === "none") return null;
      return { id: entry.itemId, count: rng.range(entry.min, entry.max) };
    }
    roll -= entry.weight;
  }
  return null;
}

canAdd(itemId, count) {
  const item = this.items.get(itemId);
  if (item.stackable && this.count(itemId) > 0) return true;
  const needed = item.stackable ? 1 : count;
  return this.slots.length + needed <= this.capacity;
}

add(itemId, count) {
  if (!this.canAdd(itemId, count)) return false;
  const item = this.items.get(itemId);
  if (item.stackable) {
    for (const slot of this.slots) {
      if (slot.id === itemId) {
        slot.count += count;
        return true;
      }
    }
    this.slots.push(new Slot(itemId, count));
    return true;
  }
  for (let i = 0; i < count; i++) this.slots.push(new Slot(itemId, 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 от програмата. На всяка стъпка светят редовете, които работят в този момент.

Идеята

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

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

// Продажбата дава половината от цената, закръглена надолу.
function sellPrice(item) {
  return Math.floor(item.price / 2);
}

function buy(player, items, itemId) {
  const item = items.get(itemId);
  let result = "готово";
  if (player.gold < item.price) result = "не стига златото";
  else if (!player.bag.canAdd(itemId, 1)) result = "няма място";
  else {
    player.gold -= item.price;
    player.bag.add(itemId, 1);
  }
  return "купува " + item.name + " (" + item.price + "): " + result + ", злато " + player.gold;
}

function sell(player, items, slotNumber) {
  const slot = player.bag.slots[slotNumber - 1];
  const item = items.get(slot.id);
  const price = sellPrice(item);
  player.bag.removeAt(slotNumber - 1);
  player.gold += price;
  return "продава " + item.name + " (" + price + "): готово, злато " + player.gold;
}

const items = loadItems(ITEMS_TEXT);
const player = new Player(100, new Inventory(3, items));
console.log(buy(player, items, "potion_heal"));
console.log(buy(player, items, "potion_heal"));
console.log(buy(player, items, "chain"));
console.log(buy(player, items, "leather"));
console.log(buy(player, items, "war_axe"));
console.log(sell(player, items, 2));
console.log(buy(player, items, "potion_mana"));
console.log(buy(player, items, "antidote"));
console.log(buy(player, items, "leather"));
console.log(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, закръглено надолу): купуване и веднага продаване никога не е печалба.

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

function sellPrice(item) {
  return Math.floor(item.price / 2);
}

Идеята

В играта

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

// Инвентарът има ограничен брой места. Еднаквите отвари и рудата се трупат на едно място.
class Inventory {
  constructor(capacity) {
    this.capacity = capacity;
    this.slots = [];
  }

  count(itemId) {
    let total = 0;
    for (const slot of this.slots) {
      if (slot.id === itemId) total += slot.count;
    }
    return total;
  }

  canAdd(itemId, count) {
    const item = ITEMS.get(itemId);
    if (item.stackable && this.count(itemId) > 0) return true;
    const needed = item.stackable ? 1 : count;
    return this.slots.length + needed <= this.capacity;
  }

  add(itemId, count) {
    if (!this.canAdd(itemId, count)) return false;
    const item = ITEMS.get(itemId);
    if (item.stackable) {
      for (const slot of this.slots) {
        if (slot.id === itemId) {
          slot.count += count;
          return true;
        }
      }
      this.slots.push({ id: itemId, count: count });
      return true;
    }
    for (let i = 0; i < count; i++) this.slots.push({ id: itemId, count: 1 });
    return true;
  }

  remove(itemId, count) {
    let left = count;
    const kept = [];
    for (const slot of this.slots) {
      if (slot.id === itemId && left > 0) {
        const taken = Math.min(left, slot.count);
        slot.count -= taken;
        left -= taken;
      }
      if (slot.count > 0) kept.push(slot);
    }
    this.slots = kept;
  }

  removeAt(index) {
    const slot = this.slots[index];
    slot.count -= 1;
    if (slot.count <= 0) this.slots.splice(index, 1);
  }
}

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

gearBonus(stat) {
  let total = 0;
  for (const slot of this.equipment.keys()) {
    const itemId = this.equipment.get(slot);
    if (itemId === '') continue;
    for (const mod of ITEMS.get(itemId).mods) {
      if (mod.stat === stat) total += mod.value;
    }
  }
  return total;
}

weapon() {
  const id = this.equipment.get('weapon');
  return ITEMS.get(id === '' ? 'fists' : id);
}

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

// Слага предмета от инвентара; старият заема неговото място в инвентара.
function equipFromInventory(hero, index) {
  const slot = hero.inventory.slots[index];
  const item = ITEMS.get(slot.id);
  if (item.kind !== 'weapon' && item.kind !== 'armor' && item.kind !== 'ring') return '';
  const old = hero.equipment.get(item.kind);
  hero.inventory.removeAt(index);
  hero.equipment.set(item.kind, item.id);
  if (old !== '') hero.inventory.slots.splice(index, 0, { id: old, count: 1 });
  if (hero.hp > hero.maxHp()) hero.hp = hero.maxHp();
  if (hero.mana > hero.maxMana()) hero.mana = hero.maxMana();
  return item.id;
}

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

// Плячка с тегла: тегло 30 от общо 100 значи 30% шанс.
function rollLoot(rng, tableId) {
  const entries = LOOT_TABLES.get(tableId);
  let total = 0;
  for (const entry of entries) total += entry.weight;
  let roll = rng.nextInt(total);
  for (const entry of entries) {
    if (roll < entry.weight) {
      if (entry.itemId === 'none') return null;
      return { id: entry.itemId, count: rng.range(entry.min, entry.max) };
    }
    roll -= entry.weight;
  }
  return null;
}

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

Една таблица по вид. Оръжията, бронята, пръстените, отварите и другото са всеки със свои колони; нашата таблица е една, за да се чете лесно.
Имена на четири езика. Всеки ред в канона носи името на 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 и шест хвърлени числа. Какво печата програмата?

function pick(ids, weights, roll) {
  for (let i = 0; i < ids.length; i++) {
    if (roll < weights[i]) return ids[i];
    roll -= weights[i];
  }
  return ids[ids.length - 1];
}

const ids = ["none", "potion_heal", "spear"];
const weights = [50, 30, 20];
const rolls = [0, 49, 50, 79, 80, 99];
for (const roll of rolls) {
  console.log(roll + ": " + pick(ids, weights, roll));
}

Отговор

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

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

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

Пробвай

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

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

const items = loadItems(ITEMS_TEXT);
const bag = new Inventory(2, items);
addAndShow(bag, "spear", 1);
addAndShow(bag, "potion_heal", 1);
addAndShow(bag, "potion_mana", 1);
addAndShow(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 места, а сценарият е този:

function addAndShow(bag, itemId, count) {
  const added = bag.add(itemId, count);
  const parts = [];
  for (const slot of bag.slots) parts.push(label(bag.items.get(slot.id).name, slot.count));
  console.log("+ " + label(bag.items.get(itemId).name, count) + ": " + (added ? "готово" : "няма място") + " " + fillText(bag) + " [" + parts.join(", ") + "]");
}

const items = loadItems(ITEMS_TEXT);
const bag = new Inventory(3, items);
addAndShow(bag, "potion_heal", 4);
addAndShow(bag, "potion_heal", 3);
addAndShow(bag, "potion_mana", 2);
addAndShow(bag, "potion_heal", 3);
addAndShow(bag, "potion_heal", 1);
addAndShow(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. Защо?Теглата са вероятности, а не точни бройки: всяко хвърляне е независимо, затова броят се колебае около очакванияГенераторът е счупен и пропуска числаПървите хвърляния се губят

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

Бисквитки