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/Calculator.ts

@@ -0,0 +1,8 @@
+export class Calculator{
+    static random(min: number, max: number){
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    static isEven(number): boolean {
+        return number % 2 == 0;
+      }
+}

rpgsaga/saga/src/Character.ts

@@ -0,0 +1,41 @@
+import { Calculator } from "./Calculator";
+import { RandomName } from "./const";
+
+
+
+export class Сharacter {
+    protected health: number;
+    protected damage: number;
+    protected name: string;
+    protected maxHealth: number;
+
+    constructor() {
+        this.maxHealth = Calculator.random(100, 250);
+        this.damage = Calculator.random(10, 50);
+        this.name = RandomName[Calculator.random(0, RandomName.length-1)];
+        this.health = this.maxHealth;
+        this.lookchar();
+
+    }
+    public lookchar() {
+        console.log(`Name: ${this.name}, Health: ${this.health}, Damage: ${this.damage}`);
+    }
+    public getDamage(){
+        return this.damage;
+    }
+    public takeDamage(myDamage: number){
+        this.health -= myDamage;
+        console.log(`${this.name} получил ${myDamage} урона. Осталост ${this.health} здоровья.` );
+    }
+    public lookHears(){
+        return this.health;
+    }
+    public getName(){
+        return this.name;
+    }
+    public reHealth(){
+        this.health = this.maxHealth;
+    }
+
+}
+

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/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;
+}