duel log

data-manager/DataManager.js

@@ -11,6 +11,8 @@ const CloudReplayPlayer_1 = require("./entities/CloudReplayPlayer");
 const Ban_1 = require("./entities/Ban");
 const RandomDuelBan_1 = require("./entities/RandomDuelBan");
 const underscore_1 = __importDefault(require("underscore"));
+const DuelLog_1 = require("./entities/DuelLog");
+const DuelLogPlayer_1 = require("./entities/DuelLogPlayer");
 class DataManager {
     constructor(config, log) {
         this.config = config;
@@ -183,6 +185,85 @@ class DataManager {
             return null;
         }
     }
+    async getAllDuelLogs() {
+        const repo = this.db.getRepository(DuelLog_1.DuelLog);
+        try {
+            const allDuelLogs = await repo.find({ relations: ["players"] });
+            return allDuelLogs;
+        }
+        catch (e) {
+            this.log.warn(`Failed to fetch duel logs: ${e.toString()}`);
+            return [];
+        }
+    }
+    async getDuelLogFromId(id) {
+        const repo = this.db.getRepository(DuelLog_1.DuelLog);
+        try {
+            const duelLog = await repo.findOne(id, { relations: ["players"] });
+            return duelLog;
+        }
+        catch (e) {
+            this.log.warn(`Failed to fetch duel logs: ${e.toString()}`);
+            return null;
+        }
+    }
+    async getDuelLogFromRecoverSearch(realName) {
+        const repo = this.db.getRepository(DuelLog_1.DuelLog);
+        try {
+            const duelLogs = await repo.createQueryBuilder("duelLog")
+                .where("startDeckBuffer is not null and currentDeckBuffer is not null and roomMode != 2 and exists (select id from duel_log_player where duel_log_player.duelLogId = duelLog.id and duel_log_player.realName = :realName)", { realName })
+                .orderBy("duelLog.id", "DESC")
+                .limit(10)
+                .leftJoinAndSelect("duelLog.players", "player")
+                .getMany();
+            return duelLogs;
+        }
+        catch (e) {
+            this.log.warn(`Failed to fetch duel logs: ${e.toString()}`);
+            return null;
+        }
+    }
+    async getDuelLogJSON(tournamentModeSettings) {
+        const allDuelLogs = await this.getAllDuelLogs();
+        return allDuelLogs.map(duelLog => duelLog.getViewJSON(tournamentModeSettings));
+    }
+    async getAllReplayFilenames() {
+        const allDuelLogs = await this.getAllDuelLogs();
+        return allDuelLogs.map(duelLog => duelLog.replayFileName);
+    }
+    async clearDuelLog() {
+        const repo = this.db.getRepository(DuelLog_1.DuelLog);
+        try {
+            await repo.clear();
+        }
+        catch (e) {
+            this.log.warn(`Failed to clear duel logs: ${e.toString()}`);
+            return [];
+        }
+    }
+    async saveDuelLog(name, roomId, cloudReplayId, replayFilename, roomMode, duelCount, playerInfos) {
+        const duelLog = new DuelLog_1.DuelLog();
+        duelLog.name = name;
+        duelLog.time = moment_1.default().toDate();
+        duelLog.roomId = roomId;
+        duelLog.cloudReplayId = cloudReplayId;
+        duelLog.replayFileName = replayFilename;
+        duelLog.roomMode = roomMode;
+        duelLog.duelCount = duelCount;
+        const players = playerInfos.map(p => DuelLogPlayer_1.DuelLogPlayer.fromDuelLogPlayerInfo(p));
+        await this.db.transaction(async (mdb) => {
+            try {
+                const savedDuelLog = await mdb.save(duelLog);
+                for (let player of players) {
+                    player.duelLog = savedDuelLog;
+                }
+                await mdb.save(players);
+            }
+            catch (e) {
+                this.log.warn(`Failed to save duel log ${name}: ${e.toString()}`);
+            }
+        });
+    }
 }
 exports.DataManager = DataManager;
 //# sourceMappingURL=DataManager.js.map
\ No newline at end of file

data-manager/DataManager.ts

 import moment from "moment";
 import { Moment } from "moment";
 import bunyan from "bunyan";
-import { Connection, ConnectionOptions, createConnection, Transaction } from "typeorm";
+import {Connection, ConnectionOptions, createConnection, Transaction} from "typeorm";
 import { CloudReplay } from "./entities/CloudReplay";
 import { CloudReplayPlayer } from "./entities/CloudReplayPlayer";
 import { Ban } from "./entities/Ban";
 import {RandomDuelBan} from "./entities/RandomDuelBan";
 import _ from "underscore";
+import {DuelLog} from "./entities/DuelLog";
+import {Deck} from "./DeckEncoder";
+import {DuelLogPlayer} from "./entities/DuelLogPlayer";
 
