RPG Saga

rpgsaga/saga/package.json

@@ -1,3 +1,6 @@
+
+
+
 {
   "name": "rpgsagats",
   "version": "1.0.0",

rpgsaga/saga/src/Calculater.ts

@@ -0,0 +1,15 @@
+export class Calculater {
+  static random(min: number, max: number): number {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+  }
+  static isEven(num: number): boolean {
+    return num % 2 === 0;
+  }
+  static booleanRandom(): boolean {
+    if (Math.random() < 0.5) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+}

rpgsaga/saga/src/Character.ts

@@ -0,0 +1,73 @@
+import { Calculater } from './Calculater';
+import { RandomName } from './Const';
+import { Logger } from './logger';
+
+export class Character {
+  protected healthProtected: number;
+  protected damageProtected: number;
+  protected maxHealthProtected: number;
+  protected nameProtected: string;
+  protected classProtected: string;
+  protected burnProtected: boolean;
+
+  constructor() {
+    this.maxHealthProtected = Calculater.random(100, 250);
+    this.damageProtected = Calculater.random(50, 100);
+    this.nameProtected = RandomName[Calculater.random(0, RandomName.length - 1)];
+    this.healthProtected = this.maxHealthProtected;
+    this.burnProtected = false;
+  }
+
+  public get health() {
+    return this.healthProtected;
+  }
+
+  get damage() {
+    return this.damageProtected;
+  }
+
+  get name() {
+    return this.nameProtected;
+  }
+
+  public get class(): string {
+    return this.classProtected;
+  }
+  public;
+
+  public get burn(): boolean {
+    return this.burnProtected;
+  }
+
+  public reHealth() {
+    this.healthProtected = this.maxHealthProtected;
+    this.burnProtected = false;
+  }
+
+  public turn(oponent: Character) {
+    this.burning();
+    if (Calculater.booleanRandom()) {
+      this.useSkill(oponent);
+    } else {
+      oponent.fightDamager(this.damage);
+      Logger.logFight(this, oponent);
+    }
+  }
+  public fightDamager(opDamager: number) {
+    this.healthProtected -= opDamager;
+  }
+
+  useSkill(oponent: Character) {
+    console.log(`Я тебя победюкаю, ${oponent.name}!`);
+  }
+
+  burnActive() {
+    this.burnProtected = true;
+  }
+  burning() {
+    if (this.burnProtected) {
+      this.healthProtected -= 10;
+      Logger.logBurn(this);
+    }
+  }
+}

rpgsaga/saga/src/Classes/Archer.ts

@@ -0,0 +1,19 @@
+import { Character } from '../Character';
+import { Logger } from '../logger';
+
+export class Archer extends Character {
+  constructor() {
+    super();
+    this.classProtected = 'Лучник';
+  }
+
+  override useSkill(oponent: Character): void {
+    if (oponent.burn) {
+      oponent.fightDamager(this.damage);
+      Logger.logFight(this, oponent);
+    } else {
+      Logger.logFireArrows(this);
+      oponent.burnActive();
+    }
+  }
+}

rpgsaga/saga/src/Classes/Knight.ts

@@ -0,0 +1,15 @@
+import { Character } from '../Character';
+import { Logger } from '../logger';
+
+export class Knight extends Character {
+  constructor() {
+    super();
+    this.classProtected = 'Рыцарь';
+  }
+
+  override useSkill(oponent: Character): void {
+    Logger.logKnightStrike(this);
+
+    oponent.fightDamager(this.damage + this.damage * 0.3);
+  }
+}

rpgsaga/saga/src/Classes/Mag.ts

@@ -0,0 +1,25 @@
+import { Character } from '../Character';
+import { Logger } from '../logger';
+
+export class Mag extends Character {
+  underProtectionFlag: boolean = false;
+
+  constructor() {
+    super();
+    this.classProtected = 'Ведьма';
+  }
+
+  override useSkill(oponent: Character): void {
+    Logger.logMagSkill(this, oponent);
+    this.underProtectionFlag = true;
+  }
+
+  override fightDamager(opDamager: number): void {
+    if (this.underProtectionFlag) {
+      Logger.logProteced(this);
+      this.underProtectionFlag = false;
+    } else {
+      this.healthProtected -= opDamager;
+    }
+  }
+}

rpgsaga/saga/src/Const.ts

@@ -0,0 +1,35 @@
+export const RandomName: string[] = [
+  'Astrid',
+  'Bjorn',
+  'Cecilia',
+  'Dagmar',
+  'Einar',
+  'Frida',
+  'Gudrun',
+  'Hans',
+  'Ingrid',
+  'Jesper',
+  'Kirsten',
+  'Lars',
+  'Mette',
+  'Nils',
+  'Ole',
+  'Pernille',
+  'Rasmus',
+  'Sofie',
+  'Torben',
+  'Ulla',
+  'Viggo',
+  'Willy',
+  'Xanthe',
+  'Yvonne',
+  'Zacharias',
+  'William',
+  'Erik',
+  'Lena',
+  'Lars',
+  'Mig',
+  'Morty',
+  'Rick',
+  'Сентябрь',
+];

rpgsaga/saga/src/index.ts

@@ -1 +1,107 @@
-console.log('Hello world');
+import * as readline from 'readline';
+
+import { Calculater } from './Calculater';
+import { Character } from './Character';
+import { Knight } from './Classes/Knight';
+import { Mag } from './Classes/Mag';
+import { Archer } from './Classes/Archer';
+import { Logger } from './logger';
+
+class Game {
+  players: Character[] = [];
+  winners: Character[] = [];
+
+  startGame() {
+    Logger.logStartGame();
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    rl.question('Введите кол-во игроков ', answer => {
+      if (Calculater.isEven(Number(answer))) {
+        const charNum: number = Number(answer);
+        this.generate(charNum);
+      } else {
+        Logger.logNotEvenGamers();
+      }
+      rl.close();
+    });
+  }
+
+  generate(numChar: number) {
+    for (let i: number = 0; i < numChar; i++) {
+      let person: Character;
+      const randomClass: number = Calculater.random(0, 2);
+      switch (randomClass) {
+        case 0:
+          person = new Mag();
+          break;
+
+        case 1:
+          person = new Knight();
+          break;
+        case 2:
+          person = new Archer();
+          break;
+      }
+      Logger.logRepresentation(person);
+      this.players.push(person);
+    }
+    this.sortPerson();
+  }
+  sortPerson() {
+    let countTurn = 1;
+    while (true) {
+      Logger.logCountTurn(countTurn);
+      countTurn = 1 + countTurn;
+
+      if (Calculater.isEven(this.players.length) === false) {
+        this.winners.push(this.players[0]);
+        this.players.splice(0, 1);
+      }
+      const sortNum: number = this.players.length;
+      for (let i = 0; i < sortNum / 2; i++) {
+        const num1: number = Calculater.random(0, this.players.length - 1);
+        const oponent1: Character = this.players[num1];
+        this.players.splice(num1, 1);
+        const num2: number = Calculater.random(0, this.players.length - 1);
+        const oponent2: Character = this.players[num2];
+        this.players.splice(num2, 1);
+        this.fight(oponent1, oponent2);
+      }
+      if (this.winners.length === 1) {
+        Logger.logWinWin(this.winners[0]);
+        break;
+      }
+
+      this.players.length = 0;
+      this.players = this.winners.slice();
+      this.winners.length = 0;
+      Logger.logOverTurn();
+    }
+  }
+  fight(oponent1: Character, oponent2: Character) {
+    let priority: boolean = true;
+    while (oponent1.health > 0 && oponent2.health > 0) {
+      if (priority) {
+        oponent1.turn(oponent2);
+      } else {
+        oponent2.turn(oponent1);
+      }
+      priority = !priority;
+    }
+    if (oponent1.health <= 0) {
+      oponent2.reHealth();
+      this.winners.push(oponent2);
+      Logger.logWinner(oponent2);
+    } else {
+      oponent1.reHealth();
+      this.winners.push(oponent1);
+      Logger.logWinner(oponent1);
+    }
+  }
+}
+
+const game = new Game();
+game.startGame();

rpgsaga/saga/src/lab1.ts

@@ -0,0 +1,26 @@
+export function taskA(start: number, finish: number, delta: number): number[] {
+  const slice: number[] = [];
+  for (let x = start; x <= finish; x += delta) {
+    slice.push(solution(x));
+  }
+  return slice;
+}
+
+export function taskB(long: number[]): number[] {
+  const answer: number[] = [];
+  for (const val of long) {
+    answer.push(solution(val));
+  }
+  return answer;
+}
+
+export function solution(x: number): number {
+  const result =
+    (Math.pow(Math.pow(x - 0.8, 2), drob(3.0)) + Math.pow(Math.abs(x + 0.4), drob(5.0))) /
+    Math.pow(Math.pow(x, 2) - Math.pow(0.8 + 0.4, 2), drob(9.0));
+  return result;
+}
+
+export function drob(y: number): number {
+  return 1 / y;
+}

rpgsaga/saga/src/logger.ts

@@ -0,0 +1,57 @@
+import { Character } from './Character';
+
+export class Logger {
+  static logStartGame() {
+    console.log('Игра началась');
+  }
+  static logNotEvenGamers() {
+    console.log('Введенно нечетное кол-во игроков. Игра не может начаться');
+  }
+  static logFight(oponent1: Character, oponent2: Character) {
+    console.log(
+      `${oponent1.name} ударил на ${oponent1.damage}. У ${oponent2.name} осталось ${oponent2.health} здоровья`,
+    );
+  }
+  static logRepresentation(person: Character) {
+    console.log(
+      `Я ${person.name} ${person.class}. У меня ${person.health} здоровья. И я бью на ${person.damage} урона!`,
+    );
+  }
+  static logBurn(oponent: Character) {
+    console.log(`${oponent.name} горю!`);
+  }
+  static logWinner(oponent: Character) {
+    console.log(`Победил ${oponent.name}`);
+  }
+
+  static logFireArrows(oponent: Character) {
+    console.log(
+      `${oponent.name} использует способность: ОГНЕННЫЕ СТРЕЛЫ. Поджигает противника. Теперь каждый ход противник теряет 10 здоровья`,
+    );
+  }
+
+  static logKnightStrike(oponent: Character) {
+    console.log(
+      `${oponent.name} использует способность: УДАР ВОЗМЕЗДИЯ. Наносит ${oponent.damage + oponent.damage * 0.3}`,
+    );
+  }
+
+  static logMagSkill(oponent: Character, oponent1) {
+    console.log(`${oponent.name} использует способность: ЗАВОРОЖЕНИЕ. Следующая аттака ${oponent1.name} не пройдет.`);
+  }
+
+  static logProteced(gamer: Character) {
+    console.log(`${gamer.name} под защитой!`);
+  }
+
+  static logWinWin(gamer: Character) {
+    console.log(`${gamer.name} победил!!!`);
+  }
+
+  static logCountTurn(countTurn: number) {
+    console.log(`${countTurn} раунд`);
+  }
+  static logOverTurn() {
+    console.log('Раунд закончился ');
+  }
+}