Task_TS RPG

rpgsaga/.gitignore

@@ -0,0 +1,7 @@
+node_modules/
+dist/
+coverage/
+.vite/
+*.log
+results.json
+.DS_Store

rpgsaga/package.json

@@ -14,7 +14,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.15.0",
-    "@types/node": "^22.10.0",
+    "@types/node": "^22.19.19",
     "eslint": "^9.15.0",
     "eslint-config-prettier": "^10.0.1",
     "eslint-plugin-prettier": "^5.5.5",
@@ -24,6 +24,6 @@
     "tsx": "^4.19.4",
     "typescript": "^5.7.2",
     "typescript-eslint": "^8.17.0",
-    "vitest": "^3.1.4"
+    "vitest": "^3.2.4"
   }
 }

rpgsaga/src/Task_TS/lab3.ts

@@ -0,0 +1,37 @@
+export function calculateY(x: number, a: number, b: number, alpha: number): number {
+  if (x > 5) {
+    const logVal = Math.log10(a * a + x);
+    return (logVal * logVal) / ((a + x) * (a + x));
+  } else {
+    return (a + b * x) ** 3.5 / (1.8 + Math.cos(alpha * x) ** 3);
+  }
+}
+
+export function TaskA(a: number, b: number, alpha: number, x_start: number, x_end: number, dx: number): string[] {
+  const results: string[] = [];
+  for (let x = x_start; x <= x_end; x += dx) {
+    const y = calculateY(x, a, b, alpha);
+    results.push(`x = ${x}, y = ${y}`);
+  }
+  return results;
+}
+
+export function TaskB(a: number, b: number, alpha: number, x_values: number[]): string[] {
+  const results: string[] = [];
+  for (let i = 0; i < x_values.length; i += 1) {
+    const x = x_values[i];
+    const y = calculateY(x, a, b, alpha);
+    results.push(`x${i + 1} = ${x}, y = ${y}`);
+  }
+  return results;
+}
+
+const a_val = 2.5;
+const b_val = 3.4;
+const alpha_val = 3.5;
+
+console.log("Задача А");
+console.log(TaskA(a_val, b_val, alpha_val, 1.2, 5.2, 0.8));
+
+console.log("\nЗадача Б");
+console.log(TaskB(a_val, b_val, alpha_val, [-2.5, 3.4, 3.5, 6.5, 0.6, 2.89, 3.54, 5.21, 6.28, 3.48]));

rpgsaga/src/Task_TS/lab4.ts

@@ -0,0 +1,37 @@
+export function calculateY(x: number, a: number, b: number, alpha: number): number {
+  if (x > 5) {
+    const logVal = Math.log10(a * a + x);
+    return (logVal * logVal) / ((a + x) * (a + x));
+  } else {
+    return (a + b * x) ** 3.5 / (1.8 + Math.cos(alpha * x) ** 3);
+  }
+}
+
+export function TaskA(a: number, b: number, alpha: number, x_start: number, x_end: number, dx: number): string[] {
+  const results: string[] = [];
+  for (let x = x_start; x <= x_end; x += dx) {
+    const y = calculateY(x, a, b, alpha);
+    results.push(`x = ${x}, y = ${y}`);
+  }
+  return results;
+}
+
+export function TaskB(a: number, b: number, alpha: number, x_values: number[]): string[] {
+  const results: string[] = [];
+  for (let i = 0; i < x_values.length; i += 1) {
+    const x = x_values[i];
+    const y = calculateY(x, a, b, alpha);
+    results.push(`x${i + 1} = ${x}, y = ${y}`);
+  }
+  return results;
+}
+
+const a_val = 2.5;
+const b_val = 3.4;
+const alpha_val = 3.5;
+
+console.log("Задача А");
+console.log(TaskA(a_val, b_val, alpha_val, 0.5, 7.0, 0.5));
+
+console.log("\nЗадача Б");
+console.log(TaskB(a_val, b_val, alpha_val, [-2.5, 3.4, 3.5, 6.5, 0.6, 2.89, 3.54, 5.21, 6.28, 3.48]));

rpgsaga/src/Task_TS/lab5.ts

