create employee class

rpgsaga/saga/src/constants.ts

@@ -0,0 +1,2 @@
+export const MAX_HEALTH = 100;
+export const MAX_POWER = 10;

rpgsaga/saga/src/game.ts

@@ -0,0 +1,91 @@
+import { Hero } from './heroes/hero';
+import { Messenger } from './messenger';
+import { getRandomInt } from './helpers/get-random-int';
+import { getRandomName } from './helpers/get-random-name';
+import { getRandomHero } from './helpers/get-random-hero';
+import { MAX_HEALTH, MAX_POWER } from './constants';
+
+export class Game {
+  messenger: Messenger;
+  private players: Hero[] = [];
+
+  constructor(private playersCount: number) {
+    this.messenger = new Messenger();
+  }
+
+  startGame() {
+    this.createPlayers();
+
+    while (this.players.length > 1) {
+      this.players.sort(() => Math.random() - 0.5);
+
+      const fightsCount = Math.floor(this.players.length / 2);
+      const names = this.players.map(player => player.name);
+
+      for (let i = 0; i < Math.floor(this.players.length / 2); i++) {
+        const firstHero = this.players[i];
+        const secondHero = this.players[i + fightsCount];
+        firstHero.refresh();
+        secondHero.refresh();
+
+        this.messenger.sendMessage(
+          `(${firstHero.heroName}) ${firstHero.name} vs (${secondHero.heroName}) ${secondHero.name}.`,
+        );
+        this.makeOneFight(firstHero, secondHero);
+      }
+
+      this.players = this.players.filter(player => player.health > 0);
+    }
+
+    this.messenger.sendMessage(`\n ${this.players[0].name} побеждает!`);
+  }
+
+  private createPlayers() {
+    const messenger = new Messenger();
+
+    for (let i = 0; i < this.playersCount; i++) {
+      const Hero = getRandomHero();
+      const name = getRandomName();
+      const health = getRandomInt(0, MAX_HEALTH);
+      const power = getRandomInt(0, MAX_POWER);
+
+      this.players.push(new Hero(health, power, name, messenger));
+    }
+  }
+
+  makeOneFight(firstHero: Hero, secondHero: Hero) {
+    const isFirstHeroStartFight = Math.random() < 0.5;
+
+    while (firstHero.health > 0 && secondHero.health > 0) {
+      if (isFirstHeroStartFight) {
+        this.makeOneAttack(firstHero, secondHero);
+
+        if (secondHero.health > 0) {
+          this.makeOneAttack(secondHero, firstHero);
+        }
+      } else {
+        this.makeOneAttack(secondHero, firstHero);
+
+        if (firstHero.health > 0) {
+          this.makeOneAttack(firstHero, secondHero);
+        }
+      }
+    }
+
+    const diedPlayer = firstHero.health <= 0 ? firstHero : secondHero;
+    diedPlayer.sendDieMessage();
+  }
+
+  private makeOneAttack(attackingHero: Hero, waitingHero: Hero) {
+    if (!attackingHero.isCanAttack) {
+      attackingHero.isCanAttack = true;
+      this.messenger.sendMessage(`${attackingHero.heroName}) ${attackingHero.name} пропускает ход`);
+    } else {
+      if (!attackingHero.usedAbility) {
+        attackingHero.useHeroAbility(waitingHero);
+      } else {
+        attackingHero.attack(waitingHero);
+      }
+    }
+  }
+}

rpgsaga/saga/src/helpers/get-random-hero.ts

@@ -0,0 +1,12 @@
+import { Archer } from '../heroes/archer';
+import { Knight } from '../heroes/knight';
+import { Mage } from '../heroes/mage';
+import { getRandomInt } from './get-random-int';
+
+const heroes = [Archer, Knight, Mage];
+
+export function getRandomHero() {
+  const randomIndex = getRandomInt(0, heroes.length - 1);
+
+  return heroes[randomIndex];
+}

rpgsaga/saga/src/helpers/get-random-int.ts

@@ -0,0 +1,3 @@
+export function getRandomInt(min: number, max: number) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}

rpgsaga/saga/src/helpers/get-random-name.ts

@@ -0,0 +1,23 @@
+import { getRandomInt } from './get-random-int';
+
+const names = [
+  'Dorian',
+  'Seren',
+  'Ronan',
+  'Elara',
+  'Lyraeth',
+  'Calder',
+  'Kaelan',
+  'Arwyn',
+  'Thorne',
+  'Seraphina',
+  'Galen',
+  'Eveline',
+  'Lillian',
+];
+
+export function getRandomName() {
+  const randomIndex = getRandomInt(0, names.length - 1);
+
+  return names[randomIndex];
+}

