Chaturbate

Apps Home | My Uploads | Create an App
Dungeon Crawl
Author: lemons_
Description Source Code Launch App Current Users
Created by: Lemons_
There are 174 other versions of this script.
// ------------------------------------------------------------------------------
// Dungeon Crawl by lemons_
//
// Sprites under commercial licence from:
//     https://www.oryxdesignlab.com/products/16-bit-fantasy-tileset
// ------------------------------------------------------------------------------


// ------------------------------------------------------------------------------
// Enemy
class Enemy {
  constructor(level, health) {
    let option
    if (level === 0) {
      option = {name: "Outside", type: {name: "Outdoors"}, count: 0}
    } else {
      const options = Enemy.levels[level]
      option = options[Math.floor(Math.random() * options.length)]
    }
    this.name = option.name
    this.type = option.type
    this.image = option.image
    this.icon = `:lemons_dc_enemy_${option.icon}`
    this.initHealths(health, option.count)
  }
  
  initHealths(health, count) {
    this.healths = []
    const healthPerEnemy = Math.floor(health / count)
    for (let i = 0; i < count - 1; i++) {
      this.healths.push(healthPerEnemy)
      health -= healthPerEnemy
    }
    // Foe at back has any uneven health.
    if (health > 0) {
      this.healths.push(health)
    }
  }
  
  removeDead() {
    this.healths = this.healths.filter((hp) => hp > 0)
  }
  
  applyDamage(amount, position=0) {
    const damage = Math.min(this.healths[position], amount)
    this.healths[position] -= damage
    return damage
  }
  
  get isDefeated() {
    for (let i = 0; i < this.healths.length; i++) {
      if (this.healths[i] > 0) {
        return false
      }
    }
    return true
  }
  
  get count() {
    return this.healths.length
  }
  
  get healthsStr() {
    return this.healths.join(", ")
  }
  
  get totalHealthRemaining() {
    return this.healths.reduce((a, h) => (a + h), 0) 
  }
  
  health(i) {
    return this.healths[i]
  }
}
Enemy.types = {
  HUMANOID: {name: "Humanoid"},
  BEAST: {name: "Beast"},
  MONSTER: {name: "Monster"},
  UNDEAD: {name: "Undead"},
  BOSS: {name: "Boss"},
}
Enemy.levels = {  // Max count == 7 if they are to fit in space on panel.
  1: [
    {name: "Kobold", count: 5, type: Enemy.types.HUMANOID, icon: "kobold1", image: "478261c2-2f1a-4b4a-aec1-4568339ec849"},
    {name: "Dire Rat", count: 3, type: Enemy.types.BEAST, icon: "rat2", image: "7732b0ff-d87d-49d3-ae49-497ba064e181"},
    {name: "Evil Eye", count: 7, type: Enemy.types.MONSTER, icon: "eye1", image: "bb938e5b-10b3-4cce-964e-af9d6bbc327d"},
    {name: "Zombie", count: 4, type: Enemy.types.UNDEAD, icon: "zombie1", image: "e2d53d1e-5af8-4ff8-9a4a-8bd4f1c4356a"},
  ],
  2: [
    {name: "Goblin", count: 4, type: Enemy.types.HUMANOID, icon: "goblin1", image: "0d9091d0-3f7d-4019-affd-3a5f36ea5eaa"},
    {name: "Giant Spider", count: 5, type: Enemy.types.BEAST, icon: "spider1", image: "fbe813fe-644e-42dd-be6f-1ae3027bc0b2"},
    {name: "Jelly Cube", count: 1, type: Enemy.types.MONSTER, icon: "jelly1", image: "367ac0ba-3f02-4e10-a466-279efca05a2c"},
    {name: "Skeleton Warrior", count: 3, type: Enemy.types.UNDEAD, icon: "skeleton_war1", image: "8002915e-c6c0-4b89-8ad6-1e7b4805c96d"},
  ],
  3: [
    {name: "Gnoll", count: 4, type: Enemy.types.HUMANOID, icon: "gnoll1", image: "8002915e-c6c0-4b89-8ad6-1e7b4805c96d"},
    {name: "Dire Wolf", count: 5, type: Enemy.types.BEAST, icon: "wolf1", image: "78b602f4-b4de-4356-a663-102dd21e2339"},
    {name: "Golem", count: 1, type: Enemy.types.MONSTER, icon: "golem1", image: "64a02da3-0263-478c-8317-301a12506b97"},
    {name: "Spectre", count: 4, type: Enemy.types.UNDEAD, icon: "spectre1", image: "31f618a4-fd29-4a79-8b1f-6148fb8c9f36"},
  ],
  4: [
    {name: "Bewitched Knight", count: 3, type: Enemy.types.HUMANOID, icon: "knight", image: "bd0f1f13-fd82-4fc2-a094-23ef1439473b"},
    {name: "Fire Scorpion", count: 2, type: Enemy.types.BEAST, icon: "scorpion1", image: "033a6dfc-21ac-4bfc-8b44-f30f07847b01"},
    {name: "Troll", count: 2, type: Enemy.types.MONSTER, icon: "troll1", image: "3acdd746-ce9f-4b55-a039-e4e1efe89bdc"},
    {name: "Vampire", count: 1, type: Enemy.types.UNDEAD, icon: "vampire1", image: "171c2047-01de-41ff-a2f5-2b5906e3a00e"},
  ],
  FINAL: [
    {name: "Lich", count: 1, type: Enemy.types.BOSS, icon: "lich1", image: "f3bfa120-27f5-45bd-a0d5-5195af14e1c2"},
    {name: "Dragon", count: 1, type: Enemy.types.BOSS, icon: "dragon1", image: "9b4aaeed-c1a2-4de2-8c27-590463a6e64e"},
    {name: "Beholder", count: 1, type: Enemy.types.BOSS, icon: "beholder1", image: "08cab5b3-0e61-464e-bbc7-19eb41f2bfb7"},
    {name: "Witch", count: 1, type: Enemy.types.BOSS, icon: "witch1", image: "3d5b39d8-6726-4a41-9113-bce5650eb39a"},
    {name: "Minotaur", count: 1, type: Enemy.types.BOSS, icon: "minotaur1", image: "7e65f588-a90d-44f9-9988-3ae7fbb0c691"},
    {name: "Mummy", count: 1, type: Enemy.types.BOSS, icon: "mummy1", image: "d7525fe3-cc66-4e0e-9343-261395766ca9"},
    {name: "Mind Flayer", count: 1, type: Enemy.types.BOSS, icon: "mindflayer1", image: "9dde752c-7ecb-446a-acfd-f902a14df191"},
  ]
}


