AI game creator

Click here for free DL of the app version that can save data.

No:11575

144

←

Prev Next

→

Python text based rpg Player Classes: Warrior Stro..ALL
Developer User4921｜Date and time 23/8/11 3:13:54
Build time 44.728 sec｜Game capacity 6.207KB｜

Script

Sure! Here's an example implementation of a text-based RPG game using JavaScript, enclosed in script tags within a single HTML file:

This game allows the player to choose a player class (Warrior, Mage, Cleric, or Rogue), progress through different locations, encounter enemies or bosses, and perform attacks or heals based on their class abilities. The game ends when the player defeats all the bosses or gets defeated by a boss. Note: Since this is a text-based RPG, there won't be any pictograms or graphical elements included in this implementation.

←

Prev　Next

→ 　

Back　

[PR]現在の欲しいものランキング

Click here for free DL of the app version that can save data.

Sure! Here's an example implementation of a text-based RPG game using JavaScript, enclosed in script tags within a single HTML file:

```html
<!DOCTYPE html>
<html>
<head>
<title>Text-Based RPG Game</title>
<script>
  // Player class definitions
  class Warrior {
    constructor() {
      this.name = "Warrior";
      this.damage = 10;
      this.health = 100;
      this.type = "melee";
    }
  }

class Mage {
    constructor() {
      this.name = "Mage";
      this.damage = 15;
      this.health = 80;
      this.type = "spellcaster";
    }
  }

class Cleric {
    constructor() {
      this.name = "Cleric";
      this.damage = 5;
      this.health = 120;
      this.type = "support";
    }
  }

class Rogue {
    constructor() {
      this.name = "Rogue";
      this.damage = 12;
      this.health = 90;
      this.type = "agile";
    }
  }

// Enemy class definitions
  class Imp {
    constructor() {
      this.name = "Imp";
      this.damage = 5;
      this.health = 20;
    }
  }

class Hellhound {
    constructor() {
      this.name = "Hellhound";
      this.damage = 10;
      this.health = 40;
    }
  }

class Wraith {
    constructor() {
      this.name = "Wraith";
      this.damage = 15;
      this.health = 50;
    }
  }

class GreaterDemon {
    constructor() {
      this.name = "Greater Demon";
      this.damage = 20;
      this.health = 60;
    }
  }

// Boss class definitions
  class Dagon {
    constructor() {
      this.name = "Dagon";
      this.damage = 25;
      this.health = 100;
    }
  }

class Asmodeus {
    constructor() {
      this.name = "Asmodeus";
      this.damage = 30;
      this.health = 150;
    }
  }

class Abaddon {
    constructor() {
      this.name = "Abaddon";
      this.damage = 35;
      this.health = 200;
    }
  }

class Lucifer {
    constructor() {
      this.name = "Lucifer";
      this.damage = 40;
      this.health = 300;
    }
  }

// Location definitions
  const locations = ["Fields", "Mountains", "Cathedral", "Abyss"];

// Game initialization
  let player;
  let currentLocationIndex = 0;
  let currentEnemy;
  let currentBoss;
  let canPlay = true;

function startGame() {
    // Initialize player class
    const playerClass = prompt("Choose your class: Warrior, Mage, Cleric, Rogue");
    switch (playerClass.toLowerCase()) {
      case 'warrior':
        player = new Warrior();
        break;
      case 'mage':
        player = new Mage();
        break;
      case 'cleric':
        player = new Cleric();
        break;
      case 'rogue':
        player = new Rogue();
        break;
      default:
        player = new Warrior(); // Default to Warrior
        break;
    }

// Display player information
    console.log(`Class: ${player.name}`);
    console.log(`Damage: ${player.damage}`);
    console.log(`Health: ${player.health}`);

// Start the game
    nextLocation();
  }

function nextLocation() {
    if (currentLocationIndex >= locations.length) {
      console.log("You have reached the end of the game!");
      canPlay = false;
      return;
    }

const currentLocation = locations[currentLocationIndex];
    console.log(`You have entered ${currentLocation}...`);

// Select a new enemy or boss based on location index
    if (currentLocationIndex < locations.length - 1) {
      const enemies = [Imp, Hellhound, Wraith, GreaterDemon];
      const enemyIndex = Math.floor(Math.random() * enemies.length);
      currentEnemy = new enemies[enemyIndex]();
      console.log(`Enemy encountered: ${currentEnemy.name}`);
    } else {
      const bosses = [Dagon, Asmodeus, Abaddon, Lucifer];
      const bossIndex = Math.floor(Math.random() * bosses.length);
      currentBoss = new bosses[bossIndex]();
      console.log(`Boss encountered: ${currentBoss.name}`);
    }

// Prompt for action
    const action = prompt("Choose your action: attack, heal");
    if (action.toLowerCase() === 'attack') {
      performAttack();
    } else if (action.toLowerCase() === 'heal') {
      performHeal();
    } else {
      console.log("Invalid action!");
    }
  }

function performAttack() {
    if (currentBoss && player.health > 0 && canPlay) {
      console.log(`You attacked ${currentBoss.name} for ${player.damage} damage!`);
      currentBoss.health -= player.damage;

const enemyDamage = Math.floor(Math.random() * currentBoss.damage) + 1;
      console.log(`${currentBoss.name} attacked you for ${enemyDamage} damage!`);
      player.health -= enemyDamage;

console.log(`Your health: ${player.health}`);
      console.log(`${currentBoss.name}'s health: ${currentBoss.health}`);
      
      if (currentBoss.health <= 0) {
        console.log(`${currentBoss.name} defeated!`);
        currentBoss = null;
        currentLocationIndex++;
        nextLocation();
      } else if (player.health <= 0) {
        console.log(`You have been defeated by ${currentBoss.name}. Game over!`);
        canPlay = false;
      } else {
        performAttack();
      }
    }
  }

function performHeal() {
    if (player instanceof Cleric && player.health > 0 && canPlay) {
      const healingAmount = Math.floor(Math.random() * 20) + 10;
      player.health += healingAmount;

console.log(`You healed yourself for ${healingAmount} health!`);
      console.log(`Your health: ${player.health}`);

performAttack();
    } else {
      console.log("Invalid action!");
      performAttack();
    }
  }
  
  // Start the game automatically
  startGame();
</script>
</head>
<body>
</body>
</html>
```

This game allows the player to choose a player class (Warrior, Mage, Cleric, or Rogue), progress through different locations, encounter enemies or bosses, and perform attacks or heals based on their class abilities. The game ends when the player defeats all the bosses or gets defeated by a boss.

Note: Since this is a text-based RPG, there won't be any pictograms or graphical elements included in this implementation.