feast/src/game/combat/actions.ts

import { StatTest, StatVigorTest, StatVigorSizeTest } from './tests'
import { DynText, LiveText, TextLike, Verb, PairLine, PairLineArgs } from '../language'
import { Entity } from '../entity'
import { Creature } from "../creature"
import { Damage, DamageFormula, Stat, Vigor, Action, Condition, CombatTest } from '../combat'
import { LogLine, LogLines, LogEntry, nilLog } from '../interface'
import { VoreContainer, Container } from '../vore'
import { CapableCondition, UserDrainedVigorCondition, TogetherCondition, EnemyCondition, SoloCondition, PairCondition, ContainsCondition, ContainedByCondition, HasRoomCondition } from './conditions'

/**
 * The PassAction has no effect.
 */
export class PassAction extends Action {
  constructor () {
    super("Pass", "Do nothing", [new SoloCondition()])
  }

  execute (user: Creature, target: Creature): LogEntry {
    return new LogLine(`${user.name.capital} ${user.name.conjugate(new Verb('pass', 'passes'))}`)
  }

  describe (user: Creature, target: Creature): LogEntry {
    return new LogLine("Do nothing.")
  }
}

/**
 * A generic action that causes damage.
 */
export abstract class DamageAction extends Action {
  abstract successLine: PairLineArgs<Creature, { damage: Damage }>

  constructor (name: TextLike, desc: TextLike, protected damage: DamageFormula, tests: CombatTest[], conditions: Condition[] = []) {
    super(
      name,
      desc,
      [new CapableCondition(), new EnemyCondition()].concat(conditions),
      tests
    )
  }

  try (user: Creature, target: Creature): LogEntry {
    const effectResults = target.effects.map(effect => effect.preAttack(target, user))

    if (effectResults.some(result => result.prevented)) {
      return new LogLines(...effectResults.map(result => result.log))
    } else {
      return super.try(user, target)
    }
  }

  execute (user: Creature, target: Creature): LogEntry {
    const damage = this.damage.calc(user, target)
    const targetResult = target.takeDamage(damage)
    const ownResult = this.successLine(user, target, { damage: damage })
    return new LogLines(ownResult, targetResult)
  }
}

/**
 * Adds flavor text to [[DamageAction]]
 */
export class AttackAction extends DamageAction {
  constructor (damage: DamageFormula, protected verb: Verb = new Verb('smack')) {
    super(
      verb.root.capital,
      'Attack the enemy',
      damage,
      [new StatTest(
        Stat.Power,
        10,
        (user, target) => new LogLine(
          `${user.name.capital} ${user.name.conjugate(new Verb('miss', 'misses'))} ${target.name.objective}!`
        )
      )],
      [new TogetherCondition()]
    )
  }

  describe (user: Creature, target: Creature): LogEntry {
    return new LogLine(`Attack ${target.baseName}. `, this.damage.describe(user, target), '. ', super.describe(user, target))
  }

  successLine: PairLineArgs<Creature, { damage: Damage }> = (user, target, args) => new LogLine(
    `${user.name.capital} ${user.name.conjugate(this.verb)} ${target.name.objective} for `,
    target.effectiveDamage(args.damage).renderShort()
  )

  failLine: PairLine<Creature> = (user, target) => new LogLine(
    `${user.name.capital} ${user.name.conjugate(new Verb('miss', 'misses'))} ${target.name.objective}`
  )
}

/**
 * Devours the target.
 */
export class DevourAction extends Action {
  constructor (protected container: Container) {
    super(
      new DynText(new LiveText(container, x => x.consumeVerb.capital), ' (', new LiveText(container, x => x.name.all), ')'),
      new LiveText(container, x => `Try to ${x.consumeVerb} your foe`),
      [new CapableCondition(), new TogetherCondition(), new HasRoomCondition(container)],
      [new StatVigorSizeTest(
        Stat.Power,
        10,
        (user, target) => new LogLine(`${user.name.capital} ${user.name.conjugate(new Verb('fail'))} to ${container.consumeVerb} ${target.name.objective}.`)
      )]
    )
  }

  allowed (user: Creature, target: Creature): boolean {
    const owner = this.container.owner === user
    const predOk = Array.from(this.container.voreTypes).every(pref => user.predPrefs.has(pref))
    const preyOk = Array.from(this.container.voreTypes).every(pref => target.preyPrefs.has(pref))

    if (owner && predOk && preyOk) {
      return super.allowed(user, target)
    } else {
      return false
    }
  }

  describe (user: Creature, target: Creature): LogEntry {
    return new LogLine(`Try to ${this.container.consumeVerb} your opponent, sending them to your ${this.container.name}. `, super.describe(user, target))
  }

  execute (user: Creature, target: Creature): LogEntry {
    return this.container.consume(target)
  }
}

/**
 * Causes the user to be eaten by the target.
 */
export class FeedAction extends Action {
  constructor (protected container: Container) {
    super(
      'Feed',
      'Feed yourself to your opponent',
      [new UserDrainedVigorCondition(Vigor.Resolve), new TogetherCondition()]
    )
    this.name += ` (${container.name})`
  }