// ------------------------------------------------------------------------------
class Class {
  constructor(name) {
    this.data = Class.config[name]
  }
  
  icon(gender) {
    return `:lemons_dc_class_${this.data.icon}_${gender}`
  }
  
  get image() {
    return this.data.image
  }

  get name() {
    return this.data.name
  }
  
  get action() {
    return this.data.action
  }
  
  get missile() {
    return this.data.missile
  }
  
  get backstab() {
    return this.data.backstab
  }
  
  get hidePlayer() {
    return !!this.data.hidePlayer
  }
  
  get bonusStr() {
    if (this.data.bonus) {
      return ` (Bonus vs ${this.data.bonus.map((b) => b.name).join(", ")})`
    } else {
      return ""
    }
  }
  
  hasBonusVs(enemyType) {
    return this.data.bonus && this.data.bonus.includes(enemyType)
  }
  
  get specialStr() {
    switch (this.special) {
      case "BACKSTAB":
        return " (Backstab: Attacks the enemy at the back)"
      case "BLAST":
        return " (Blast: Damage spreads evenly over all enemies)"
      case "PIERCE":
        return " (Pierce: Extra damage carries over to second enemy)"
      default:
        return ""
    }
  }
  
  get description() {
    return `${this.name}${this.bonusStr}${this.specialStr}`
  }
  
  
  get special() {
    return this.data.special
  }
}
Class.config = {
  RANGER: {name: "Ranger", icon: "ranger", action: "shoot", special: "PIERCE", 
           image: "52c7f861-d2ee-4af1-958b-0fe548ac1586", 
           missile: {image: "7b08e2e9-1044-441e-8226-6440c146bde0", icon: "ranger1"}},
  
  KNIGHT: {name: "Knight", icon: "knight", bonus: [Enemy.types.HUMANOID], action: "bash",
           image: "f37c37aa-5d1e-4fe1-b400-285477e69909"},
  
  WIZARD: {name: "Wizard", icon: "wizard", action: "burn", special: "BLAST", 
           image: "6b8d6ab9-34ca-4b93-a5e2-409c66f5cd3c", 
           missile: {image: "811c15e4-5284-4c45-aae3-5e5d83af4cc8", icon: "wizard1"}},
  
  PRIEST: {name: "Priest", icon: "priest", bonus: [Enemy.types.UNDEAD], action: "bless",
           image: "1d58985b-c389-497e-ae84-2a22b1102136",
           missile: {image: "67cbe4b6-48a5-4ac8-839e-df1c42cefa6c", icon: "priest1"}},
  
  PALADIN: {name: "Paladin", icon: "paladin", bonus: [Enemy.types.UNDEAD], action: "smite",
            image: "2717497b-cfa6-4b2f-bbf4-92d9a4a39af9"},
  
  ROGUE: {name: "Rogue", icon: "rogue1", action: "stab", special: "BACKSTAB", hidePlayer: true,
          backstab: {image: "3f2d2bc6-1db1-40ef-948d-cdd7f1978914", icon: "rogue1b"},
          image: "68bb4d50-ee18-484a-81ce-9b8d8690b4a9"},
   
  DRUID: {name: "Druid", icon: "druid", bonus: [Enemy.types.BEAST], action: "maul",
          image: "45d48461-fb3b-41b6-8a19-a43c70893cbc", hidePlayer: true,
          missile: {image: "5d7f3a13-641e-468a-8aa8-57b97c897ebb", icon: "druid1"}},
  
  //DUELIST: {name: "Duelist", icon: "duelist", bonus: [Enemy.types.HUMANOID], action: "stab", 
  //          image: "b3cdbc75-a02e-442f-854e-ce20bd7710fc"},
  
  BARBARIAN: {name: "Barbarian", icon: "barbarian", bonus: [Enemy.types.MONSTER], action: "cleave",
              image: "cd20c955-a594-47f4-8836-785564c5ab2f"},
  
  BARD: {name: "Bard", icon: "bard", bonus: [Enemy.types.BEAST], action: "insult",
         image: "a2aa9a5f-77a8-4dbb-9ac0-e03d67ef19fa"},

  PEASANT: {name: "Peasant", icon: "peasant2", action: "punch",
            image: "032ec0c6-50c2-4daf-bfc3-3863372e88c8"},  // Default.
  
  CAPTIVE: {name: "Captive", icon: "captive", action: "slap"},  // Model during game (peasant).
  FREED: {name: "Rescued Captive", icon: "freed", action: "slap"},  // Model after rescue (king/queen).
}


