index.js

class Person {
  constructor(name) {
    this.name = name;
    this.health = 100;
    this.defense = 10;
    this.attack = 10;
    this.inventory = {}; // item key: value
    this.partner = {}; //   partner key : value
  }
}

class Item {
  // creates items
  constructor(name, description, type, effect, quantity) {
    this.name = name;
    this.description = description;
    this.type = type;

    this.effect = effect;
    this.quantity = quantity;
  }
}

const water = new Item(
  `Water`,
  `A refreshing bottle of water that feels like magic to the soul. Some call it liquid healing. (+20HP)`,
  "healing",
  20,
  1
);
const energyDrink = new Item(
  `Energy Drink`,
  `A tall can of lightning in a bottle. It will give you energy but at what cost?(-10HP)`,
  "attacking",
  10,
  1
); //want to figure out how to have it also affect health
const seaMoss = new Item(
  `Sea Moss`,
  `A unique beverage acclaimed for it's health benefits. (+30HP)`,
  "healing",
  30,
  1
);

class Move {
  constructor(name, damage) {
    this.name = name;
    this.damage = damage;
  }
  effect(target) {
    target.health -= this.damage;
  }
}

const iceBlast = new Move("Ice Blast", 20);
const blobBuster = new Move("Blob Buster", 10);
const shadowSlash = new Move("Shadow Slash", 30);
const grassGun = new Move("Grass Gun", 50);
const lavaNuke = new Move("Lava Nuke", 80);
const mollyWhop = new Move("Molly Whop", 100);
const rainbowDestructor = new Move("Rainbow Destructor", 200);
const powerOfTheSun = new Move("Power of The Sun", 1000);

const globalMovePool = [
  iceBlast,
  blobBuster,
  shadowSlash,
  grassGun,
  lavaNuke,
  mollyWhop,
];

class GeneralMonster {
  constructor(name) {
    this.name = name;
    this.moveSet = [];
    this.item = [];
  }
  addMove() {
    // make sure global move pool exists
    if (!globalMovePool || globalMovePool.length === 0) {
      return null;
    }

    // pick random index from global move pool
    const randomIndex = Math.floor(Math.random() * globalMovePool.length);
    const selectedMove = globalMovePool[randomIndex]; // we get the randomly selected move

    // avoid duplicate moves so that the monster can't learn same move twice
    if (!this.moveSet.includes(selectedMove)) {
      this.moveSet.push(selectedMove);
      return selectedMove;
    }

    // if move already exists, try again so we use recursion
    return this.addMove();
  }
}

class EnemyMonster extends GeneralMonster {
  constructor(name, numMoves = 2) {
    super(name);
    this.health = 30;
    this.defense = 5;
    this.attack = 5;
    //give enemy random moves
    for (let i = 0; i < numMoves; i++) {
      this.addMove(); //addMove to give enemy random moves
    }
  }
}

class MonPal extends GeneralMonster {
  constructor(name, item, numMoves = 2) {
    super(name);
  }
}

const eIceBird = new EnemyMonster("IceBird", 2);
const eShadowBlobFish = new EnemyMonster("Shadow Blob", 2);
const eFireFossa = new EnemyMonster("fireFossa", 2);
const eIronPangolin = new EnemyMonster("Iron Pangolin", 2);

const fIceBird = new MonPal("IceBird", iceBlast);
const fShadowBlobFish = new MonPal("Shadow Blob", blobBuster);
const fFireFossa = new MonPal("fireFossa");

function exposition(player) {
  const scene =
    "The Valley of Choices lies before you: a land of shadowed ridges and dark rivers, where every path forks into risk and reward.";
  ("A mist coils at your feet and every sound-your breath, your heartbeat echoes louder than it should.");

  const storyMode =
    "Here, the valley tests not muscle, but decision. Every decision is a stone cast into the unseen depths. Attack recklessly, and you will get consumed.";
  ("Defend too often, and the shadows may close in.");
  ("Heal when you must, but the enemy will not wait.");
  ("For in this place, hesitation is death, and the courage is the only map.");

  const playerStory = `${player.name}, you are not just a wanderer. You are a spark against the dark.
Your body is steady and your health soars at ${player.health} points, your guard sharpened by survival and a defense of ${player.defense} points, your strikes are sharp starting with hits as high as ${player.attack} points.`;

  alert(scene);

  alert(storyMode);

  alert(playerStory);
}

function beginGame() {
  const gameGreeting = confirm(`Would you like to play a game?`);
  if (gameGreeting) {
    alert(
      `This world is full of suprises and will have you questioning your own abilities. Can you take on this journey on your own or will you need a little help from a friend? `
    );
    let name = prompt(`Awesome! What's your name?`);
    if (name) {
      alert(`Welcome to the World of MonPal, ${name}.`);
      // create the player
      const player = new Person(name);
      // insert exposition function to be invoked

      exposition(player);

      startFight(player, eIronPangolin);
    }
  } else {
    alert("Ok, bye...");
  }
}