@@ -0,0 +1,28 @@
+export class Computer {
+  brand: string;
+  model: string;
+  hdSize: number;
+
+  constructor(brand: string, model: string, hdSize: number) {
+    this.brand = brand;
+    this.model = model;
+    this.hdSize = hdSize;
+  }
+
+  setSize(size: number): void {
+    this.hdSize = size;
+  }
+
+  getSize(): number {
+    return this.hdSize;
+  }
+
+  print(): void {
+    console.log(`${this.brand} ${this.model} ${this.hdSize} GB`);
+  }
+}
+
+const pc = new Computer("Kraftway", "IC220", 512);
+pc.print();
+pc.setSize(1024);
+pc.print();

rpgsaga/src/factories/HeroFactory.ts

@@ -0,0 +1,41 @@
+import { Hero } from "../models/Hero";
+import { Knight } from "../models/Knight";
+import { Archer } from "../models/Archer";
+import { Mage } from "../models/Mage";
+
+const NAMES: string[] = ["Артур", "Гэндальф", "Эльдар", "Вильямс"];
+
+export class HeroFactory {
+    static createKnight(name: string, hp: number, strength: number): Knight {
+        return new Knight(name, hp, strength);
+    }
+
+    static createArcher(name: string, hp: number, strength: number): Archer {
+        return new Archer(name, hp, strength);
+    }
+
+    static createMage(name: string, hp: number, strength: number): Mage {
+        return new Mage(name, hp, strength);
+    }
+
+    static createRandomHeroes(count: number): Hero[] {
+        const heroes: Hero[] = [];
+        const types = ["Knight", "Archer", "Mage"];
+
+        for (let i = 0; i < count; i++) {
+            const type = types[Math.floor(Math.random() * 3)];
+            const name = NAMES[Math.floor(Math.random() * NAMES.length)];
+            const hp = Math.floor(Math.random() * 100) + 50;
+            const strength = Math.floor(Math.random() * 30) + 10;
+
+            if (type === "Knight") {
+                heroes.push(this.createKnight(name, hp, strength));
+            } else if (type === "Archer") {
+                heroes.push(this.createArcher(name, hp, strength));
+            } else {
+                heroes.push(this.createMage(name, hp, strength));
+            }
+        }
+        return heroes;
+    }
+}

rpgsaga/src/index.ts

@@ -1,18 +1,5 @@
-export function sum(a: number, b: number): number {
-  return a + b;
-}
+import { HeroFactory } from "./factories/HeroFactory";
+import { BattleService } from "./services/BattleService";
 
-// Example usage of the addNumbers function
-console.log("Hello world");
-
-// Adding two integers
-const result1 = sum(5, 3);
-console.log(`5 + 3 = ${result1}`);
-
-// Adding two floating-point numbers
-const result2 = sum(2.5, 3.7);
-console.log(`2.5 + 3.7 = ${result2}`);
-
-// Adding an integer and a floating-point number
-const result3 = sum(10, 4.2);
-console.log(`10 + 4.2 = ${result3}`);
+const heroes = HeroFactory.createRandomHeroes(4);
+BattleService.tournament(heroes);

rpgsaga/src/models/Archer.ts

@@ -0,0 +1,19 @@
+import { Hero } from "./Hero";
+
+export class Archer extends Hero {
+    private iceUsed: boolean = false;
+
+    getType(): string {
+        return "Лучник";
+    }
+
+    attack(): number {
+        let bonus = this.iceUsed ? 2 : 0;
+        return this.strength + bonus;
+    }
+
+    useAbility(): { damage: number; skipEnemyTurn: boolean } {
+        this.iceUsed = true;
+        return { damage: this.strength, skipEnemyTurn: false };
+    }
+}

rpgsaga/src/models/Hero.ts

@@ -0,0 +1,28 @@
+export abstract class Hero {
+    protected name: string;
+    protected hp: number;
+    protected strength: number;
+
+    constructor(name: string, hp: number, strength: number) {
+        this.name = name;
+        this.hp = hp;
+        this.strength = strength;
+    }
+
+    getName(): string { return this.name; }
+    getHp(): number { return this.hp; }
+    getStrength(): number { return this.strength; }
+    abstract getType(): string;
+
+    isAlive(): boolean {
+        return this.hp > 0;
+    }
+
+    takeDamage(amount: number): void {
+        this.hp = this.hp - amount;
+        if (this.hp < 0) this.hp = 0;
+    }
+
+    abstract attack(): number;
+    abstract useAbility(): { damage: number; skipEnemyTurn: boolean };
+}