// ------------------------------------------------------------------------------
// Classes
class Classes {
  constructor() {
    this.classes = {}
    for (const classID of Object.keys(Class.config)) {
      this.classes[classID] = new Class(classID)
    }
  }
  
  get(id) {
    return this.classes[id]
  }
}


// ------------------------------------------------------------------------------
// Player
class Player {
  constructor(name) {
    this.name = name
    this.xp = 0  // Amount of damage dealt
    this.tipped = 0 // Amount of tokens tipped
    this.gender = this.isBroadcaster ? cb.settings.captiveGender : "m"
    this.klass = new Class(this.isBroadcaster ? "CAPTIVE" : "PEASANT")
    this.isMod = false
  }
  
  get icon() {
    return this.klass.icon(this.gender)
  }
  
  get image() {
    return this.klass.image
  }
  
  get missile() {
    return this.klass.missile
  }
  
  get backstab() {
    return this.klass.backstab
  }
  
  // Hide player when attacking.
  get hidePlayer() {
    return this.klass.hidePlayer
  }
  
  attack(enemy, tipAmount) {
    this.tipped += tipAmount
    
    // Damage = tip * 0.5 to * 1.5 (or tip * 1 to * 2 with bonus)
    const baseDamage = Math.floor(tipAmount / 2)
    
    let damage = baseDamage + roll(baseDamage, 2)
    
    if (this.klass.hasBonusVs(enemy.type)) {
      damage += baseDamage
    }
    
    let effectiveDamage = 0
    
    
    switch (this.klass.special) {
      case "BACKSTAB":  // Attack the last one in the line!
        effectiveDamage += enemy.applyDamage(damage, enemy.count - 1)
        break
      case "BLAST":  // Spead damage over all enemies
        const individualDamage = Math.round(damage / enemy.count)
        for (let i = 0; i < enemy.count; i++) {
          effectiveDamage += enemy.applyDamage(individualDamage, i)
        }
        break
      case "PIERCE": // Attack first and second.
        let damageRemaining = damage
        for (let i = 0; i < Math.min(2, enemy.count); i++) {
          const damageApplied = enemy.applyDamage(damageRemaining, i)
          damageRemaining -= damageApplied
          effectiveDamage += damageApplied
        }
        break
      default:  // Attack front enemy.
        effectiveDamage += enemy.applyDamage(damage, 0)
        break
    }
    
    const overkill = effectiveDamage < damage ? ` (${damage - effectiveDamage} excess damage wasted!)` : ""
    this.xp += effectiveDamage

    print(`${this.name} ${this.icon} ${pluralize(this.klass.action)} the ${enemy.name} ${enemy.icon} for ${effectiveDamage} damage${overkill}`)
        
    return effectiveDamage
  }
    
