feast/src/game/items.ts

import { TextLike, LiveText, DynText, Word, ImproperNoun, Verb } from './language'
import { Actionable, Action, DamageFormula, ConstantDamageFormula, Damage, DamageType, Vigor, StatDamageFormula, Stat, Effective, CompositionAction, Condition, CompositeDamageFormula } from './combat'
import { AttackAction } from './combat/actions'
import { Resistances } from './entity'
import { DamageTypeResistanceEffect } from './combat/effects'
import { DamageConsequence, LogConsequence, HealingConsequence } from './combat/consequences'
import { SoloCondition } from './combat/conditions'
import { LogLine, LogEntry } from './interface'
import { Creature } from './creature'

export enum ItemKind {
  Key = "Key Item",
  Consumable = "Consumable",
  Equipment = "Equipment"
}

export const ItemKindIcons: {[key in ItemKind]: string} = {
  [ItemKind.Key]: "fas fa-key",
  [ItemKind.Consumable]: "fas fa-wine-bottle",
  [ItemKind.Equipment]: "fas fa-hammer"
}

export abstract class Item implements Actionable {
  actions: Array<Action> = []
  effects: Array<Effective> = []
  consumed = false

  abstract kind: ItemKind
  constructor (public name: Word, public desc: TextLike) {

  }
}

export enum EquipmentSlot {
  Head = "Head",
  Chest = "Chest",
  Legs = "Legs",
  Arms = "Arms",
  MainHand = "MainHand",
  OffHand = "OffHand",
  Feet = "Feet"
}

export abstract class Equipment extends Item {
  kind = ItemKind.Equipment
  abstract slot: EquipmentSlot
}

export abstract class Weapon extends Equipment {
  actions: Array<Action> = []
  slot = EquipmentSlot.MainHand

  constructor (name: Word, desc: TextLike, damageFormula: DamageFormula, verb: Verb) {
    super(name, desc)
    const attack = new AttackAction(damageFormula, verb)
    attack.desc = new DynText(`Attack with your `, this.name.all)
    this.actions.push(attack)
  }
}

export class Sword extends Weapon {
  constructor () {
    super(
      new ImproperNoun('sword', 'swords'),
      'An arming sword',
      new StatDamageFormula([
        { fraction: 0.35, stat: Stat.Power, target: Vigor.Health, type: DamageType.Slash },
        { fraction: 0.25, stat: Stat.Power, target: Vigor.Health, type: DamageType.Pierce }
      ]),
      new Verb('slash', 'slashes')
    )
  }
}

export class Dagger extends Weapon {
  constructor () {
    super(
      new ImproperNoun('dagger', 'daggers'),
      'A pointy dagger',
      new StatDamageFormula([
        { fraction: 0.50, stat: Stat.Speed, target: Vigor.Health, type: DamageType.Pierce },
        { fraction: 0.05, stat: Stat.Speed, target: Vigor.Health, type: DamageType.Slash }
      ]),
      new Verb('stab', 'stabs', 'stabbing', 'stabbed')
    )
  }
}

export class Wand extends Weapon {
  constructor () {
    super(
      new ImproperNoun('wand', 'wands'),
      'A magical wand',
      new StatDamageFormula([
        { fraction: 0.25, stat: Stat.Charm, target: Vigor.Health, type: DamageType.Crush },
        { fraction: 0.25, stat: Stat.Willpower, target: Vigor.Health, type: DamageType.Crush }
      ]),
      new Verb('zap', 'zaps', 'zapping', 'zapped')
    )
  }
}

export class Mace extends Weapon {
  constructor () {
    super(
      new ImproperNoun('mace', 'maces'),
      'A heavy mace',
      new StatDamageFormula([
        { fraction: 0.4, stat: Stat.Power, target: Vigor.Health, type: DamageType.Crush },
        { fraction: 0.2, stat: Stat.Power, target: Vigor.Health, type: DamageType.Pierce }
      ]),
      new Verb('bash', 'bashes', 'bashing', 'bashed')
    )
  }
}

export abstract class Armor extends Equipment {
  constructor (name: Word, desc: TextLike, public slot: EquipmentSlot, resistances: Partial<Resistances>) {
    super(name, desc)
    Object.entries(resistances).forEach(([damageType, value]) => {
      if (value !== undefined) {
        this.effects.push(
          new DamageTypeResistanceEffect(
            [damageType as DamageType],
            value
          )
        )
      }
    })
  }
}

export class Helmet extends Armor {
  constructor () {
    super(
      new ImproperNoun('helmet'),
      'A helmet',
      EquipmentSlot.Head,
      {
        Slash: 0.75,
        Pierce: 0.5,
        Crush: 0.9
      }
    )
  }
}

export class ItemAction extends Action {
  constructor (name: TextLike, desc: TextLike, private item: Item, private action: Action) {
    super(name, desc, action.conditions)
  }

  execute (user: Creature, target: Creature): LogEntry {
    this.item.consumed = true
    return this.action.execute(user, target)
  }

  describe (user: Creature, target: Creature): LogEntry {
    return this.action.describe(user, target)
  }
}

export class Consumable extends Item {
  kind = ItemKind.Consumable

  constructor (name: Word, desc: TextLike, onUse: Action) {
    super(name, desc)
    this.actions.push(new ItemAction(
      onUse.name,
      onUse.desc,
      this,
      onUse
    ))
  }
}

export class HealthPotion extends Consumable {
  constructor () {
    super(
      new ImproperNoun("health potion"),
      "Restores all of your vigors",
      new CompositionAction(
        "Drink Potion",
        "Heals your vigors",
        {
          conditions: [
            new SoloCondition()
          ],
          consequences: [
            new LogConsequence(
              (user, target) => new LogLine(`${user.name.capital} ${user.name.conjugate(new Verb('drink'))} a potion.`)
            ),
            new HealingConsequence(
              new CompositeDamageFormula([
                new ConstantDamageFormula(
                  new Damage(
                    { amount: 100, target: Vigor.Health, type: DamageType.Heal },
                    { amount: 100, target: Vigor.Stamina, type: DamageType.Heal },
                    { amount: 100, target: Vigor.Resolve, type: DamageType.Heal }
                  )
                ),
                new StatDamageFormula([
                  { fraction: 2, stat: Stat.Toughness, target: Vigor.Health, type: DamageType.Heal },
                  { fraction: 2, stat: Stat.Speed, target: Vigor.Stamina, type: DamageType.Heal },
                  { fraction: 2, stat: Stat.Willpower, target: Vigor.Resolve, type: DamageType.Heal }
                ])
              ])
            )
          ]
        }
      )
    )
  }
}