rpgsaga/saga/src/heroes/archer.ts

@@ -0,0 +1,28 @@
+import { Messenger } from '../messenger';
+import { Hero } from './hero';
+
+const ARROWS_DAMAGE = 2;
+
+export class Archer extends Hero {
+  heroName: string = 'Лучник';
+
+  constructor(health: number, power: number, name: string, messenger: Messenger) {
+    super(health, power, name, messenger);
+  }
+
+  attack(enemy: Hero) {
+    enemy.getDamage(this.usedAbility ? this.power + ARROWS_DAMAGE : this.power);
+    this.sendDamageMessage(enemy);
+  }
+
+  useHeroAbility(enemy: Hero) {
+    if (!this.usedAbility) {
+      enemy.getDamage(ARROWS_DAMAGE);
+      this.usedAbility = true;
+
+      this.messenger.sendMessage(
+        `(${this.heroName}) ${this.name} использует (Огненные стрелы) на игрока (${enemy.heroName}) ${enemy.name}, он загорается и теряет ${ARROWS_DAMAGE} единицы жизни.`,
+      );
+    }
+  }
+}

rpgsaga/saga/src/heroes/hero.ts

@@ -0,0 +1,35 @@
+import { Messenger } from '../messenger';
+
+export abstract class Hero {
+  abstract heroName: string;
+  usedAbility: boolean = false;
+  isCanAttack: boolean = true;
+
+  abstract useHeroAbility(enemy: Hero): void;
+
+  constructor(public health: number, public power: number, public name: string, public messenger: Messenger) {}
+
+  attack(enemy: Hero) {
+    enemy.getDamage(this.power);
+    this.sendDamageMessage(enemy);
+  }
+
+  getDamage(damage: number) {
+    this.health = this.health - damage;
+  }
+
+  refresh() {
+    this.usedAbility = false;
+    this.isCanAttack = true;
+  }
+
+  sendDamageMessage(enemy: Hero) {
+    this.messenger.sendMessage(
+      `(${this.heroName}) ${this.name} наносит урон ${this.power} противнику (${enemy.heroName}) ${enemy.name}.`,
+    );
+  }
+
+  sendDieMessage() {
+    this.messenger.sendMessage(`(${this.heroName}) ${this.name} погибает.`);
+  }
+}

rpgsaga/saga/src/heroes/knight.ts

@@ -0,0 +1,25 @@
+import { Messenger } from '../messenger';
+import { Hero } from './hero';
+
+const RETALIATION_STRIKE_INCREASE_DAMAGE_INDEX = 1.3;
+
+export class Knight extends Hero {
+  heroName: string = 'Рыцарь';
+
+  constructor(health: number, power: number, name: string, messenger: Messenger) {
+    super(health, power, name, messenger);
+  }
+
+  useHeroAbility(enemy: Hero) {
+    if (!this.usedAbility) {
+      enemy.getDamage(this.power * RETALIATION_STRIKE_INCREASE_DAMAGE_INDEX);
+      this.usedAbility = true;
+
+      this.messenger.sendMessage(
+        `(${this.heroName}) ${this.name} использует (Удар возмездия) и наносит урон ${
+          this.power * RETALIATION_STRIKE_INCREASE_DAMAGE_INDEX
+        } противнику (${enemy.heroName}) ${enemy.name}.`,
+      );
+    }
+  }
+}

rpgsaga/saga/src/heroes/mage.ts

@@ -0,0 +1,21 @@
+import { Messenger } from '../messenger';
+import { Hero } from './hero';
+
+export class Mage extends Hero {
+  heroName: string = 'Маг';
+
+  constructor(health: number, power: number, name: string, messenger: Messenger) {
+    super(health, power, name, messenger);
+  }
+
+  useHeroAbility(enemy: Hero) {
+    if (!this.usedAbility) {
+      this.usedAbility = true;
+      enemy.isCanAttack = false;
+
+      this.messenger.sendMessage(
+        `(${this.heroName}) ${this.name} использует (заворожение), противник (${enemy.heroName}) ${enemy.name} пропустит следующий ход.`,
+      );
+    }
+  }
+}

rpgsaga/saga/src/index.ts

@@ -1,16 +1,4 @@
-import { Phone } from './phone';
+import { Game } from './game';
 
-const first = new Phone('+7900-000 000 (123)', 1990, 'Телефон 1');
-first.year = 1998;
-
-first.year = -1998;
-first.call('12345');
-first.endCall();
-
-const second = new Phone('+799900000', -5);
-// second.name = 'Телефон 2';
-console.log(second.year);
-second.call('12345');
-second.endCall();
-
-console.log(first, second, Phone.phoneCount);
+const game = new Game(6);
+game.startGame();