  setClass(klassID) {
    this.klass = new Class(klassID)
    this.xp = Math.max(0, this.xp - cb.settings.xpToAdvance)
    print(`You train very hard and become a ${this.icon} ${this.klass.description}!`, this.name)
  }
  
  display(player) {
    const klass = this.klass.description,
          who = player == this ? "You are" : `${this.name} is`
    print(`${who} a level ${this.level} ${klass} with ${this.xp} XP (tipped a total of ${this.tipped} tokens in this game)`,
          player.name)
  }
  
  get level() {
    return Math.floor(this.xp / cb.settings.xpToAdvance) + 1
  }
  
  get isBroadcaster() {
    return this.name == cb.room_slug
  }
  
  get isAdmin() {
    return this.isBroadcaster || this.isMod
  }
}


// ------------------------------------------------------------------------------
// Players
class Players {
  constructor() {
    this.players = {}
  }
  
  get(name, isMod) {
    if (!this.players[name]) {
      this.players[name] = new Player(name)
    }
    
    const p = this.players[name]
    p.isMod = isMod
    return p
  }
}


// ------------------------------------------------------------------------------
// Leaderboard
class Leaderboard {
  constructor() {
    this.hits = []
    this.heros = []
    this.lastAttack = null
  }
  
  displayHeros(player) {
    const lines = [title("Hall of Heros")]
    for (let i = 0; i < this.heros.length; i++) {
      lines.push(`${i + 1}) ${this.describeHero(i)}`)
    }
    print(lines.join("\n"), player.name)
  }
  
  displayHits(player) {
    const lines = [title("Greatest Hits")]
    for (let i = 0; i < this.hits.length; i++) {
      lines.push(`${i + 1}) ${this.describeHit(i)} damage`)
    }
    print(lines.join("\n"), player.name)
 }
  
  describeHit(n) {
    const hit = this.hits[n]
    return `${hit.player.icon} ${hit.player.name}: ${hit.damage}`
  }
  
  describeHero(n) {
    const hero = this.heros[n]
    return `${hero.icon} ${hero.name}: Lvl ${hero.level} (${hero.xp} XP)`
  }
  
  get greatestHero() {
    if (this.heros.length === 0) {
      return null
    }
    return this.heros[0]
  }
  
  record(player, damage) {
    this.hits.push({player: player, damage: damage})
    this.hits.sort((a, b) => b.damage - a.damage)
    this.hits = this.hits.slice(0, cb.settings.leaderboardSize)
    
    if (!this.heros.find((p) => p.name == player.name)) {
      this.heros.push(player)
    }
    this.heros.sort((a, b) => b.xp - a.xp)
    this.heros = this.heros.slice(0, cb.settings.leaderboardSize)
    
    this.lastAttack = {
      image: player.hidePlayer ? null : player.image,
      missile: player.missile ? player.missile.image : null,
      backstab: player.backstab ? player.backstab.image : null,
      damage: damage,
      name: player.name,
      level: player.level,
    }
  }
  
  invalidateLastAttack() {
    this.lastAttack = null
  }
}


// ------------------------------------------------------------------------------
// Panel
class Panel {
  constructor() {
    this.layers = []
  }
  
  addImage(fileID, x=0, y=0) {
    this.layers.push({
      type: "image",
      fileID: fileID,
      left: x,
      top: y,
    })
  }
    
  addText(text, x, y, {
    color = "white",
    shadow = false,
    fontSize = 11, 
    fontStyle = "normal",
    fontFamily = "UbuntuRegular"
  }={}) {
    if (shadow) {
      this.layers.push({
        type: "text",
        text: text,
        left: x + 0.5,
        top: y + 0.5,
        "font-size": fontSize,
        "font-style": fontStyle,
        "font-family": fontFamily,
        color: "black",
      })
    }
    
    this.layers.push({
      type: "text",
      text: text,
      left: x,
      top: y,
      "font-size": fontSize,
      "font-style": fontStyle,
      "font-family": fontFamily,
      color: color,
    })
  }
    
  draw() {
    this.layers = []
    
    this.addImage(Panel.BACKGROUNDS[game.currentLevelIndex])
      
    this.addTopRow()
    this.addMiddleRow()
    this.addBottomRow()
    
    return {template: "image_template", layers: this.layers}
  }
  
