Logger completed, needs redesign with action types

rpgsaga/saga/src/saga/actions.ts

@@ -0,0 +1,33 @@
+
+export abstract class Action{
+    name: string
+
+    constructor(name:string){
+        this.name = name;
+    }
+}
+
+export class Attack extends Action{
+    constructor(){
+        super("default attack")
+    }
+}
+
+export class AbilityAttack extends Action{
+    constructor(name: string){
+        super(name)
+    }
+}
+
+export class Ability extends Action{
+    constructor(name: string){
+        super(name)
+    }
+}
+
+export class State extends Action{
+    constructor(name: string){
+        super(name)
+    }
+}
+

rpgsaga/saga/src/saga/battle.ts

@@ -14,11 +14,14 @@ export class Battle {
     const logger = new ConsoleLogger(this.opponents[0], this.opponents[1], this.useLogger);
     logger.startLog();
     let currentTurn = randomBool();
+    let currentPlayer = this.opponents[currentTurn]
     while (this.opponents[0].health > 0 && this.opponents[1].health > 0) {
-      const res = this.opponents[currentTurn].act();
-      logger.actionLog(this.opponents[currentTurn], res);
+      const action = currentPlayer.act();
+      logger.actionLog(currentPlayer, action);
       currentTurn = currentTurn === 0 ? 1 : 0;
-      this.opponents[currentTurn].passTurn(res);
+      currentPlayer = this.opponents[currentTurn];
+      const res = currentPlayer.passTurn(action)
+      logger.stateLog(currentPlayer, res);
     }
     logger.endLog(this.opponents[0].health <= 0 ? this.opponents[0] : this.opponents[1]);
     return this.opponents[0].health <= 0 ? this.opponents[1] : this.opponents[0];

rpgsaga/saga/src/saga/classes.ts

@@ -1,3 +1,4 @@
+import { Ability, AbilityAttack } from './actions';
 import { Player, ActionResult } from './player';
 
 export class Knight extends Player {
@@ -6,7 +7,7 @@ export class Knight extends Player {
   }
 
   public ability(): ActionResult {
-    return new ActionResult(this.strength * 1.3, false, false, 'Удар возмездия');
+    return new ActionResult(this.strength * 1.3, false, false, new AbilityAttack('Удар возмездия'));
   }
 }
 
@@ -17,7 +18,7 @@ export class Mage extends Player {
   }
 
   public ability(): ActionResult {
-    return new ActionResult(0, false, true, 'Заворожение');
+    return new ActionResult(0, false, true, new Ability('Заворожение'));
   }
 }
 
@@ -28,6 +29,6 @@ export class Archer extends Player {
   }
 
   public ability(): ActionResult {
-    return new ActionResult(0, true, false, 'Огненные стрелы');
+    return new ActionResult(0, true, false, new Ability('Огненные стрелы'));
   }
 }

rpgsaga/saga/src/saga/logger.ts