-
-export interface CloudReplayPlayerInfo {
+interface BasePlayerInfo {
 	name: string;
-	key: string;
 	pos: number
 }
 
+export interface CloudReplayPlayerInfo extends BasePlayerInfo {
+	key: string;
+}
+
+export interface DuelLogPlayerInfo extends BasePlayerInfo {
+	realName: string;
+	startDeckBuffer: Buffer;
+	deck: Deck;
+	isFirst: boolean;
+	winner: boolean;
+	ip: string;
+	score: number;
+	lp: number;
+	cardCount: number;
+}
+
+
 export class DataManager {
 	config: ConnectionOptions;
 	ready: boolean;
@@ -158,7 +176,7 @@ export class DataManager {
 		}
 	}
 
-	async randomDuelBanPlayer(ip: string, reason: string, countadd?: number){
+	async randomDuelBanPlayer(ip: string, reason: string, countadd?: number) {
 		const count = countadd || 1;
 		const repo = this.db.getRepository(RandomDuelBan);
 		try {
@@ -191,4 +209,88 @@ export class DataManager {
 		}
 
 	}
+
+	async getAllDuelLogs() {
+		const repo = this.db.getRepository(DuelLog);
+		try {
+			const allDuelLogs = await repo.find({relations: ["players"]});
+			return allDuelLogs;
+		} catch (e) {
+			this.log.warn(`Failed to fetch duel logs: ${e.toString()}`);
+			return [];
+		}
+
+	}
+
+	async getDuelLogFromId(id: number) {
+		const repo = this.db.getRepository(DuelLog);
+		try {
+			const duelLog = await repo.findOne(id, {relations: ["players"]});
+			return duelLog;
+		} catch (e) {
+			this.log.warn(`Failed to fetch duel logs: ${e.toString()}`);
+			return null;
+		}
+
+	}
+
+	async getDuelLogFromRecoverSearch(realName: string) {
+		const repo = this.db.getRepository(DuelLog);
+		try {
+			const duelLogs = await repo.createQueryBuilder("duelLog")
+				.where("startDeckBuffer is not null and currentDeckBuffer is not null and roomMode != 2 and exists (select id from duel_log_player where duel_log_player.duelLogId = duelLog.id and duel_log_player.realName = :realName)", { realName })
+				.orderBy("duelLog.id", "DESC")
+				.limit(10)
+				.leftJoinAndSelect("duelLog.players", "player")
+				.getMany();
+			return duelLogs;
+		} catch (e) {
+			this.log.warn(`Failed to fetch duel logs: ${e.toString()}`);
+			return null;
+		}
+
+	}
+
+
+
+	async getDuelLogJSON(tournamentModeSettings: any) {
+		const allDuelLogs = await this.getAllDuelLogs();
+		return allDuelLogs.map(duelLog => duelLog.getViewJSON(tournamentModeSettings));
+	}
+	async getAllReplayFilenames() {
+		const allDuelLogs = await this.getAllDuelLogs();
+		return allDuelLogs.map(duelLog => duelLog.replayFileName);
+	}
+	async clearDuelLog() {
+		const repo = this.db.getRepository(DuelLog);
+		try {
+			await repo.clear();
+		} catch (e) {
+			this.log.warn(`Failed to clear duel logs: ${e.toString()}`);
+			return [];
+		}
+	}
+	async saveDuelLog(name: string, roomId: number, cloudReplayId: number, replayFilename: string, roomMode: number, duelCount: number, playerInfos: DuelLogPlayerInfo[]) {
+		const duelLog = new DuelLog();
+		duelLog.name = name;
+		duelLog.time = moment().toDate();
+		duelLog.roomId = roomId;
+		duelLog.cloudReplayId = cloudReplayId;
+		duelLog.replayFileName = replayFilename;
+		duelLog.roomMode = roomMode;
+		duelLog.duelCount = duelCount;
+		const players = playerInfos.map(p => DuelLogPlayer.fromDuelLogPlayerInfo(p));
+		await this.db.transaction(async (mdb) => {
+			try {
+				const savedDuelLog = await mdb.save(duelLog);
+				for (let player of players) {
+					player.duelLog = savedDuelLog;
+				}
+				await mdb.save(players);
+			} catch (e) {
+				this.log.warn(`Failed to save duel log ${name}: ${e.toString()}`);
+			}
+		});
+
+	}
 }

data-manager/DeckEncoder.js

+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeDeck = exports.encodeDeck = void 0;
+const assert_1 = __importDefault(require("assert"));
+function encodeDeck(deck) {
+    let pointer = 0;
+    const bufferSize = (2 + deck.main.length + deck.side.length) * 4;
+    const buffer = Buffer.allocUnsafe(bufferSize);
+    buffer.writeInt32LE(deck.main.length, pointer);
+    pointer += 4;
+    buffer.writeInt32LE(deck.side.length, pointer);
+    pointer += 4;
+    for (let cardCode of deck.main.concat(deck.side)) {
+        buffer.writeInt32LE(cardCode, pointer);
+        pointer += 4;
+    }
+    assert_1.default(pointer === bufferSize, `Invalid buffer size. Expected: ${bufferSize}. Got: ${pointer}`);
+    return buffer;
+}
+exports.encodeDeck = encodeDeck;
+function decodeDeck(buffer) {
+    let pointer = 0;
+    const mainLength = buffer.readInt32LE(pointer);
+    pointer += 4;
+    const sideLength = buffer.readInt32LE(pointer);
+    pointer += 4;
+    const correctBufferLength = (2 + mainLength + sideLength) * 4;
+    assert_1.default(buffer.length >= (2 + mainLength + sideLength) * 4, `Invalid buffer size. Expected: ${correctBufferLength}. Got: ${buffer.length}`);
+    const main = [];
+    const side = [];
+    for (let i = 0; i < mainLength; ++i) {
+        main.push(buffer.readInt32LE(pointer));
+        pointer += 4;
+    }
+    for (let i = 0; i < sideLength; ++i) {
+        side.push(buffer.readInt32LE(pointer));
+        pointer += 4;
+    }
+    return { main, side };
+}
+exports.decodeDeck = decodeDeck;
+//# sourceMappingURL=DeckEncoder.js.map
\ No newline at end of file

data-manager/DeckEncoder.ts

+import assert from "assert";
+
+export interface Deck {
+    main: number[];
+    side: number[];
+}
+
+export function encodeDeck(deck: Deck) {
+    let pointer = 0;
+    const bufferSize = (2 + deck.main.length + deck.side.length) * 4;
+    const buffer = Buffer.allocUnsafe(bufferSize);
+    buffer.writeInt32LE(deck.main.length, pointer);
+    pointer += 4;
+    buffer.writeInt32LE(deck.side.length, pointer);
+    pointer += 4;
+    for(let cardCode of deck.main.concat(deck.side)) {
+        buffer.writeInt32LE(cardCode, pointer);
+        pointer += 4;
+    }
+    assert(pointer === bufferSize, `Invalid buffer size. Expected: ${bufferSize}. Got: ${pointer}`);
+    return buffer;
+}
+
+export function decodeDeck(buffer: Buffer): Deck {
+    let pointer = 0;
+    const mainLength = buffer.readInt32LE(pointer);
+    pointer += 4;
+    const sideLength = buffer.readInt32LE(pointer);
+    pointer += 4;
+    const correctBufferLength = (2 + mainLength + sideLength) * 4;
+    assert(buffer.length >= (2 + mainLength + sideLength) * 4, `Invalid buffer size. Expected: ${correctBufferLength}. Got: ${buffer.length}`);
+    const main: number[] = [];
+    const side: number[] = [];
+    for(let i = 0; i < mainLength; ++i) {
+        main.push(buffer.readInt32LE(pointer));
+        pointer += 4;
+    }
+    for(let i = 0; i < sideLength; ++i) {
+        side.push(buffer.readInt32LE(pointer));
+        pointer += 4;
+    }
+    return {main, side};
+}
\ No newline at end of file

data-manager/entities/Ban.js

@@ -11,27 +11,24 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ban = void 0;
 const typeorm_1 = require("typeorm");
-let Ban = /** @class */ (() => {
-    let Ban = class Ban {
-    };
-    __decorate([
+let Ban = class Ban {
+};
+__decorate([
     typeorm_1.PrimaryGeneratedColumn({ unsigned: true, type: "bigint" }),
     __metadata("design:type", Number)
-    ], Ban.prototype, "id", void 0);
-    __decorate([
+], Ban.prototype, "id", void 0);
+__decorate([
     typeorm_1.Index(),
     typeorm_1.Column({ type: "varchar", length: 64, nullable: true }),
     __metadata("design:type", String)
-    ], Ban.prototype, "ip", void 0);
-    __decorate([
+], Ban.prototype, "ip", void 0);
+__decorate([
     typeorm_1.Index(),
     typeorm_1.Column({ type: "varchar", length: 20, nullable: true }),
     __metadata("design:type", String)
-    ], Ban.prototype, "name", void 0);
-    Ban = __decorate([
+], Ban.prototype, "name", void 0);
+Ban = __decorate([
     typeorm_1.Entity()
-    ], Ban);
-    return Ban;
-})();
+], Ban);
 exports.Ban = Ban;
 //# sourceMappingURL=Ban.js.map
\ No newline at end of file

data-manager/entities/Ban.ts

-import { Column, Entity, Index, PrimaryColumn, PrimaryGeneratedColumn } from "typeorm";
+import {Column, Entity, Index, PrimaryGeneratedColumn} from "typeorm";
 
 @Entity()
 export class Ban {

data-manager/entities/BasePlayer.js

+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePlayer = void 0;
+const typeorm_1 = require("typeorm");
+class BasePlayer {
+}
+__decorate([
+    typeorm_1.PrimaryGeneratedColumn({ unsigned: true, type: "bigint" }),
+    __metadata("design:type", Number)
+], BasePlayer.prototype, "id", void 0);
+__decorate([
+    typeorm_1.Column({ type: "varchar", length: 20 }),
+    __metadata("design:type", String)
+], BasePlayer.prototype, "name", void 0);
+__decorate([
+    typeorm_1.Column({ type: "tinyint" }),
+    __metadata("design:type", Number)
+], BasePlayer.prototype, "pos", void 0);
+exports.BasePlayer = BasePlayer;
+//# sourceMappingURL=BasePlayer.js.map
\ No newline at end of file

data-manager/entities/BasePlayer.ts

+import {Column, PrimaryGeneratedColumn} from "typeorm";
+
+export abstract class BasePlayer {
+    @PrimaryGeneratedColumn({unsigned: true, type: "bigint"})
+    id: number;
+
+    @Column({ type: "varchar", length: 20 })
+    name: string;
+
+    @Column({ type: "tinyint" })
+    pos: number;
+}
\ No newline at end of file

data-manager/entities/CloudReplay.js

@@ -17,8 +17,7 @@ const typeorm_1 = require("typeorm");
 const CloudReplayPlayer_1 = require("./CloudReplayPlayer");
 const underscore_1 = __importDefault(require("underscore"));
 const moment_1 = __importDefault(require("moment"));
-let CloudReplay = /** @class */ (() => {
-    let CloudReplay = class CloudReplay {
+let CloudReplay = class CloudReplay {
     fromBuffer(buffer) {
         this.data = buffer.toString("base64");
     }
@@ -36,27 +35,25 @@ let CloudReplay = /** @class */ (() => {
     getDisplayString() {
         return `R#${this.id} ${this.getPlayerNamesString()} ${this.getDateString()}`;
     }
-    };
-    __decorate([
+};
+__decorate([
     typeorm_1.PrimaryColumn({ unsigned: true, type: "bigint" }),
     __metadata("design:type", Number)
-    ], CloudReplay.prototype, "id", void 0);
-    __decorate([
+], CloudReplay.prototype, "id", void 0);
+__decorate([
     typeorm_1.Column({ type: "text" }),
     __metadata("design:type", String)
-    ], CloudReplay.prototype, "data", void 0);
-    __decorate([
+], CloudReplay.prototype, "data", void 0);
+__decorate([
     typeorm_1.Column({ type: "datetime" }),
     __metadata("design:type", Date)
-    ], CloudReplay.prototype, "date", void 0);
-    __decorate([
+], CloudReplay.prototype, "date", void 0);
+__decorate([
     typeorm_1.OneToMany(() => CloudReplayPlayer_1.CloudReplayPlayer, player => player.cloudReplay),
     __metadata("design:type", Array)
-    ], CloudReplay.prototype, "players", void 0);
-    CloudReplay = __decorate([
+], CloudReplay.prototype, "players", void 0);
+CloudReplay = __decorate([
     typeorm_1.Entity()
-    ], CloudReplay);
-    return CloudReplay;
-})();
+], CloudReplay);
 exports.CloudReplay = CloudReplay;
 //# sourceMappingURL=CloudReplay.js.map
\ No newline at end of file

data-manager/entities/CloudReplay.ts

-import { Column, Entity, OneToMany, PrimaryColumn } from "typeorm";
-import { CloudReplayPlayer } from "./CloudReplayPlayer";
+import {Column, Entity, OneToMany, PrimaryColumn} from "typeorm";
+import {CloudReplayPlayer} from "./CloudReplayPlayer";
 import _ from "underscore";
 import moment from "moment";
 

data-manager/entities/CloudReplayPlayer.js

@@ -8,13 +8,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var CloudReplayPlayer_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CloudReplayPlayer = void 0;
 const typeorm_1 = require("typeorm");
 const CloudReplay_1 = require("./CloudReplay");
-let CloudReplayPlayer = /** @class */ (() => {
-    var CloudReplayPlayer_1;
-    let CloudReplayPlayer = CloudReplayPlayer_1 = class CloudReplayPlayer {
+const BasePlayer_1 = require("./BasePlayer");
+let CloudReplayPlayer = CloudReplayPlayer_1 = class CloudReplayPlayer extends BasePlayer_1.BasePlayer {
     static fromPlayerInfo(info) {
         const p = new CloudReplayPlayer_1();
         p.key = info.key;
@@ -22,32 +22,18 @@ let CloudReplayPlayer = /** @class */ (() => {
         p.pos = info.pos;
         return p;
     }
-    };
-    __decorate([
-        typeorm_1.PrimaryGeneratedColumn({ unsigned: true, type: "bigint" }),
-        __metadata("design:type", Number)
-    ], CloudReplayPlayer.prototype, "id", void 0);
-    __decorate([
+};
+__decorate([
     typeorm_1.Index(),
     typeorm_1.Column({ type: "varchar", length: 40 }),
     __metadata("design:type", String)
-    ], CloudReplayPlayer.prototype, "key", void 0);
-    __decorate([
-        typeorm_1.Column({ type: "varchar", length: 20 }),
-        __metadata("design:type", String)
-    ], CloudReplayPlayer.prototype, "name", void 0);
-    __decorate([
-        typeorm_1.Column({ type: "tinyint" }),
-        __metadata("design:type", Number)
-    ], CloudReplayPlayer.prototype, "pos", void 0);
-    __decorate([
+], CloudReplayPlayer.prototype, "key", void 0);
+__decorate([
     typeorm_1.ManyToOne(() => CloudReplay_1.CloudReplay, replay => replay.players),
     __metadata("design:type", CloudReplay_1.CloudReplay)
-    ], CloudReplayPlayer.prototype, "cloudReplay", void 0);
-    CloudReplayPlayer = CloudReplayPlayer_1 = __decorate([
+], CloudReplayPlayer.prototype, "cloudReplay", void 0);
+CloudReplayPlayer = CloudReplayPlayer_1 = __decorate([
     typeorm_1.Entity()
-    ], CloudReplayPlayer);
-    return CloudReplayPlayer;
-})();
+], CloudReplayPlayer);
 exports.CloudReplayPlayer = CloudReplayPlayer;
 //# sourceMappingURL=CloudReplayPlayer.js.map
\ No newline at end of file

data-manager/entities/CloudReplayPlayer.ts

-import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn } from "typeorm";
-import { CloudReplayPlayerInfo } from "../DataManager";
-import { CloudReplay } from "./CloudReplay";
+import {Column, Entity, Index, ManyToOne} from "typeorm";
+import {CloudReplayPlayerInfo} from "../DataManager";
+import {CloudReplay} from "./CloudReplay";
+import {BasePlayer} from "./BasePlayer";
 
 @Entity()
-export class CloudReplayPlayer {
-	@PrimaryGeneratedColumn({unsigned: true, type: "bigint"})
-	id: number;
-
+export class CloudReplayPlayer extends BasePlayer {
 	@Index()
 	@Column({ type: "varchar", length: 40 })
 	key: string;
 
-	@Column({ type: "varchar", length: 20 })
-	name: string;
-
-	@Column({ type: "tinyint" })
-	pos: number;
-
 	@ManyToOne(() => CloudReplay, replay => replay.players)
 	cloudReplay: CloudReplay;
 

data-manager/entities/DuelLog.js

+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuelLog = void 0;
+const typeorm_1 = require("typeorm");
+const DuelLogPlayer_1 = require("./DuelLogPlayer");
+const moment_1 = __importDefault(require("moment"));
+const underscore_1 = __importDefault(require("underscore"));
+let DuelLog = class DuelLog {
+    getViewString() {
+        const viewPlayers = underscore_1.default.clone(this.players);
+        viewPlayers.sort((p1, p2) => p1.pos - p2.pos);
+        const playerString = viewPlayers[0].realName.split("$")[0] + (viewPlayers[2] ? "+" + viewPlayers[2].realName.split("$")[0] : "") + " VS " + (viewPlayers[1] ? viewPlayers[1].realName.split("$")[0] : "AI") + (viewPlayers[3] ? "+" + viewPlayers[3].realName.split("$")[0] : "");
+        return `<${this.id}> ${playerString} ${moment_1.default(this.time).format("YYYY-MM-DD HH-mm-ss")}`;
+    }
+    getViewJSON(tournamentModeSettings) {
+        const data = {
+            id: this.id,
+            time: moment_1.default(this.time).format("YYYY-MM-DD HH-mm-ss"),
+            name: this.name + (tournamentModeSettings.show_info ? " (Duel:" + this.duelCount + ")" : ""),
+            roomid: this.roomId,
+            cloud_replay_id: "R#" + this.cloudReplayId,
+            replay_filename: this.replayFileName,
+            roommode: this.roomMode,
+            players: this.players.map(player => {
+                return {
+                    pos: player.pos,
+                    is_first: player.isFirst === 1,
+                    name: player.name + (tournamentModeSettings.show_ip ? " (IP: " + player.ip.slice(7) + ")" : "") + (tournamentModeSettings.show_info && !(this.roomMode === 2 && player.pos % 2 > 0) ? " (Score:" + player.score + " LP:" + (player.lp != null ? player.lp : "???") + (this.roomMode !== 2 ? " Cards:" + (player.cardCount != null ? player.cardCount : "???") : "") + ")" : ""),
+                    winner: player.winner === 1
+                };
+            })
+        };
+    }
+};
+__decorate([
+    typeorm_1.PrimaryGeneratedColumn({ unsigned: true, type: "bigint" }),
+    __metadata("design:type", Number)
+], DuelLog.prototype, "id", void 0);
+__decorate([
+    typeorm_1.Column("datetime"),
+    __metadata("design:type", Date)
+], DuelLog.prototype, "time", void 0);
+__decorate([
+    typeorm_1.Index(),
+    typeorm_1.Column({ type: "varchar", length: 20 }),
+    __metadata("design:type", String)
+], DuelLog.prototype, "name", void 0);
+__decorate([
+    typeorm_1.Column("int"),
+    __metadata("design:type", Number)
+], DuelLog.prototype, "roomId", void 0);
+__decorate([
+    typeorm_1.Column("bigint"),
+    __metadata("design:type", Number)
+], DuelLog.prototype, "cloudReplayId", void 0);
+__decorate([
+    typeorm_1.Column({ type: "varchar", length: 256 }),
+    __metadata("design:type", String)
+], DuelLog.prototype, "replayFileName", void 0);
+__decorate([
+    typeorm_1.Column("tinyint", { unsigned: true }),
+    __metadata("design:type", Number)
+], DuelLog.prototype, "roomMode", void 0);
+__decorate([
+    typeorm_1.Column("tinyint", { unsigned: true }),
+    __metadata("design:type", Number)
+], DuelLog.prototype, "duelCount", void 0);
+__decorate([
+    typeorm_1.OneToMany(() => DuelLogPlayer_1.DuelLogPlayer, player => player.duelLog),
+    __metadata("design:type", Array)
+], DuelLog.prototype, "players", void 0);
+DuelLog = __decorate([
+    typeorm_1.Entity()
+], DuelLog);
+exports.DuelLog = DuelLog;
+//# sourceMappingURL=DuelLog.js.map
\ No newline at end of file

data-manager/entities/DuelLog.ts

+import {Column, Entity, Index, OneToMany, PrimaryGeneratedColumn} from "typeorm";
+import {DuelLogPlayer} from "./DuelLogPlayer";
+import moment from "moment";
+import _ from "underscore";
+import {DuelLogPlayerInfo} from "../DataManager";
+
+@Entity()
+export class DuelLog {
+    @PrimaryGeneratedColumn({unsigned: true, type: "bigint"})
+    id: number;
+
+    @Column("datetime")
+    time: Date;
+
+    @Index()
+    @Column({type: "varchar", length: 20})
+    name: string;
+
+    @Column("int")
+    roomId: number;
+
+    @Column("bigint")
+    cloudReplayId: number; // not very needed to become a relation
+
+    @Column({type: "varchar", length: 256})
+    replayFileName: string;
+
+    @Column("tinyint", {unsigned: true})
+    roomMode: number;
+
+    @Column("tinyint", {unsigned: true})
+    duelCount: number;
+
+    @OneToMany(() => DuelLogPlayer, player => player.duelLog)
+    players: DuelLogPlayer[];
+
+    getViewString() {
+        const viewPlayers = _.clone(this.players);
+        viewPlayers.sort((p1, p2) => p1.pos - p2.pos);
+        const playerString = viewPlayers[0].realName.split("$")[0] + (viewPlayers[2] ? "+" + viewPlayers[2].realName.split("$")[0] : "") + " VS " + (viewPlayers[1] ? viewPlayers[1].realName.split("$")[0] : "AI") + (viewPlayers[3] ? "+" + viewPlayers[3].realName.split("$")[0] : "");
+        return `<${this.id}> ${playerString} ${moment(this.time).format("YYYY-MM-DD HH-mm-ss")}`;
+    }
+
+    getViewJSON(tournamentModeSettings: any) {
+        const data = {
+            id: this.id,
+            time: moment(this.time).format("YYYY-MM-DD HH-mm-ss"),
+            name: this.name + (tournamentModeSettings.show_info ? " (Duel:" + this.duelCount + ")" : ""),
+            roomid: this.roomId,
+            cloud_replay_id: "R#" + this.cloudReplayId,
+            replay_filename: this.replayFileName,
+            roommode: this.roomMode,
+            players: this.players.map(player => {
+                return {
+                    pos: player.pos,
+                    is_first: player.isFirst === 1,
+                    name: player.name + (tournamentModeSettings.show_ip ? " (IP: " + player.ip.slice(7) + ")" : "") + (tournamentModeSettings.show_info && !(this.roomMode === 2 && player.pos % 2 > 0) ? " (Score:" + player.score + " LP:" + (player.lp != null ? player.lp : "???") + (this.roomMode !== 2 ? " Cards:" + (player.cardCount != null ? player.cardCount : "???") : "") + ")" : ""),
+                    winner: player.winner === 1
+                }
+            })
+        }
+    }
+}
\ No newline at end of file

data-manager/entities/DuelLogPlayer.js

+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var DuelLogPlayer_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuelLogPlayer = void 0;
+const typeorm_1 = require("typeorm");
+const BasePlayer_1 = require("./BasePlayer");
+const DuelLog_1 = require("./DuelLog");
+const DeckEncoder_1 = require("../DeckEncoder");
+let DuelLogPlayer = DuelLogPlayer_1 = class DuelLogPlayer extends BasePlayer_1.BasePlayer {
+    setStartDeck(deck) {
+        if (deck === null) {
+            this.startDeckBuffer = null;
+            return;
+        }
+        this.startDeckBuffer = DeckEncoder_1.encodeDeck(deck).toString("base64");
+    }
+    getStartDeck() {
+        return DeckEncoder_1.decodeDeck(Buffer.from(this.startDeckBuffer, "base64"));
+    }
+    setCurrentDeck(deck) {
+        if (deck === null) {
+            this.currentDeckBuffer = null;
+            return;
+        }
+        this.currentDeckBuffer = DeckEncoder_1.encodeDeck(deck).toString("base64");
+    }
+    getCurrentDeck() {
+        return DeckEncoder_1.decodeDeck(Buffer.from(this.currentDeckBuffer, "base64"));
+    }
+    static fromDuelLogPlayerInfo(info) {
+        const p = new DuelLogPlayer_1();
+        p.name = info.name;
+        p.pos = info.pos;
+        p.realName = info.realName;
+        p.lp = info.lp;
+        p.ip = info.ip;
+        p.score = info.score;
+        p.cardCount = info.cardCount;
+        p.isFirst = info.isFirst ? 1 : 0;
+        p.winner = info.winner ? 1 : 0;
+        p.startDeckBuffer = info.startDeckBuffer.toString("base64");
+        p.setCurrentDeck(info.deck);
+        return p;
+    }
+};
+__decorate([
+    typeorm_1.Index(),
+    typeorm_1.Column({ type: "varchar", length: 20 }),
+    __metadata("design:type", String)
+], DuelLogPlayer.prototype, "realName", void 0);
+__decorate([
+    typeorm_1.Column({ type: "varchar", length: 64, nullable: true }),
+    __metadata("design:type", String)
+], DuelLogPlayer.prototype, "ip", void 0);
+__decorate([
+    typeorm_1.Column("tinyint", { unsigned: true }),
+    __metadata("design:type", Number)
+], DuelLogPlayer.prototype, "isFirst", void 0);
+__decorate([
+    typeorm_1.Column("tinyint"),
+    __metadata("design:type", Number)
+], DuelLogPlayer.prototype, "score", void 0);
+__decorate([
+    typeorm_1.Column("int", { nullable: true }),
+    __metadata("design:type", Number)
+], DuelLogPlayer.prototype, "lp", void 0);
+__decorate([
+    typeorm_1.Column("smallint", { nullable: true }),
+    __metadata("design:type", Number)
+], DuelLogPlayer.prototype, "cardCount", void 0);
+__decorate([
+    typeorm_1.Column("text", { nullable: true }),
+    __metadata("design:type", String)
+], DuelLogPlayer.prototype, "startDeckBuffer", void 0);
+__decorate([
+    typeorm_1.Column("text", { nullable: true }),
+    __metadata("design:type", String)
+], DuelLogPlayer.prototype, "currentDeckBuffer", void 0);
+__decorate([
+    typeorm_1.Column("tinyint"),
+    __metadata("design:type", Number)
+], DuelLogPlayer.prototype, "winner", void 0);
+__decorate([
+    typeorm_1.ManyToOne(() => DuelLog_1.DuelLog, duelLog => duelLog.players),
+    __metadata("design:type", DuelLog_1.DuelLog)
+], DuelLogPlayer.prototype, "duelLog", void 0);
+DuelLogPlayer = DuelLogPlayer_1 = __decorate([
+    typeorm_1.Entity()
+], DuelLogPlayer);
+exports.DuelLogPlayer = DuelLogPlayer;
+//# sourceMappingURL=DuelLogPlayer.js.map
\ No newline at end of file

data-manager/entities/DuelLogPlayer.ts

+import {Column, Entity, Index, ManyToOne} from "typeorm";
+import {BasePlayer} from "./BasePlayer";
+import {DuelLog} from "./DuelLog";
+import {Deck} from "../DeckEncoder";
+import {decodeDeck, encodeDeck} from "../DeckEncoder";
+import {DuelLogPlayerInfo} from "../DataManager";
+
+@Entity()
+export class DuelLogPlayer extends BasePlayer {
+    @Index()
+    @Column({ type: "varchar", length: 20 })
+    realName: string;
+
+    @Column({ type: "varchar", length: 64, nullable: true })
+    ip: string;
+
+    @Column("tinyint", {unsigned: true})
+    isFirst: number;
+
+    @Column("tinyint")
+    score: number;
+
+    @Column("int", {nullable: true})
+    lp: number;
+
+    @Column("smallint", {nullable: true})
+    cardCount: number;
+
+    @Column("text", {nullable: true})
+    startDeckBuffer: string;
+
+    @Column("text", {nullable: true})
+    currentDeckBuffer: string;
+
+    @Column("tinyint")
+    winner: number;
+
+    setStartDeck(deck: Deck) {
+        if(deck === null) {
+            this.startDeckBuffer = null;
+            return;
+        }
+        this.startDeckBuffer = encodeDeck(deck).toString("base64");
+    }
+
+    getStartDeck() {
+        return decodeDeck(Buffer.from(this.startDeckBuffer, "base64"));
+    }
+
+    setCurrentDeck(deck: Deck) {
+        if(deck === null) {
+            this.currentDeckBuffer = null;
+            return;
+        }
+        this.currentDeckBuffer = encodeDeck(deck).toString("base64");
+    }
+
+    getCurrentDeck() {
+        return decodeDeck(Buffer.from(this.currentDeckBuffer, "base64"));
+    }
+
+    @ManyToOne(() => DuelLog, duelLog => duelLog.players)
+    duelLog: DuelLog;
+
+    static fromDuelLogPlayerInfo(info: DuelLogPlayerInfo) {
+        const p = new DuelLogPlayer();
+        p.name = info.name;
+        p.pos = info.pos;
+        p.realName = info.realName;
+        p.lp = info.lp;
+        p.ip = info.ip;
+        p.score = info.score;
+        p.cardCount = info.cardCount;
+        p.isFirst = info.isFirst ? 1 : 0;
+        p.winner = info.winner ? 1 : 0;
+        p.startDeckBuffer = info.startDeckBuffer.toString("base64");
+        p.setCurrentDeck(info.deck);
+        return p;
+    }
+}

data-manager/entities/RandomDuelBan.js

@@ -11,39 +11,36 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RandomDuelBan = void 0;
 const typeorm_1 = require("typeorm");
-let RandomDuelBan = /** @class */ (() => {
-    let RandomDuelBan = class RandomDuelBan {
+let RandomDuelBan = class RandomDuelBan {
     setNeedTip(need) {
         this.needTip = need ? 1 : 0;
     }
     getNeedTip() {
         return this.needTip > 0 ? true : false;
     }
-    };
-    __decorate([
+};
+__decorate([
     typeorm_1.PrimaryColumn({ type: "varchar", length: 64 }),
     __metadata("design:type", String)
-    ], RandomDuelBan.prototype, "ip", void 0);
-    __decorate([
+], RandomDuelBan.prototype, "ip", void 0);
+__decorate([
     typeorm_1.Column("datetime"),
     __metadata("design:type", Date)
-    ], RandomDuelBan.prototype, "time", void 0);
-    __decorate([
+], RandomDuelBan.prototype, "time", void 0);
+__decorate([
     typeorm_1.Column("smallint"),
     __metadata("design:type", Number)
-    ], RandomDuelBan.prototype, "count", void 0);
-    __decorate([
+], RandomDuelBan.prototype, "count", void 0);
+__decorate([
     typeorm_1.Column({ type: "simple-array" }),
     __metadata("design:type", Array)
-    ], RandomDuelBan.prototype, "reasons", void 0);
-    __decorate([
+], RandomDuelBan.prototype, "reasons", void 0);
+__decorate([
     typeorm_1.Column({ type: "tinyint", unsigned: true }),
     __metadata("design:type", Number)
-    ], RandomDuelBan.prototype, "needTip", void 0);
-    RandomDuelBan = __decorate([
+], RandomDuelBan.prototype, "needTip", void 0);
+RandomDuelBan = __decorate([
     typeorm_1.Entity()
-    ], RandomDuelBan);
-    return RandomDuelBan;
-})();
+], RandomDuelBan);
 exports.RandomDuelBan = RandomDuelBan;
 //# sourceMappingURL=RandomDuelBan.js.map
\ No newline at end of file