  addTopRow() {
    this.addText("Dungeon Crawl", 4, 2, {color: "orange", shadow: true, fontStyle: "bold"})
    
    if (game.currentLevelIndex === 0) {
      this.addText('Tip to enter!', 195, 2, {shadow: true, fontStyle: "bold"})
    } else {
      const progress = game.isPlaying ? `${game.currentLevelIndex} of ${game.numLevels}` : "Completed!"

      this.addText(progress, Panel.ENEMIES_X + 4, 2, {shadow: true})
      this.addText(game.reward ? ` (${game.reward})` : "", Panel.ENEMIES_X + 40, 4, {shadow: true, fontSize: 8})
    }
  }
  
  addMiddleRow() {
    if (game.enemy) {
      this.addEnemies()
    }
 
    if (game.leaderboard.lastAttack) {
      this.addLastAttack()
    }
  }
  
  addBottomRow() {
    this.addText( `Greatest Hero`, 4, 54, {shadow: true, color: "orange"})
    this.addHero()
  }
  
  addHero() {
    const hero = game.leaderboard.greatestHero
    
    if (hero) {
      this.addImage(hero.image, Panel.ENEMIES_X, 52)
    }
    
    this.addText(
      hero ? `${hero.name}: Lvl ${hero.level} (${hero.xp} XP)` : "No-one is brave enough!",
      Panel.ENEMIES_X + (hero ? 24 : 0), 54,
      {shadow: true}      
    )
  }
  
  addLastAttack() {
    const attack = game.leaderboard.lastAttack
    
    // Attacker class image.
    if (attack.image) {
      this.addImage(attack.image, attack.missile ? 6 : Panel.ENEMIES_X - 24, 20)
    } else if (attack.backstab) {
      this.addImage(attack.backstab, Panel.ENEMIES_X + game.enemy.count * 24, 20)
    }

    // Name
    this.addText(`${attack.name} (${attack.level})`, 4, 41, {fontSize: 8, shadow: true})
    
    // Missile
    if (attack.missile) {
      this.addImage(attack.missile, Panel.ENEMIES_X - 24, 20)
    }

    // Hit splat
    //this.addImage("9c9dd554-a6fd-4afb-9fc1-34b691f73a88", Panel.ENEMIES_X, 20)
   
    // Damage
    this.addText(`-${attack.damage}`, Panel.ENEMIES_X + 5, 15,  {fontSize: 9, color: "#ff3333", shadow: true, fontFamily: "UbuntuBold"})
  }
  
  addEnemies(layers) {
    const enemy = game.enemy
    
    for (let i = 0; i < enemy.count; i++) {
      const left = Panel.ENEMIES_X + i * 24
      
      this.addImage(enemy.image, left, 20)
      this.addText(enemy.health(i) || "X", left + 8, 41, {color:  'lightgreen', fontSize: 9, shadow: true, fontFamily: "UbuntuBold"})
    }
  } 
}
Panel.ENEMIES_X = 90
Panel.BACKGROUNDS = {
  0: "b030df03-56b9-4fe0-951a-a226b1caceac", // Outside
  1: "7b0715b6-5548-4fd8-992a-bc70736eab6f", // Level 1
  2: "7b0715b6-5548-4fd8-992a-bc70736eab6f", // Level 2
  3: "7b0715b6-5548-4fd8-992a-bc70736eab6f", // Level 3
  4: "7b0715b6-5548-4fd8-992a-bc70736eab6f", // Level 4
  FINAL: "7b0715b6-5548-4fd8-992a-bc70736eab6f", // Final Boss Level
}


// ------------------------------------------------------------------------------
// Game
class Game {
  constructor() {
    this.players = new Players()
    this.classes = new Classes()
    this.leaderboard = new Leaderboard()
    this.panel = new Panel()
    
    this.initLevels()
    this.currentLevelIndex = 0
    this.update()
  }
    
  get level() {
    return this.levels[this.currentLevelIndex]
  }
  
  update() {
    cb.drawPanel()
  }
  
  initLevels() {
    this.levels = [{enemy: new Enemy(0, 0), reward: null}]
        
    for (let i = 1; i < cb.settings.numLevels; i++) {
      this.addLevel(i)
    }
    
    this.addLevel("FINAL")
  }
  
  addLevel(id) {
    this.levels.push({
      enemy: new Enemy(id, cb.settings[`level${id}health`]),
      reward: cb.settings[`level${id}reward`],
    })
  }

