fortnite-replay-analysis 1.0.8 → 1.1.0

package/README.md

@@ -1,117 +1,112 @@
 # Fortnite Replay Analysis
 
-Fortniteのリプレイファイルを解析して、プレイヤーデータを取得・集計・ソートできるNode.jsのモジュールです。
+FortniteのリプレイファイルをNode.jsで解析し、プレイヤーデータを取得・集計・ソートできるモジュールです。
 
 ## 特徴
 
-* OS判定してC#でビルドされた自己完結バイナリを呼び出すから、高速解析できる
-* botプレイヤーの除外や順位ソートなどオプション対応
-* 複数マッチのスコアをパーティ単位でマージして集計可能
-* 公式準拠でのスコアのソートも可能
+* OS判定でビルド済みの自己完結バイナリを呼び出し、高速に解析できます。
+* botプレイヤーの除外や順位ソートのオプションに対応しています。
+* 複数マッチのスコアをパーティ単位でマージして集計できます。
+* 公式準拠のルールでスコアをソートできます。
 
 ## インストール
 
-```
+```bash
 npm install fortnite-replay-analysis@latest
 ```
 
 ## 使い方
 
+以下は、1試合のリプレイ解析からスコア計算、複数マッチのマージまでを実行する例です。
+
 ```js
-const { ReplayAnalysis, mergeScores, sortScores, calculateScore } = require('fortnite-replay-analysis');
+const {
+    ReplayAnalysis,
+    calculateScore,
+    sortScores,
+    mergeScores
+} = require('fortnite-replay-analysis');
 
 (async () => {
-  try {
-    // 1試合分のリプレイ解析（返り値はJSON形式）
-    // rawPlayerData: 元の解析結果、生データ
-    // processedPlayerInfo: bot除外や順位ソート済みのプレイヤーデータ
-    const { rawPlayerData, processedPlayerInfo } = await ReplayAnalysis('./path/to/replayDir', { bot: false, sort: true });
+    // リプレイ解析（ディレクトリ指定時は最初に見つけた .replay を処理、ファイル指定時はそのファイルを使用）
+    const {
+        rawReplayData,
+        rawPlayerData,
+        processedPlayerInfo
+    } = await ReplayAnalysis(
+        './path/to/replayDirOrFile',
+        { 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試合目の結果
-      // ...
-    ]);
+    // ポイント＆キル計算
+    const score = await calculateScore({
+        matchData: processedPlayerInfo,
+        points: { 1: 11, 2: 6, 3: 5, 4: 4, 5: 3, 6: 2 },
+        killCountUpperLimit: 10,      // 省略可能、デフォルト null（無制限）
+        killPointMultiplier: 1        // 1撃破あたりの倍率（1の場合1撃破1pt, 2の場合1撃破2ポイント）、省略可能、デフォルト 1
+    });
 
-    // マージ後の結果もsortScoresで再ソート可能
-    const finalSorted = sortScores(mergedScores);
+    console.log('Score:', score);
 
-    console.log('Merged and Sorted:', finalSorted);
+    // 複数マッチのマージと再ソート
+    const merged = mergeScores([ sortedScores, sortedScores2 ]);
+    const finalSorted = sortScores(merged);
 
-  } catch (e) {
-    console.error(e);
-  }
+    console.log('Merged & Sorted:', finalSorted);
 })();
 ```
 
-## calculateScoreの使い方
-
-リプレイ解析済みの`ReplayAnalysis` の `result.processedPlayerInfo` を保存した JSON ファイル（ファイル名は任意でOK）から、大会形式のスコアを計算したいときに使える。
-
-```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(inputPath, options)`
 
-* `replayFileDir`：リプレイファイルが入ったディレクトリのパス
-* `options`：
+* `inputPath`: .replayファイルがあるディレクトリまたはファイルのパス
+* `options`（省略可）:
 
-  * `bot`（boolean）：botプレイヤーを結果に含めるか（デフォルトfalse）
-  * `sort`（boolean）：順位でソートするか（デフォルトtrue）
-* 返り値はPromiseで、`rawPlayerData`と`processedPlayerInfo`を含むオブジェクトを返す
+  * `bot`（boolean）: botプレイヤーを含めるか（デフォルト: `false`）
+  * `sort`（boolean）: 順位でソートするか（デフォルト: `true`）
+* 戻り値: Promise<{
+  rawReplayData: Object,
+  rawPlayerData: Array,
+  processedPlayerInfo: Array
+  }>
 
-### `mergeScores(scoreArrays)`
+### `calculateScore({ matchData, points, killCountUpperLimit, killPointMultiplier })`
 
-* 複数マッチのスコア配列をパーティ単位でマージする
-* 返り値はマージされたスコア配列
+* `matchData`: `ReplayAnalysis`の`processedPlayerInfo`配列、またはそのJSONファイルへのパス
+* `points`: 順位ごとのポイント設定オブジェクト（例: `{1:11,2:6,...}`）
+* `killCountUpperLimit`: キル数の上限（省略可能、デフォルト: `null` で無制限）
+* `killPointMultiplier`: 1撃破あたりの倍率（1の場合1撃破1pt, 2の場合1撃破2ポイント）、省略可能、デフォルト: `1`
+* 戻り値: Promise（パーティごとの集計結果）
 
 ### `sortScores(scoreArray)`
 
-* 公式準拠のルールでスコアをソートする
-* 引数はマージ済みのスコア配列
+* 公式準拠のルールでスコアをソートして返します。
+* 引数: `calculateScore`や`mergeScores`の戻り値として得られる配列
+* ソート順:
 
-### `calculateScore({ matchDataPath, points, killCountUpperLimit, killPointMultiplier })`
+  1. 累計ポイント降順
+  2. Victory Royale 回数降順
+  3. 平均撃破数降順
+  4. 平均順位昇順
+  5. 合計生存時間降順
+  6. 最初のパーティ番号昇順
 
-* `matchDataPath`：`ReplayAnalysis` の `result.processedPlayerInfo` を保存した JSON ファイルのパス（ファイル名は任意でOK）
-* `points`：順位に対するポイント設定（例：{ 1: 11, 2: 6, ... }）
-* `killCountUpperLimit`：キル数制限（nullで無制限）
-* `killPointMultiplier`：キル数倍率（例：1なら1キル1ポイント、2なら1キル2ポイント）
-
-## 動作環境
+### `mergeScores(scoreArrays)`
 
-* Node.js v22以上
-* Windows / Linux対応（Macは未対応）
-* C#で作られた自己完結バイナリが`CSproj/bin/Release/net8.0/`配下に同補されていること
+* 複数マッチ分のスコア配列をパーティ単位でマージします。
+* 引数: ソート済みスコア配列の配列（例: `[sorted1, sorted2, ...]`）
+* 戻り値: マージ後のスコア配列
 
 ## 注意事項
 
-* リプレイファイルはディレクトリに1つ以上`.replay`ファイルが必要
-* ディレクトリ内に複数ファイルある場合は現状最初の1つのみ処理される
-* 何か問題起こっても俺は責任追わない
-* このリポジトリをフォークする際は、GitHubの「Fork」ボタンからフォークしてください。
-git cloneして新しく別リポジトリを作るのではなく、GitHub上のフォーク機能を使っていただけると、変更履歴を正しく追えます。
-ご協力よろしくお願いします！
+* ディレクトリ指定時は最初に見つけた `.replay` を処理します。
+* 直接ファイルを指定した場合はそのファイルを処理し、`.replay` が存在しない場合でも最初に見つけたものを使用します。
+* 問題が発生しても責任は負いかねます。
+* フォークする場合はGitHubのFork機能を利用し、履歴を追いやすくしてください。

package/index.js

@@ -17,24 +17,27 @@ function getBinaryPath() { // OS判定して自己完結バイナリの実行フ
     }
 }
 
-function ReplayAnalysis(replayFileDir, { bot = false, sort = true } = {}) { // Fortniteのリプレイファイルを解析してプレイヤーデータを返す
+function ReplayAnalysis(inputPath, { bot = false, sort = true } = {}) { // Fortniteのリプレイファイルを解析してプレイヤーデータを返す
     return new Promise((resolve, reject) => {
 
-        let replayFiles;
+        let replayFilePath;
+
         try {
-            replayFiles = fs.readdirSync(replayFileDir).filter(f => f.endsWith('.replay'));
+            const stat = fs.statSync(inputPath);
+            if (stat.isDirectory()) {
+                const replayFiles = fs.readdirSync(inputPath).filter(f => f.endsWith('.replay'));
+                if (replayFiles.length === 0) {
+                    return reject(new Error(`No .replay files found in directory: ${inputPath}`));
+                }
+                replayFilePath = path.join(inputPath, replayFiles[0]);
+            } else if (stat.isFile()) {
+                replayFilePath = inputPath;
+            } else {
+                return reject(new Error(`Invalid input path: ${inputPath}`));
+            }
         } catch (e) {
-            reject(new Error(`Failed to read directory: ${e.message}`));
-            return;
+            return reject(new Error(`Failed to access path: ${e.message}`));
         }
-
-        if (replayFiles.length === 0) {
-            reject(new Error(`No replay file found in directory: ${replayFileDir}`));
-            return;
-        }
-
-        // とりあえず1個目のファイルを処理（複数ある場合は要拡張）
-        const replayFilePath = path.join(replayFileDir, replayFiles[0]);
         const binPath = getBinaryPath();
 
         execFile(binPath, [replayFilePath], (error, stdout, stderr) => {
@@ -46,8 +49,17 @@ function ReplayAnalysis(replayFileDir, { bot = false, sort = true } = {}) { // F
                 console.warn(`Warning: ${stderr}`);
             }
 
+            let parsed;
+            try {
+                parsed = JSON.parse(stdout);
+            } catch (jsonErr) {
+                reject(new Error(`JSON parse error: ${jsonErr.message}`));
+                return;
+            }
+
+            const playerData = parsed.PlayerData;
+
             try {
-                const playerData = JSON.parse(stdout);
 
                 if (!Array.isArray(playerData)) {
                     reject(new Error(`Unexpected JSON format: playerData is not an array.`));
@@ -94,7 +106,9 @@ function ReplayAnalysis(replayFileDir, { bot = false, sort = true } = {}) { // F
                 }
 
                 resolve({
-                    rawPlayerData: playerData, processedPlayerInfo: filteredAndSortedPlayerInfo,
+                    rawReplayData: parsed,
+                    rawPlayerData: playerData,
+                    processedPlayerInfo: filteredAndSortedPlayerInfo
                 });
             } catch (jsonErr) {
                 reject(new Error(`JSON parse error: ${jsonErr.message}`));
@@ -103,18 +117,24 @@ 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.');
+async function calculateScore({ matchData, points, killCountUpperLimit = null, killPointMultiplier = 1 } = {}) {
+    if (!matchData) throw new Error('matchData is required');
+
+    let playerInfo;
+    if (typeof matchData === 'string') {
+        if (!fs.existsSync(matchData)) throw new Error(`Match data path does not exist: ${matchData}`);
+        const rawData = fs.readFileSync(matchData, 'utf8');
+        try {
+            playerInfo = JSON.parse(rawData);
+        } catch (e) {
+            throw new Error(`Failed to parse JSON from file: ${e.message}`);
+        }
     }
-    if (killCountUpperLimit !== null && (typeof killCountUpperLimit !== 'number' || killCountUpperLimit < 0)) {
-        throw new Error('killCountUpperLimit must be a non-negative number or null.');
+    else if (Array.isArray(matchData)) playerInfo = matchData;
+    else {
+        throw new Error('matchData must be either a file path (string) or parsed JSON array');
     }
 
-    const playerInfo = JSON.parse(fs.readFileSync(path.join(matchDataPath), 'utf8'));
     const partyScore = playerInfo.reduce((acc, player) => {
         if (!acc[player.partyNumber]) {
             const limitedKills = killCountUpperLimit == null
@@ -157,39 +177,38 @@ function mergeScores(scoreArrays) { // 複数マッチの結果をマージし
             const key = JSON.stringify([...p.partyMemberIdList].sort());
             if (!map.has(key)) {
                 map.set(key, {
-                    partyPlacement: null,
-                    partyNumber: p.partyNumber,
                     partyScore: p.partyScore,
                     partyPoint: p.partyPoint,
                     partyKills: p.partyKills,
-                    partyMemberList: [...p.partyMemberList],
-                    matchList: [p.matchName],
+                    partyKillsNoLimit: p.partyKillsNoLimit,
                     partyVictoryRoyaleCount: p.partyVictoryRoyale ? 1 : 0,
+                    matchList: [p.matchName],
+                    partyMemberList: [...p.partyMemberList],
                     partyAliveTimeByMatch: [
                         { match: p.matchName, times: [...(p.partyAliveTimeList || [])] }
                     ],
-                    partyPlacementList: [p.partyPlacement]
+                    partyPlacementList: [p.partyPlacement],
+                    matchs: { [p.matchName]: { ...p } }
                 });
             } else {
                 const ex = map.get(key);
-                ex.matchList.push(p.matchName);
                 ex.partyScore              += p.partyScore;
-                ex.partyKills              += p.partyKills;
                 ex.partyPoint              += p.partyPoint;
+                ex.partyKills              += p.partyKills;
+                ex.partyKillsNoLimit       += p.partyKillsNoLimit;
                 ex.partyVictoryRoyaleCount += p.partyVictoryRoyale ? 1 : 0;
+                ex.matchList.push(p.matchName);
                 ex.partyAliveTimeByMatch.push({
                     match: p.matchName,
                     times: [...(p.partyAliveTimeList || [])]
                 });
                 ex.partyPlacementList.push(p.partyPlacement);
+                ex.matchs[p.matchName] = { ...p };
             }
         })
     );
     
-    return Array.from(map.values()).map(p => ({
-        ...p,
-        partyPlacement: p.partyPlacementList.reduce((a, b) => a + b, 0) / p.partyPlacementList.length
-    }));
+    return Array.from(map.values());
 }
 
 function sortScores(arr) { // 公式準拠のスコアソート関数
@@ -197,47 +216,58 @@ function sortScores(arr) { // 公式準拠のスコアソート関数
     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 = {
+        const matchCount = (p.matchList || []).length || 1;
+        p.summary = {
             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,
+            // Decimalを使って計算
+            avgKills: matchCount > 0
+                ? new Decimal(p.partyKills || 0).dividedBy(matchCount)
+                : new Decimal(p.partyKills || 0),
+            avgPlacement: Array.isArray(p.partyPlacementList) && p.partyPlacementList.length > 0 && matchCount > 0
+                ? new Decimal(p.partyPlacementList.reduce((sum, val) => sum + val, 0)).dividedBy(matchCount)
+                : new Decimal(p.partyPlacement || 0),
             totalAliveTime: sumMaxAliveTime(p.partyAliveTimeList, p.partyAliveTimeByMatch),
         };
     });
 
     return arr.sort((a, b) => {
         // 1. 累計獲得ポイント
-        if (b.result.point !== a.result.point) {
-            return b.result.point - a.result.point;
+        if (b.summary.point !== a.summary.point) {
+            return b.summary.point - a.summary.point;
         }
         // 2. セッション中の累計 Victory Royale 回数
-        if (b.result.victoryCount !== a.result.victoryCount) {
-            return b.result.victoryCount - a.result.victoryCount;
+        if (b.summary.victoryCount !== a.summary.victoryCount) {
+            return b.summary.victoryCount - a.summary.victoryCount;
         }
 
         // 3. 平均撃破数
-        if (b.result.avgKills !== a.result.avgKills) {
-            return b.result.avgKills - a.result.avgKills;
+        const cmpAvgKills = b.summary.avgKills.comparedTo(a.summary.avgKills);
+        if (cmpAvgKills !== 0) {
+            return cmpAvgKills;
         }
 
         // 4. 平均順位（小さいほうが上位）
-        if (b.result.avgPlacement !== a.result.avgPlacement) {
-            return b.result.avgPlacement - a.result.avgPlacement;
+        const cmpAvgPlacement = b.summary.avgPlacement.comparedTo(a.summary.avgPlacement);
+        if (cmpAvgPlacement !== 0) {
+            return cmpAvgPlacement;
         }
 
         // 5. 全マッチの合計生存時間
-        const cmp = b.result.totalAliveTime.comparedTo(a.result.totalAliveTime);
-        if (cmp !== 0) return cmp;
+        const cmpTime = b.summary.totalAliveTime.comparedTo(a.summary.totalAliveTime);
+        if (cmpTime !== 0) {
+            return cmpTime;
+        }
 
         // 6. 最終手段：1マッチ目のパーティ番号が小さい順
-        return a.partyNumber - b.partyNumber;
+        const numA = Array.isArray(a.matchList) && a.matchList.length > 0
+            ? a.matchs[a.matchList[0]].partyNumber
+            : a.partyNumber;
+        const numB = Array.isArray(b.matchList) && b.matchList.length > 0
+            ? b.matchs[b.matchList[0]].partyNumber
+            : b.partyNumber;
+        return numA - numB;
     });
 }
 

package/package.json

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