  allowed (user: Creature, target: Creature): boolean {
    const owner = this.container.owner === target
    const predOk = Array.from(this.container.voreTypes).every(pref => user.preyPrefs.has(pref))
    const preyOk = Array.from(this.container.voreTypes).every(pref => target.predPrefs.has(pref))

    if (owner && predOk && preyOk) {
      return super.allowed(user, target)
    } else {
      return false
    }
  }

  execute (user: Creature, target: Creature): LogEntry {
    return new LogLines(this.successLine(user, target), this.container.consume(user))
  }

  describe (user: Creature, target: Creature): LogEntry {
    return new LogLine(`Your willpower is drained, and you really feel like shoving yourself into ${target.name.possessive} ${this.container.name}...`)
  }

  protected successLine: PairLine<Entity> = (user, target) => new LogLine(
    `${user.name.capital} ${user.name.conjugate(new Verb('feed'))} ${user.pronouns.reflexive} to ${target.name}. `
  )

  protected failLine: PairLine<Entity> = (user, target) => new LogLine(
    `${user.name.capital} ${user.name.conjugate(new Verb('fail'))} to feed ${user.pronouns.reflexive} to ${target.name}. `
  )
}

/**
 * Tries to escape from the target's container
 */
export class StruggleAction extends Action {
  constructor (public container: Container) {
    super(
      new DynText('Struggle (', new LiveText(container, x => x.name.all), ')'),
      'Try to escape from your foe',
      [new CapableCondition(), new PairCondition(), new ContainedByCondition(container)],
      [new StatVigorSizeTest(
        Stat.Power,
        0,
        (user, target) => new LogLine(`${user.name.capital} ${user.name.conjugate(new Verb('fail'))} to escape from ${target.name.possessive} ${container.name}.`)
      )]
    )
  }

  execute (user: Creature, target: Creature): LogEntry {
    if (user.containedIn !== null) {
      return new LogLines(this.successLine(user, target, { container: this.container }), user.containedIn.release(user))
    } else {
      return new LogLine("Vore's bugged!")
    }
  }

  describe (user: Creature, target: Creature): LogEntry {
    return new LogLine(`Try to escape from ${target.baseName.possessive} ${this.container.name}. `, super.describe(user, target))
  }

  protected successLine: PairLineArgs<Entity, { container: Container }> = (prey, pred, args) => new LogLine(
    `${prey.name.capital} ${prey.name.conjugate(new Verb('escape'))} from ${pred.name.possessive} ${args.container.name}.`
  )
}

export class DigestAction extends Action {
  constructor (protected container: VoreContainer) {
    super(
      new DynText('Digest (', new LiveText(container, container => container.name.all), ')'),
      'Digest your prey',
      [new CapableCondition(), new SoloCondition()]
    )
  }

  allowed (user: Creature, target: Creature) {
    if (this.container.owner === user && this.container.contents.length > 0) {
      return super.allowed(user, target)
    } else {
      return false
    }
  }

  execute (user: Creature, target: Creature): LogEntry {
    const results = this.container.tick(60)
    return new LogLines(results)
  }

  describe (user: Creature, target: Creature): LogEntry {
    return new LogLine(`Digest everyone inside of your ${this.container.name}.`)
  }
}

export class ReleaseAction extends Action {
  constructor (protected container: Container) {
    super(
      new DynText('Release (', new LiveText(container, x => x.name.all), ')'),
      'Release one of your prey',
      [new CapableCondition(), new PairCondition(), new ContainsCondition(container)]
    )
  }

  allowed (user: Creature, target: Creature) {
    if (target.containedIn === this.container && this.container.contents.indexOf(target) >= 0) {
      return super.allowed(user, target)
    } else {
      return false
    }
  }

  execute (user: Creature, target: Creature): LogEntry {
    return this.container.release(target)
  }

  describe (user: Creature, target: Creature): LogEntry {
    return new LogLine(`Release ${target.baseName} from your ${this.container.name}.`)
  }
}

export class TransferAction extends Action {
  verb: Verb = new Verb('send')

  constructor (protected from: Container, protected to: Container, name = 'Transfer') {
    super(
      name,
      `${from.name.all.capital} to ${to.name.all}`,
      [new CapableCondition(), new PairCondition()]
    )
  }

  line: PairLineArgs<Creature, { from: Container; to: Container }> = (user, target, args) => new LogLine(
    `${user.name.capital} ${user.name.conjugate(this.verb)} ${target.name.objective} from ${user.pronouns.possessive} ${args.from.name} to ${user.pronouns.possessive} ${args.to.name}`
  )

  allowed (user: Creature, target: Creature) {
    if (target.containedIn === this.from && this.from.contents.includes(target)) {
      return super.allowed(user, target)
    } else {
      return false
    }
  }

  execute (user: Creature, target: Creature): LogEntry {
    this.from.release(target)
    this.to.consume(target)
    return this.line(user, target, { from: this.from, to: this.to })
  }

  describe (user: Creature, target: Creature): LogEntry {
    return new LogLine(`Push ${target.baseName} from your ${this.from.name} to your ${this.to.name}`)
  }
}