  showLevels(player) {
    const lines = [title("Levels")]
    for (let i = 1; i < this.numLevels; i++) {
      const enemy = this.levels[i].enemy,
            reward = this.levels[i].reward            
      lines.push(`${i}) ${enemy.icon} ${enemy.name} (${enemy.type.name}) - ${enemy.healthsStr} (${enemy.totalHealthRemaining} total) - ${reward}`)
    }
    print(lines.join("\n"), {player: player})
  }
  
  delveDeeper() {
    this.currentLevelIndex += 1
    
    if (this.currentLevelIndex > this.levels.length) {
      this.model.setClass("FREED")
      print(`Having defeated the ${this.enemy.name}, and rescued ${cb.settings.levelFINALcaptive} ${this.model.icon} , the Dungeon Crawl is complete!`)
      print(`Rescued ${cb.settings.levelFINALcaptive}: ${this.reward}`, {background: "#f00", color: "#fff"})
      this.level = null
      cb.cancelTimeout(remindEvent)
    } else {
      if (this.currentLevelIndex === 1) {
        const boss = this.levels[this.levels.length - 1].enemy.name
        print(`Collecting all of our wits and valor, we delve into the dungeon, in order to rescue ${cb.settings.levelFINALcaptive} ${this.model.icon} from the ${boss}!`)
      } else {
        print(`Having defeated all foes on this level, we delve deeper into the dungeon!`)
        print(`Found ${this.reward}`, {background: "#f00", color: "#fff"})
      }
      const enemy = this.enemy,
            pronoun = (this.currentLevelIndex === this.levels.length - 1) ? "the" : "a",
            enemyName =`${enemy.count == 1 ? pronoun : enemy.count} ${enemy.count == 1 ? enemy.name : pluralize(enemy.name)}`
      
      print(`This level contains ${enemyName}!`)
    }
  }
  
  get model() {
    return this.player(cb.room_slug, false)
  }
  
  get enemy() {
    return this.level ? this.level.enemy : null
  }
  
  get reward() {
    return this.level ? this.level.reward : null
  }
  
  get isPlaying() {
    return this.enemy !== null
  }
  
  get numLevels() {
    return this.levels.length
  }
  
  drawPanel() {
    return this.panel.draw()
  }
  
  player(name, isMod) {
    return this.players.get(name, isMod)
  }
  
  klass(id) {
    return this.classes.get(id)
  }
  
  showHelp(player) {
    const s = cb.settings
    
    const lines = [
      title("Help"),
      `Initially, you are a lowly, level 1 ${this.klass("PEASANT").description}`,
      `Each time you earn ${cb.settings.xpToAdvance} XP, you gain a level!`,
      `You can change your class at any time, but you lose a level (i.e. -${cb.settings.xpToAdvance} XP)!`,
      `TIP ${s.costBarbarian} to become a ${this.klass("BARBARIAN").description} ${this.klass("BARBARIAN").icon('m')}`,
      `TIP ${s.costBard} to become a ${this.klass("BARD").description} ${this.klass("BARD").icon('m')}`,
      `TIP ${s.costDruid} to become a ${this.klass("DRUID").description} ${this.klass("DRUID").icon('m')}`,
      `TIP ${s.costKnight} to become a ${this.klass("KNIGHT").description} ${this.klass("KNIGHT").icon('m')}`,
      `TIP ${s.costPaladin} to become a ${this.klass("PALADIN").description} ${this.klass("PALADIN").icon('m')}`,
      `TIP ${s.costPriest} to become a ${this.klass("PRIEST").description} ${this.klass("PRIEST").icon('m')}`,
      `TIP ${s.costRanger} to become a ${this.klass("RANGER").description} ${this.klass("RANGER").icon('m')}`,
      `TIP ${s.costRogue} to become a ${this.klass("ROGUE").description} ${this.klass("ROGUE").icon('m')}`,
      `TIP ${s.costWizard} to become a ${this.klass("WIZARD").description} ${this.klass("WIZARD").icon('m')}`,
      "TIP any other amount to make attacks against the current foe or foes!",
      "/status - Get information about a class, bonuses, special abilities and XP",
      "/heros - Get information about who are the greatest heros (by XP)",
      "/hits - Get information about the best hits (by damage)",
      "/help - Get this message",
    ]
    
    if (player.isAdmin) {
      lines.push("/restart - restart the game (ADMIN ONLY)")
      lines.push("/levels - show what is on each level (ADMIN ONLY)")
      lines.push("/enemies - show all possible enemies by level (ADMIN ONLY)")
      lines.push("/faketip AMOUNT - tip effects without paying (ADMIN ONLY)")
      lines.push("/status NAME - Get information about a player's class, bonuses, special abilities and XP")
    }
    
    print(lines.join("\n"), {player: player})
  }
  