rpgsaga/saga/src/messenger.ts

@@ -0,0 +1,5 @@
+export class Messenger {
+  sendMessage(message: string) {
+    console.log(message);
+  }
+}

rpgsaga/saga/tests/archer.test.ts

@@ -0,0 +1,31 @@
+import { Archer } from '../src/heroes/archer';
+import { Messenger } from '../src/messenger';
+
+describe('Archer', () => {
+  it('useHeroAbility test', () => {
+    const messenger = new Messenger();
+    const archer = new Archer(100, 20, 'archer', messenger);
+    const enemy = new Archer(100, 20, 'enemy', messenger);
+
+    const messengerFn = jest.spyOn(messenger, 'sendMessage');
+    const initialHealth = enemy.health;
+    archer.useHeroAbility(enemy);
+
+    expect(enemy.health).toBe(initialHealth - 2);
+    expect(archer.usedAbility).toBe(true);
+    expect(messengerFn).toHaveBeenCalledWith(
+      '(Лучник) archer использует (Огненные стрелы) на игрока (Лучник) enemy, он загорается и теряет 2 единицы жизни.',
+    );
+  });
+
+  it('attack test', () => {
+    const messenger = new Messenger();
+    const archer = new Archer(100, 20, 'archer', messenger);
+    const enemy = new Archer(100, 20, 'enemy', messenger);
+
+    const getDamageMock = jest.spyOn(enemy, 'getDamage');
+    archer.attack(enemy);
+
+    expect(getDamageMock).toHaveBeenCalledWith(archer.power);
+  });
+});

rpgsaga/saga/tests/game.test.ts

@@ -0,0 +1,25 @@
+import { Game } from '../src/game';
+import { Knight } from '../src/heroes/knight';
+import { Messenger } from '../src/messenger';
+
+const messenger = new Messenger();
+const game = new Game(4);
+
+describe('Game', () => {
+  it('battle test', () => {
+    const firstPlayer = new Knight(200, 20, 'firstPlayer', messenger);
+    const secondPlayer = new Knight(100, 10, 'secondPlayer', messenger);
+
+    const useFirstPlayerAbilityMock = jest.spyOn(firstPlayer, 'useHeroAbility');
+    const useSecondPlayerAbilityMock = jest.spyOn(secondPlayer, 'useHeroAbility');
+    const firstPlayerAttackMock = jest.spyOn(firstPlayer, 'attack');
+    const secondPlayerattackMock = jest.spyOn(secondPlayer, 'attack');
+
+    game.makeOneFight(firstPlayer, secondPlayer);
+
+    expect(useFirstPlayerAbilityMock).toHaveBeenCalled();
+    expect(useSecondPlayerAbilityMock).toHaveBeenCalled();
+    expect(firstPlayerAttackMock).toHaveBeenCalled();
+    expect(secondPlayerattackMock).toHaveBeenCalled();
+  });
+});

rpgsaga/saga/tests/knight.test.ts

@@ -0,0 +1,20 @@
+import { Knight } from '../src/heroes/knight';
+import { Messenger } from '../src/messenger';
+
+describe('Knight', () => {
+  it('useHeroAbility test', () => {
+    const messenger = new Messenger();
+    const knight = new Knight(100, 20, 'knight', messenger);
+    const enemy = new Knight(100, 20, 'enemy', messenger);
+
+    const messengerFn = jest.spyOn(messenger, 'sendMessage');
+    const initialHealth = enemy.health;
+    knight.useHeroAbility(enemy);
+
+    expect(knight.usedAbility).toBe(true);
+    expect(messengerFn).toHaveBeenCalledWith(
+      `(Рыцарь) knight использует (Удар возмездия) и наносит урон 26 противнику (Рыцарь) enemy.`,
+    );
+    expect(enemy.health).toBe(initialHealth - knight.power * 1.3);
+  });
+});

rpgsaga/saga/tests/mage.test.ts

@@ -0,0 +1,19 @@
+import { Mage } from '../src/heroes/mage';
+import { Messenger } from '../src/messenger';
+
+describe('Mage', () => {
+  it('useHeroAbility test', () => {
+    const messenger = new Messenger();
+    const mage = new Mage(100, 20, 'mage', messenger);
+    const enemy = new Mage(100, 20, 'enemy', messenger);
+
+    const messengerFn = jest.spyOn(messenger, 'sendMessage');
+    mage.useHeroAbility(enemy);
+
+    expect(enemy.isCanAttack).toBe(false);
+    expect(mage.usedAbility).toBe(true);
+    expect(messengerFn).toHaveBeenCalledWith(
+      `(Маг) mage использует (заворожение), противник (Маг) enemy пропустит следующий ход.`,
+    );
+  });
+});