rpgsaga/src/models/Knight.ts

@@ -0,0 +1,16 @@
+import { Hero } from "./Hero";
+
+export class Knight extends Hero {
+    getType(): string {
+        return "Рыцарь";
+    }
+
+    attack(): number {
+        return this.strength;
+    }
+
+    useAbility(): { damage: number; skipEnemyTurn: boolean } {
+        const damage = Math.floor(this.strength * 1.3);
+        return { damage, skipEnemyTurn: false };
+    }
+}

rpgsaga/src/models/Mage.ts

@@ -0,0 +1,18 @@
+import { Hero } from "./Hero";
+
+export class Mage extends Hero {
+    private charmUsed: boolean = false;
+
+    getType(): string {
+        return "Маг";
+    }
+
+    attack(): number {
+        return this.strength;
+    }
+
+    useAbility(): { damage: number; skipEnemyTurn: boolean } {
+        this.charmUsed = true;
+        return { damage: 0, skipEnemyTurn: true };
+    }
+}

rpgsaga/src/services/BattleService.ts

@@ -0,0 +1,62 @@
+import { Hero } from "../models/Hero";
+import { LoggerService } from "./LoggerService";
+
+export class BattleService {
+    static fight(hero1: Hero, hero2: Hero): Hero {
+        LoggerService.log(`\n(${hero1.getType()}) ${hero1.getName()} vs (${hero2.getType()}) ${hero2.getName()}`);
+
+        let turn = 0;
+        while (hero1.isAlive() && hero2.isAlive()) {
+            const attacker = turn % 2 === 0 ? hero1 : hero2;
+            const defender = turn % 2 === 0 ? hero2 : hero1;
+
+            const useAbility = Math.random() < 0.3;
+            let result;
+
+            if (useAbility) {
+                result = attacker.useAbility();
+                if (result.damage > 0) {
+                    LoggerService.log(`(${attacker.getType()}) ${attacker.getName()} использует способность и наносит ${result.damage} урона`);
+                } else {
+                    LoggerService.log(`(${attacker.getType()}) ${attacker.getName()} использует способность`);
+                }
+            } else {
+                const damage = attacker.attack();
+                result = { damage, skipEnemyTurn: false };
+                LoggerService.log(`(${attacker.getType()}) ${attacker.getName()} наносит ${damage} урона`);
+            }
+
+            defender.takeDamage(result.damage);
+
+            if (!defender.isAlive()) {
+                LoggerService.log(`(${defender.getType()}) ${defender.getName()} погибает`);
+                return attacker;
+            }
+
+            if (result.skipEnemyTurn) {
+                LoggerService.log(`(${defender.getType()}) ${defender.getName()} пропускает ход`);
+                turn++;
+            }
+            turn++;
+        }
+        return hero1.isAlive() ? hero1 : hero2;
+    }
+
+    static tournament(heroes: Hero[]): Hero {
+        let round = 1;
+        let players = [...heroes];
+
+        while (players.length > 1) {
+            LoggerService.log(`\n=== РАУНД ${round} ===`);
+            const winners: Hero[] = [];
+            for (let i = 0; i < players.length; i += 2) {
+                winners.push(this.fight(players[i], players[i + 1]));
+            }
+            players = winners;
+            round++;
+        }
+
+        LoggerService.log(`\n=== ПОБЕДИТЕЛЬ: (${players[0].getType()}) ${players[0].getName()} ===`);
+        return players[0];
+    }
+}

rpgsaga/src/services/LoggerService.ts

@@ -0,0 +1,16 @@
+export class LoggerService {
+    private static logs: string[] = [];
+
+    static log(message: string): void {
+        this.logs.push(message);
+        console.log(message);
+    }
+
+    static getLogs(): string[] {
+        return this.logs;
+    }
+
+    static clear(): void {
+        this.logs = [];
+    }
+}