  performAttack(player, amount) {
    if (this.enemy.isDefeated) {
      this.delveDeeper()
    } else {
      this.enemy.removeDead()
    }
    
    const damage = player.attack(this.enemy, amount)
    
    this.leaderboard.record(player, damage)
    this.update()
  }
  
  showEnemies(player) {
    const lines = [title("Enemies")]
    
    for (let level of Object.keys(Enemy.levels)) {
      lines.push(`Level ${level}`)
      for (let enemy of Enemy.levels[level]) {
        lines.push(`:lemons_dc_enemy_${enemy.icon} ${enemy.name} x${enemy.count} (${enemy.type.name})`)
      }
    }
    
    print(lines.join("\n"), {player: player, background: "white", color: "black"})
  }
}


let game, remindDelayMs, remindEvent


// ------------------------------------------------------------------------------
// print()
const print = (message, {player=null, background=null, color=null, weight=null, to_group=null}={}) => {
  cb.sendNotice(message, (player ? player.name : null), background, color, weight, to_group)
}


// ------------------------------------------------------------------------------
// roll()
const roll = (sides, count=1) => {
  let total = 0
  for (let i = 0; i < count; i++) {
    total += Math.floor(Math.random() * sides) + 1
  }
  return total
}


// ------------------------------------------------------------------------------
const title = (label) => {
   return `--- Dungeon Crawl: ${label} ---`    
}


// ------------------------------------------------------------------------------
const reset = () => {
  game = new Game()
  remindEvent = cb.setTimeout(remind, remindDelayMs)
}


// ------------------------------------------------------------------------------
const remind = () => {
  cb.chatNotice("We are playing Dungeon Crawl by lemons_! (/help for instructions)")
  remindEvent = cb.setTimeout(remind, remindDelayMs)
}


// ------------------------------------------------------------------------------
const pluralize = (word) => {
  return `${word}${(word.endsWith("sh") || word.endsWith("s")) ? "es" : "s"}`
}


// ------------------------------------------------------------------------------
// onEnter()
cb.onEnter((user) => {
  if (!game.isPlaying) {
    return
  }
  
  print(`Welcome ${user.user}, we are playing Dungeon Crawl! (/help for instructions)`, {player: {name: user.user}})
})


// ------------------------------------------------------------------------------
// onStart()
cb.onStart((user) => {
  remindDelayMs = cb.settings.reminderDelayMinutes * 60 * 1000
  reset()
})


// ------------------------------------------------------------------------------
// onDrawPanel()
cb.onDrawPanel(() => {
  if (game) {
    return game.drawPanel()
  } else {
    return {
      template: "3_rows_of_labels",
    }
  }
})


// ------------------------------------------------------------------------------
// resolveTip()
const resolveTip = (amount, player) => {
  const s = cb.settings

  switch (amount) {
    case s.costRanger:
      player.setClass("RANGER")
      break
    case s.costKnight:
      player.setClass("KNIGHT")
      break
    case s.costWizard:
      player.setClass("WIZARD")
      break
    case s.costPriest:
      player.setClass("PRIEST")
      break
    case s.costRogue:
      player.setClass("ROGUE")
      break
    case s.costBarbarian:
      player.setClass("BARBARIAN")
      break
    case s.costPaladin:
      player.setClass("PALADIN")
      break
    case s.costBard:
      player.setClass("BARD")
      break
    case s.costDruid:
      player.setClass("DRUID")
      break
    default:
      game.performAttack(player, amount)
  } 
}


// ------------------------------------------------------------------------------
// onTip()
cb.onTip((tip) => {
  if (!game.isPlaying) {
    return
  }
  
  const amount = tip.amount
  const player = game.player(tip.from_user, tip.from_user_is_mod)
  
  resolveTip(amount, player)
})