@@ -1,77 +1,107 @@
-import { Player, ActionResult } from './player';
+import { Player, ActionResult, StateChange } from './player';
 
 export class ConsoleLogger {
-  player1: Player;
-  player2: Player;
-  isEnabled: boolean;
+    player1: Player;
+    player2: Player;
+    isEnabled: boolean;
 
-  constructor(player1: Player, player2: Player, enable: boolean) {
-    this.player1 = player1;
-    this.player2 = player2;
-    this.isEnabled = enable;
-  }
+    constructor(player1: Player, player2: Player, enable: boolean) {
+        this.player1 = player1;
+        this.player2 = player2;
+        this.isEnabled = enable;
+    }
 
-  public startLog() {
-    if (this.isEnabled) {
-      console.log(
-        '(%s) %s vs (%s) %s',
-        this.player1.constructor.name,
-        this.player1.name,
-        this.player2.constructor.name,
-        this.player2.name,
-      );
+    public startLog() {
+        if (this.isEnabled) {
+            console.log(
+                '(%s) %s vs (%s) %s',
+                this.player1.constructor.name,
+                this.player1.name,
+                this.player2.constructor.name,
+                this.player2.name,
+            );
+        }
     }
-  }
 
-  public actionLog(attacker: Player, input: ActionResult) {
-    if (this.isEnabled) {
-      const defender = this.player1 === attacker ? this.player2 : this.player1;
-      if (input.actionName === 'default attack') {
-        console.log(
-          '(%s) %s наносит урон %d противнику (%s) %s',
-          attacker.constructor.name,
-          attacker.name,
-          input.damage,
-          defender.constructor.name,
-          defender.name,
-        );
-      } else {
-        if (input.damage !== 0) {
-          console.log(
-            '(%s) %s использует (%s) и наносит урон %d противнику (%s) %s',
-            attacker.constructor.name,
-            attacker.name,
-            input.actionName,
-            input.damage,
-            defender.constructor.name,
-            defender.name,
-          );
-        } else {
-          console.log(
-            '(%s) %s использует (%s) на противнике (%s) %s',
-            attacker.constructor.name,
-            attacker.name,
-            input.actionName,
-            defender.constructor.name,
-            defender.name,
-          );
+    public actionLog(attacker: Player, input: ActionResult) {
+        if (this.isEnabled) {
+            const defender = this.player1 === attacker ? this.player2 : this.player1;
+            switch (input.action.constructor.name) {
+                case "Attack":
+                    console.log(
+                        '(%s) %s наносит урон %d противнику (%s) %s',
+                        attacker.constructor.name,
+                        attacker.name,
+                        input.damage,
+                        defender.constructor.name,
+                        defender.name,
+                    );
+                    break;
+                case "AbilityAttack":
+                    console.log(
+                        '(%s) %s использует (%s) и наносит урон %d противнику (%s) %s',
+                        attacker.constructor.name,
+                        attacker.name,
+                        input.action.name,
+                        input.damage,
+                        defender.constructor.name,
+                        defender.name,
+                    );
+                    break;
+                case "Ability":
+                    console.log(
+                        '(%s) %s использует (%s) на противнике (%s) %s',
+                        attacker.constructor.name,
+                        attacker.name,
+                        input.action.name,
+                        defender.constructor.name,
+                        defender.name,
+                    );
+                    break;
+                case "State":
+                    if (input.action.name === 'frozen') {
+                        console.log(
+                            '(%s) %s заморожен и не может двигаться',
+                            attacker.constructor.name,
+                            attacker.name
+                        );
+                    }
+
+                default:
+                    break;
+            }
         }
-      }
     }
-  }
 
-  public endLog(defeated: Player) {
-    if (this.isEnabled) {
-      console.log('(%s) %s погибает', defeated.constructor.name, defeated.name);
+    public stateLog(player: Player, input: StateChange) {
+        if (this.isEnabled) {
+            if (input.action.name === "unfrozen") {
+                console.log(
+                    '(%s) %s разморожен и готов атаковать',
+                    player.constructor.name,
+                    player.name
+                );
+            }
+        }
+    }
+
+    public endLog(defeated: Player) {
+        if (this.isEnabled) {
+            console.log('(%s) %s погибает\n', defeated.constructor.name, defeated.name);
+        }
     }
-  }
 
-  public logCurrentTournament(players: Array<Player>) {
-    if (this.isEnabled){
-        console.log("\n В турнире участвуют \n")
-        for (let i = 0; i < players.length; i++) {
-            console.log(players[i].name, " ")            
+    public logCurrentTournament(players: Array<Player>) {
+        if (this.isEnabled && players.length > 0) {
+            if (players.length > 1) {
+                console.log("\nВ турнире участвуют \n")
+                for (let i = 0; i < players.length; i++) {
+                    console.log(players[i].name, " ")
+                }
+            } else {
+                console.log("\nВ турнире побеждает \n")
+                console.log(players[0].name, " ")
+            }
         }
     }
-  }
 }

rpgsaga/saga/src/saga/player.ts

@@ -1,3 +1,5 @@
+import {Ability, Action, Attack, State} from "./actions"
+
 export abstract class Player {
     health: number;
     readonly maxHealth: number;
@@ -17,12 +19,12 @@ export abstract class Player {
     }
 
     public attack(): ActionResult {
-        return new ActionResult(this.strength, false, false, 'default attack');
+        return new ActionResult(this.strength, false, false, new Attack());
     }
 
     public ability(): ActionResult {
         // when no ability, return null
-        return new ActionResult(0, false, false, 'debug ability');
+        return new ActionResult(0, false, false, new Ability('debug ability'));
     }
 
     public act(): ActionResult {
@@ -33,23 +35,27 @@ export abstract class Player {
                 return this.ability();
             }
         } else{
-            return new ActionResult(0,false,false, "frozen")
+            return new ActionResult(0,false,false, new State("frozen"))
         }
     }
-    public passTurn(input: ActionResult) {
+    public passTurn(input: ActionResult): StateChange {
+        const res = new StateChange(0, false,false, new State(""))
         this.health -= input.damage;
         if (this.isFrozenCounter === 0) {
             if (input.setEffectFreeze) {
                 this.isFrozenCounter = 1;
             }
         } else {
             this.isFrozenCounter -= 1;
+            res.isFrosenCancelled = true;
+            res.action = new State("unfrozen")
         }
         if (this.isBurned) {
             this.health -= 2;
         } else {
             this.isBurned = input.setEffectBurn;
         }
+        return res;
     }
 
     fullHeal(){
@@ -61,13 +67,27 @@ export class ActionResult {
     damage: number;
     setEffectFreeze: boolean;
     setEffectBurn: boolean;
-    actionName = '';
+    action: Action;
 
-    constructor(damage: number, burn: boolean, freeze: boolean, name: string) {
+    constructor(damage: number, burn: boolean, freeze: boolean, action: Action) {
         this.damage = damage;
         this.setEffectFreeze = freeze;
         this.setEffectBurn = burn;
-        this.actionName = name;
+        this.action = action;
+    }
+}
+
+export class StateChange{
+    isBurnedCancelled: boolean;
+    isFrosenCancelled: boolean;
+    pointsHealed: number;
+    action : Action;
+
+    constructor(hpAdded: number, burn: boolean, frozen: boolean, action: Action){
+        this.pointsHealed = hpAdded;
+        this.isBurnedCancelled = burn;
+        this.isFrosenCancelled = frozen;
+        this.action = action;
     }
 }