fortnite-replay-analysis 1.0.5 → 1.0.8

package/README.md

@@ -1,56 +1,117 @@
 # Fortnite Replay Analysis
 
-Fortniteの `.replay` ファイルを解析して、試合中のプレイヤー情報やパーティごとの統計データを取得できるNode.jsモジュールです。
+Fortniteのリプレイファイルを解析して、プレイヤーデータを取得・集計・ソートできるNode.jsのモジュールです。
 
 ## 特徴
 
-* クロスプラットフォーム対応（Windows / Linux）
-* .NET製CLIバイナリとNode.jsで連携
-* Decimal.jsで高精度な生存時間計算
-* スコア集計、C6S3公式準拠の並び替え機能付き
+* OS判定してC#でビルドされた自己完結バイナリを呼び出すから、高速解析できる
+* botプレイヤーの除外や順位ソートなどオプション対応
+* 複数マッチのスコアをパーティ単位でマージして集計可能
+* 公式準拠でのスコアのソートも可能
 
 ## インストール
 
-```bash
-npm install fortnite-replay-analysis
+```
+npm install fortnite-replay-analysis@latest
 ```
 
-## 使用例
+## 使い方
 
 ```js
-const { ReplayAnalysis, sortScores, mergeScores } = require('fortnite-replay-analysis');
+const { ReplayAnalysis, mergeScores, sortScores, calculateScore } = require('fortnite-replay-analysis');
+
+(async () => {
+  try {
+    // 1試合分のリプレイ解析（返り値はJSON形式）
+    // rawPlayerData: 元の解析結果、生データ
+    // processedPlayerInfo: bot除外や順位ソート済みのプレイヤーデータ
+    const { rawPlayerData, processedPlayerInfo } = await ReplayAnalysis('./path/to/replayDir', { bot: false, sort: true });
+
+    console.log('Raw Data:', rawPlayerData);
+    console.log('Processed Player Info:', processedPlayerInfo);
+
+    // 解析結果のスコア配列を公式準拠のルールでソートも可能
+    const sortedScores = sortScores(processedPlayerInfo);
+
+    // 複数マッチの解析結果をまとめたいときは、
+    // sortScoresでソート済みの配列を複数用意して
+    // mergeScoresに配列の配列として渡す
+    const mergedScores = mergeScores([
+      sortedScores,    // 1試合目の結果
+      sortedScores2,   // 2試合目の結果
+      // ...
+    ]);
+
+    // マージ後の結果もsortScoresで再ソート可能
+    const finalSorted = sortScores(mergedScores);
+
+    console.log('Merged and Sorted:', finalSorted);
+
+  } catch (e) {
+    console.error(e);
+  }
+})();
+```
+
+## calculateScoreの使い方
+
+リプレイ解析済みの`ReplayAnalysis` の `result.processedPlayerInfo` を保存した JSON ファイル（ファイル名は任意でOK）から、大会形式のスコアを計算したいときに使える。
 
-// リプレイファイルのパスを指定して解析
-ReplayAnalysis('./match1.replay').then(({ processedPlayerInfo }) => {
-    console.log(processedPlayerInfo);
+```js
+const { calculateScore } = require('fortnite-replay-analysis');
+
+const score = await calculateScore({
+  matchDataPath: './output/matchA1/playerInfo.json',
+  points: {
+    1: 11, 2: 6, 3: 5, 4: 4, 5: 3,
+    6: 2, 7: 1, 8: 1, 9: 1, 10: 1
+  },
+  killPointMultiplier: 1,
+  killCountUpperLimit: 10
 });