// ------------------------------------------------------------------------------
// onMessage
cb.onMessage((msg) => {
  const message = msg.m
  const player = game.player(msg.user, msg.is_mod)
  const s = cb.settings,
        c = Class.config
  
  msg.m = `${player.icon} ${msg.m}`
 
  
  if (message === "/help") {
    game.showHelp(player)
    msg['X-Spam'] = true
  } else if (message === "/restart" && player.isAdmin) {
    reset()
    msg['X-Spam'] = true
  } else if (message === "/levels" && player.isAdmin) {
    game.showLevels(player)
    msg['X-Spam'] = true
  } else if (message === "/enemies" && player.isAdmin) {
    game.showEnemies(player)
    msg['X-Spam'] = true
  } else if (message.startsWith("/faketip") && player.isAdmin && game.isPlaying) {
    const amount = parseInt(message.slice("/faketip".length + 1))
    resolveTip(amount, player)
    msg['X-Spam'] = true
  } else if (message.startsWith("/status")) {
    if (player.isAdmin) {
      otherPlayer = game.player(message.slice("/status".length + 1))
      otherPlayer.display(player)
    } else {
      player.display(player)
    }
    msg['X-Spam'] = true
  } else if (message === "/heros" || message === "/heroes") {
    game.leaderboard.displayHeros(player)
    msg['X-Spam'] = true
  } else if (message === "/hits") {
    game.leaderboard.displayHits(player)
    msg['X-Spam'] = true
  }
  
  return msg
})


// ------------------------------------------------------------------------------
cb.settings_choices = [  
  {name: 'costBarbarian', type: 'int', minValue: 1, defaultValue: 61, label: "Token cost to become a Barbarian"},
  {name: 'costBard', type: 'int', minValue: 1, defaultValue: 62, label: "Token cost to become a Bard"},
  {name: 'costDruid', type: 'int', minValue: 1, defaultValue: 63, label: 'Token cost to become a Druid'},
  {name: 'costKnight', type: 'int', minValue: 1, defaultValue: 64, label: "Token cost to become a Knight"},
  {name: 'costPaladin', type: 'int', minValue: 1, defaultValue: 65, label: "Token cost to become a Paladin"},
  {name: 'costPriest', type: 'int', minValue: 1, defaultValue: 66, label: "Token cost to become a Priest"},
  {name: 'costRanger', type: 'int', minValue: 1, defaultValue: 67, label: "Token cost to become an Ranger"},
  {name: 'costRogue', type: 'int', minValue: 1, defaultValue: 68, label: "Token cost to become a Rogue"},
  {name: 'costWizard', type: 'int', minValue: 1, defaultValue: 69, label: "Token cost to become a Wizard"},
  
  {name: 'xpToAdvance', type: 'int', minValue: 1, defaultValue: 100, label: "XP (damage dealt) to advance level"},
  
  {name: 'level1health', type: 'int', required: false, minValue: 1, defaultValue: 250, label: "Health of level 1 foe(s)"},
  {name: 'level1reward', type: 'str', required: false, defaultValue: "Flask of Oil: Oil boobs!", label: "Treasure for defeating level 1"},
  
  {name: 'level2health', type: 'int', required: false, minValue: 1, defaultValue: 500, label: "Health of level 2 foe(s)"},
  {name: 'level2reward', type: 'str', required: false, defaultValue: "Fireball Scroll: Remove item of clothing!", label: "Treasure for defeating level 2"},

  {name: 'level3health', type: 'int', required: false, minValue: 1, defaultValue: 750, label: "Health of level 3 foe(s)"},
  {name: 'level3reward', type: 'str', required: false, defaultValue: "Scroll of Truesight: Get naked!", label: "Treasure for defeating level 3"},
  
  {name: 'level4health', type: 'int', required: false, minValue: 1, defaultValue: 1000, label: "Health of level 4 foe(s)"},
  {name: 'level4reward', type: 'str', required: false, defaultValue: "", label: "Treasure for defeating level 4"},
  
  {name: 'levelFINALhealth', type: 'int', minValue: 1, defaultValue: 2000, label: "Health of final level boss(es)"},
  {name: 'levelFINALreward', type: 'str', defaultValue: "Cum show!", label: "Reward for defeating final level"},
  {name: 'levelFINALcaptive', type: 'str', defaultValue: "Brian", label: "Name of person to be rescued"},
  
  {name: 'captiveGender', type: "choice", choice1: "m", choice2: "f", defaultValue: "f", label: "Gender of the captive (broadcaster)"},
  {name: 'leaderBoardSize', type: 'int', defaultValue: 8, minValue: 3, label: "Size of leaderboard (/heros list)"},
  
  {name: 'numLevels', type: 'int', defaultValue: 3, minValue: 1, maxValue: 5, label: "Number of levels (goals) including the final level (goal): 1-5"},
  
  {name: 'reminderDelayMinutes', type: 'int', defaultValue: 10, minValue: 1, label: "Remind users every X minutes"},
]