function addItem(target, itemName, item) {
  if (!target.inventory[itemName]) {
    target.inventory[itemName] = item;
  } else {
    target.inventory[itemName].quantity += 1;
  }
}

function useItem(target, itemChoice) {
  const choice = target.inventory[itemChoice];

  if (!choice.type) {
    alert("not a choice.");
  }
  switch (choice.type) {
    case `healing`:
      target.health += choice.effect;
      alert(
        `You used ${choice.name}. It changed your health by ${choice.effect}. Your health is now ${target.health}.`
      );
      break;

    case `attacking`:
      target.attack += choice.effect;
      alert(
        `You used ${choice.name}. It changed your attack by ${choice.effect} Your attack is now ${target.attack}.`
      );
      break;

    default:
      // this.health += this.effect;
      alert(`I don't know this one...`);
  }
}

function startFight(player, enemy, remainingEnemies = []) {
  alert(
    `Before you set off on your journey an empty inventory is a path to failure. The best way to stay on top is to stay hydrated. You grab a bottle of water before you go. "Water" has been added to your inventory. `
  );

  addItem(player, "Water", water);

  alert(
    `Uh oh, looks like trouble! An angry ${enemy.name} has appeared and wants to fight. ${player.name}, your current health is ${player.health}.`
  );

  tempHealth = enemy.health;
  while (player.health > 0 && tempHealth > 0) {
    let itemOrFight = prompt(
      `How would you like to proceed? Type 1 to use item or Type 2 to fight.`
    );

    if (itemOrFight == "1") {
      let itemNames = Object.keys(player.inventory).join(",");

      let itemChoice = prompt(
        `What item would you like to use? ${JSON.stringify(itemNames)}`
      );

      if (player.inventory[itemChoice]) {
        useItem(player, itemChoice);

        alert(
          `Good Choice with ${itemChoice}! Your health is now ${player.health}.`
        );
      } else {
        alert(
          `That's not an item you have.You spent too much time searching for an item that doesn't exist. Your opponent is now attacking!`
        );
      }
    } else {
      let response = prompt(
        `How would you like to proceed? Type attack to hit your opponent.`
      );

      if (response === "attack") {
        let playerDamage = player.attack + 15 - enemy.defense; //(insert damage);

        tempHealth -= playerDamage;

        alert(
          `Nice job you hit ${enemy.name}, its defense is ${enemy.defense} and your attack does ${playerDamage} damage. Their health is now ${tempHealth}.`
        );

        if (tempHealth <= 0) {
          return endGame({ outcome: "win", player, enemy });

          // return; //or start new round
        }
      } else {
        alert(`It's really not the time for inaction, ${player.name}!`);
        //insert consequence
      }
    }
    //enemy begins

    alert(`Think fast! It's ${enemy.name} turn!`);

    let moveLength = enemy.moveSet.length - 1;
    let movePicker = Math.round(Math.random() * moveLength);
    let enemyMove = enemy.moveSet[movePicker].name;

    let enemyDamage =
      enemy.moveSet[movePicker].damage + enemy.attack - player.defense; //insert dmg

    alert(
      `Enemy uses ${enemyMove}, your defense is ${player.defense}, its attack is ${enemy.attack}, the move does ${enemy.moveSet[movePicker].damage} damage.`
    );

    player.health -= enemyDamage;

    alert(
      `Ouch, you got hit hard! and took ${enemyDamage} points of damage! Your health is now ${player.health}.`
    );

    // check if player is dead
    if (player.health <= 0) {
      return endGame({ outcome: "lose", player, enemy });
    }
  }
}

// Object.assign();

function symbioticRelationship(friendlyMon, player) {
  Object.assign();
}

// Pseudocode - Kish
function endGame({ outcome, player, enemy, remainingEnemies = [] }) {
  if (outcome === "win")
    alert(`You did it, ${player.name}! You defeated ${enemy.name}.`);

  //if there are more enemies, start the next battle
  if (remainingEnemies.length > 0) {
    const nextEnemy = remainingEnemies.shift();
    alert(`A new Enemy appears ${nextEnemy.name}! Prepare yourself!`);
    return startFight();
  }

  //No more enemies = Win
  //Ask the user if they want to replay
  const replay = confirm(
    outcome === "win"
      ? "Play again from the start?"
      : "Try again from the start"
  );

  //if yes, game has to restart from the existing entry flow
  if (replay) {
    beginGame();
  } else {
    alert("Thanks for playing!");
  }
}

beginGame();