+
+console.log(score);
 ```
 
-## 関数一覧
+## API
+
+### `ReplayAnalysis(replayFileDir, options)`
 
-### `ReplayAnalysis(replayFilePath: string, options?: { bot?: boolean, sort?: boolean }): Promise<{ rawPlayerData, processedPlayerInfo }>`
+* `replayFileDir`：リプレイファイルが入ったディレクトリのパス
+* `options`：
 
-* `.replay` ファイルを解析して、プレイヤーごとの詳細情報を取得
-* `bot`: Botプレイヤーを含めるかどうか（デフォルト: `false`）
-* `sort`: 順位でソートするか（デフォルト: `true`）
+  * `bot`（boolean）：botプレイヤーを結果に含めるか（デフォルトfalse）
+  * `sort`（boolean）：順位でソートするか（デフォルトtrue）
+* 返り値はPromiseで、`rawPlayerData`と`processedPlayerInfo`を含むオブジェクトを返す
 
-### `mergeScores(scoreArrays: ProcessedMatch[][]): MergedPartyResult[]`
+### `mergeScores(scoreArrays)`
 
-* 複数のマッチを統合してパーティ単位の統計を作成
+* 複数マッチのスコア配列をパーティ単位でマージする
+* 返り値はマージされたスコア配列
 
-### `sortScores(partyResults: MergedPartyResult[]): MergedPartyResult[]`
+### `sortScores(scoreArray)`
 
-* Fortnite公式基準でスコア順にソート（スコア → VictoryRoyale数 → 平均キル → 平均順位 → 生存時間）
+* 公式準拠のルールでスコアをソートする
+* 引数はマージ済みのスコア配列
 
-## 開発者向け
+### `calculateScore({ matchDataPath, points, killCountUpperLimit, killPointMultiplier })`
 
-* このパッケージは自己完結型の.NETバイナリを含みます（OSにより異なる）
-* 実行にはNode.js v22以上を推奨
+* `matchDataPath`：`ReplayAnalysis` の `result.processedPlayerInfo` を保存した JSON ファイルのパス（ファイル名は任意でOK）
+* `points`：順位に対するポイント設定（例：{ 1: 11, 2: 6, ... }）
+* `killCountUpperLimit`：キル数制限（nullで無制限）
+* `killPointMultiplier`：キル数倍率（例：1なら1キル1ポイント、2なら1キル2ポイント）
 
-## ライセンス
+## 動作環境
 
-MIT License
+* Node.js v22以上
+* Windows / Linux対応（Macは未対応）
+* C#で作られた自己完結バイナリが`CSproj/bin/Release/net8.0/`配下に同補されていること
 
-## リポジトリ
+## 注意事項
 
-[https://github.com/yuyutti/Fortnite_Replay_Analysis](https://github.com/yuyutti/Fortnite_Replay_Analysis)
+* リプレイファイルはディレクトリに1つ以上`.replay`ファイルが必要
+* ディレクトリ内に複数ファイルある場合は現状最初の1つのみ処理される
+* 何か問題起こっても俺は責任追わない
+* このリポジトリをフォークする際は、GitHubの「Fork」ボタンからフォークしてください。
+git cloneして新しく別リポジトリを作るのではなく、GitHub上のフォーク機能を使っていただけると、変更履歴を正しく追えます。
+ご協力よろしくお願いします！

package/index.js

@@ -77,7 +77,7 @@ function ReplayAnalysis(replayFileDir, { bot = false, sort = true } = {}) { // F
                         Placement: player.Placement,
                         Kills: player.Kills,
                         TeamKills: player.TeamKills,
-                        aliveTime: aliveTimeDecimal,  // Decimalオブジェクトのまま保持
+                        aliveTime: aliveTimeDecimal,
                         EpicId: player.EpicId,
                         PlayerName: player.PlayerName,
                         Platform: player.Platform,
@@ -103,6 +103,53 @@ function ReplayAnalysis(replayFileDir, { bot = false, sort = true } = {}) { // F
     });
 }
 
+async function calculateScore({ matchDataPath, points, killCountUpperLimit = null, killPointMultiplier = 1 } = {}) {
+    if (!matchDataPath || !fs.existsSync(matchDataPath)) {
+        throw new Error(`Match data file not found: ${matchDataPath}`);
+    }
+    if (!points || typeof points !== 'object' || Object.keys(points).length === 0) {
+        throw new Error('Points configuration is required and must be a non-empty object.');
+    }
+    if (killCountUpperLimit !== null && (typeof killCountUpperLimit !== 'number' || killCountUpperLimit < 0)) {
+        throw new Error('killCountUpperLimit must be a non-negative number or null.');
+    }
+
+    const playerInfo = JSON.parse(fs.readFileSync(path.join(matchDataPath), 'utf8'));
+    const partyScore = playerInfo.reduce((acc, player) => {
+        if (!acc[player.partyNumber]) {
+            const limitedKills = killCountUpperLimit == null
+                ? (player.TeamKills || 0)
+                : Math.min(player.TeamKills || 0, killCountUpperLimit);
+            acc[player.partyNumber] = {
+                partyPlacement: player.Placement,
+                partyNumber: player.partyNumber,
+                partyKills: limitedKills,
+                partyKillsNoLimit: player.TeamKills || 0,
+                partyScore: (points[player.Placement] ?? 0) + ((limitedKills) * killPointMultiplier),
+                partyPoint: points[player.Placement] ?? 0,
+                partyVictoryRoyale: player.Placement === 1,
+                partyKillsList: [],
+                partyAliveTimeList: [],
+                partyMemberList: [],
+                partyMemberIdList: [],
+            };
+        }
+    
+        // キル数の加算
+        acc[player.partyNumber].partyKillsList.push(player.Kills || 0);
+        acc[player.partyNumber].partyAliveTimeList.push(player.aliveTime || 0);
+        acc[player.partyNumber].partyMemberList.push(player.PlayerName);
+        acc[player.partyNumber].partyMemberIdList.push(player.EpicId);
+    
+        return acc;
+    }, {});
+    
+    let result = Object.values(partyScore);
+    result = sortScores(result);
+
+    return result;
+}
+
 function mergeScores(scoreArrays) { // 複数マッチの結果をマージしてパーティごとに集計
     const map = new Map();
     scoreArrays.forEach(scores =>
@@ -146,38 +193,47 @@ function mergeScores(scoreArrays) { // 複数マッチの結果をマージし
 }
 
 function sortScores(arr) { // 公式準拠のスコアソート関数
+    // リザルトとしてpoint, ビクロイ数, マッチ数, 平均撃破数, 平均順位, 合計生存時間を追加したい
+    if (!Array.isArray(arr) || arr.length === 0) return arr;
+
+    arr.forEach(p => {
+        const matchCount = (p.partyPlacementList || []).filter((placement, i, arr) =>
+            placement === 1 && p.partyNumber === (arr[i] || {}).partyNumber
+        ).length || 1;
+        p.result = {
+            point: p.partyScore || 0,
+            victoryCount: p.partyVictoryRoyaleCount ?? (p.partyVictoryRoyale ? 1 : 0),
+            matchCount,
+            avgKills: (p.partyKills || 0) / matchCount,
+            avgPlacement: (p.partyPlacementList && p.partyPlacementList.length > 0)
+                ? (p.partyPlacementList.reduce((s, x) => s + x, 0) / p.partyPlacementList.length)
+                : p.partyPlacement,
+            totalAliveTime: sumMaxAliveTime(p.partyAliveTimeList, p.partyAliveTimeByMatch),
+        };
+    });
+
     return arr.sort((a, b) => {
         // 1. 累計獲得ポイント
-        if (b.partyScore !== a.partyScore) {
-            return b.partyScore - a.partyScore;
+        if (b.result.point !== a.result.point) {
+            return b.result.point - a.result.point;
         }
         // 2. セッション中の累計 Victory Royale 回数
-        if (b.partyVictoryRoyaleCount !== a.partyVictoryRoyaleCount) {
-            return b.partyVictoryRoyaleCount - a.partyVictoryRoyaleCount;
+        if (b.result.victoryCount !== a.result.victoryCount) {
+            return b.result.victoryCount - a.result.victoryCount;
         }
 
-        // マッチ数（配置と生存時間の配列長を使う想定）
-        const aCount = (a.partyPlacementList || a.partyAliveTimeList || []).length || 1;
-        const bCount = (b.partyPlacementList || b.partyAliveTimeList || []).length || 1;
-
         // 3. 平均撃破数
-        const aAvgKills = (a.partyKills || 0) / aCount;
-        const bAvgKills = (b.partyKills || 0) / bCount;
-        if (bAvgKills !== aAvgKills) {
-            return bAvgKills - aAvgKills;
+        if (b.result.avgKills !== a.result.avgKills) {
+            return b.result.avgKills - a.result.avgKills;
         }
 
         // 4. 平均順位（小さいほうが上位）
-        const aAvgPlacement = (a.partyPlacementList || []).reduce((s, x) => s + x, 0) / aCount;
-        const bAvgPlacement = (b.partyPlacementList || []).reduce((s, x) => s + x, 0) / bCount;
-        if (aAvgPlacement !== bAvgPlacement) {
-            return aAvgPlacement - bAvgPlacement;
+        if (b.result.avgPlacement !== a.result.avgPlacement) {
+            return b.result.avgPlacement - a.result.avgPlacement;
         }
 
         // 5. 全マッチの合計生存時間
-        const aTime = sumMaxAliveTime(a.partyAliveTimeByMatch);
-        const bTime = sumMaxAliveTime(b.partyAliveTimeByMatch);
-        const cmp = bTime.comparedTo(aTime);
+        const cmp = b.result.totalAliveTime.comparedTo(a.result.totalAliveTime);
         if (cmp !== 0) return cmp;
 
         // 6. 最終手段：1マッチ目のパーティ番号が小さい順
@@ -185,17 +241,40 @@ function sortScores(arr) { // 公式準拠のスコアソート関数
     });
 }
 
-function sumMaxAliveTime(aliveTimeByMatch) {
-    return (Array.isArray(aliveTimeByMatch) ? aliveTimeByMatch : [])
-        .reduce((sum, match) => {
-            const times = Array.isArray(match.times) ? match.times : [new Decimal(0)];
-            const maxTime = times.reduce((max, t) => (t.comparedTo(max) > 0 ? t : max), new Decimal(0));
+function sumMaxAliveTime(partyAliveTimeList, partyAliveTimeByMatch) {
+    if (Array.isArray(partyAliveTimeByMatch) && partyAliveTimeByMatch.length > 0) {
+        // 複数マッチ分の最大値を足す処理
+        return partyAliveTimeByMatch.reduce((sum, match) => {
+            if (!Array.isArray(match.times) || match.times.length === 0) return sum;
+            const maxTime = match.times.reduce(
+                (max, t) => {
+                    const timeDec = new Decimal(t);
+                    return timeDec.greaterThan(max) ? timeDec : max;
+                },
+                new Decimal(0)
+            );
             return sum.plus(maxTime);
         }, new Decimal(0));
+    }
+
+    // こっちは単一マッチ用。配列の最大値返すだけ
+    if (Array.isArray(partyAliveTimeList) && partyAliveTimeList.length > 0) {
+        const maxVal = partyAliveTimeList.reduce(
+            (max, t) => {
+                const timeDec = new Decimal(t);
+                return timeDec.greaterThan(max) ? timeDec : max;
+            },
+            new Decimal(0)
+        );
+        return maxVal;
+    }
+
+    return new Decimal(0);
 }
 
 module.exports = {
     ReplayAnalysis,
+    calculateScore,
     sortScores,
     mergeScores
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fortnite-replay-analysis",
-  "version": "1.0.5",
+  "version": "1.0.8",
   "description": "Fortniteのリプレイ解析をNode.jsから呼べる自己完結型C#バイナリラッパー",
   "repository": {
     "type": "git",