antipath/core/battle/ai.js

const Move = require('./move')

const discord = require('discord.js')
const _ = require('lodash')
const prompt = require('../util/prompt')

// The base class! Each method is called to request a decision from the AI.
// Instanced on a battle-by-battle, per-character basis.
class AI {
  constructor(char, battle, team) {
    this.char = char
    this.battle = battle
    this.team = team
  }

  // Returns { move: Move, targets: [Character] } to perform next.
  async moveChoice(self, battle) {}
}

// For player-controlled characters. Interfaces with Discord.
class DiscordAI extends AI {
  async moveChoice() {
    // Move
    const moves = await Promise.all(
      this.char.moveIDs.map(id => Move.findOne({_id: id}))
    )

    const {move} = await prompt({
      channel: this.team.channel,
      user: this.char,
      title: this.char.getName(this.battle.game.guild),
      description: 'Next move:',
      choices: moves.map(move => ({
        emote: move.emote,
        name: `**${move.name}** - ${move.description}`,
        move,
      })),
    })

    // Target(s)
    let targetPromptDesc = `Use _${move.name}_ on:`

    if (move.target.numberMin === 1 && move.target.numberMax > 1) {
      targetPromptDesc += ` (pick up to ${move.target.numberMax})`
    } else if (move.target.numberMax > move.target.numberMin) {
      targetPromptDesc += ` (pick ${move.target.numberMin} - ${
        move.target.numberMax
      })`
    }

    let targetable
    switch (move.target.type) {
      // Only yourself.
      case 'self':
        targetable = [this.char]
        break

      // Everyone in your party but yourself.
      case 'party':
        targetable = this.team.party.members.filter(
          m => m.discordID !== this.char.discordID
        )
        break

      // Anyone in a different party (ie. hostile),
      case 'enemy':
        targetable = _.flatten(
          this.battle.teams
            .map(({party}) => party)
            .filter(party => party._id !== this.team.party._id)
            .map(party => party.members)
        )
        break

      // Anyone else in the battle.
      case 'any':
        targetable = this.battle.everyone.filter(m => m._id !== this.char._id)
        break
    }

    /*if (targetable.length === 1) {
      // Only one character can be targeted, so just choose them.
      return {move, targets: targetable}
    } else */ if (
      targetable.length === 0
    ) {
      // No-one can be targeted, so ask for a different move choice.
      // TODO: handle this case better?
      const msg = await this.team.channel.send('No targets for that move!')
      const ret = await this.moveChoice()

      await msg.delete()
      return ret
    }

    // TODO: add a back button

    const targets = await prompt.multi({
      channel: this.team.channel,
      user: this.char,
      title: this.char.getName(this.battle.game.guild),
      description: targetPromptDesc,
      choices: await Promise.all(
        targetable.map(async (char, i) => ({
          emote: await char.getEmote(this.battle.game),
          name: char.getName(this.battle.game.guild),
          char,
        }))
      ),
      chooseMin: move.target.numberMin,
      chooseMax: move.target.numberMax,
    })

    return {move, targets: targets.map(choice => choice.char)}
  }
}

module.exports = {DiscordAI}