fortnite-replay-analysis 1.0.9 → 1.1.1

package/LICENSE

@@ -0,0 +1,30 @@
+MIT License
+
+Copyright (c) 2025 yuyutti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+This project includes code from the following MIT-licensed project:
+
+FortniteReplayDecompressor  
+https://github.com/Shiqan/FortniteReplayDecompressor  
+Copyright (c) 2021 Ferron  
+Licensed under the MIT License.

package/README.ja.md

@@ -0,0 +1,124 @@
+## 🌐 Language
+
+- [English](./README.md)
+- [日本語](./README.ja.md)
+
+# Fortnite Replay Analysis
+
+FortniteのリプレイファイルをNode.jsで解析し、プレイヤーデータを取得・集計・ソートできるモジュールです。
+
+## 特徴
+
+* OS判定でビルド済みの自己完結バイナリを呼び出し、高速に解析できます。
+* botプレイヤーの除外や順位ソートのオプションに対応しています。
+* 複数マッチのスコアをパーティ単位でマージして集計できます。
+* 公式準拠のルールでスコアをソートできます。
+
+## インストール
+
+```bash
+npm install fortnite-replay-analysis@latest
+```
+
+## 使い方
+
+以下は、1試合のリプレイ解析からスコア計算、複数マッチのマージまでを実行する例です。
+
+```js
+const {
+    ReplayAnalysis,
+    calculateScore,
+    sortScores,
+    mergeScores
+} = require('fortnite-replay-analysis');
+
+(async () => {
+    // リプレイ解析（ディレクトリ指定時は最初に見つけた .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);
+
+    // ポイント＆キル計算
+    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
+    });
+
+    console.log('Score:', score);
+
+    // 複数マッチのマージと再ソート
+    const merged = mergeScores([ sortedScores, sortedScores2 ]);
+    const finalSorted = sortScores(merged);
+
+    console.log('Merged & Sorted:', finalSorted);
+})();
+```
+
+## API
+
+### `ReplayAnalysis(inputPath, options)`
+
+* `inputPath`: .replayファイルがあるディレクトリまたはファイルのパス
+* `options`（省略可）:
+
+  * `bot`（boolean）: botプレイヤーを含めるか（デフォルト: `false`）
+  * `sort`（boolean）: 順位でソートするか（デフォルト: `true`）
+* 戻り値: Promise<{
+  rawReplayData: Object,
+  rawPlayerData: Array,
+  processedPlayerInfo: Array
+  }>
+
+### `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`の戻り値として得られる配列
+* ソート順:
+
+  1. 累計ポイント降順
+  2. Victory Royale 回数降順
+  3. 平均撃破数降順
+  4. 平均順位昇順
+  5. 合計生存時間降順
+  6. 最初のパーティ番号昇順
+
+### `mergeScores(scoreArrays)`
+
+* 複数マッチ分のスコア配列をパーティ単位でマージします。
+* 引数: ソート済みスコア配列の配列（例: `[sorted1, sorted2, ...]`）
+* 戻り値: マージ後のスコア配列
+
+## 注意事項
+
+* ディレクトリ指定時は最初に見つけた `.replay` を処理します。
+* 直接ファイルを指定した場合はそのファイルを処理し、`.replay` が存在しない場合でも最初に見つけたものを使用します。
+* 本ツールの利用により発生した問題について、開発者は一切の責任を負いません。
+* フォークする場合は、GitHub の「Fork」機能を利用してください（clone → 新規リポジトリ作成は非推奨です）。
+
+## 🔗 使用ライブラリ
+
+このプロジェクトは以下のオープンソースライブラリを使用しています：
+
+- [FortniteReplayDecompressor](https://github.com/Shiqan/FortniteReplayDecompressor)  
+  © Shiqan — 本プロジェクトは MIT ライセンスのもとで利用しています。

package/README.md

@@ -1,117 +1,117 @@
-# Fortnite Replay Analysis
+## 🌐 Language
 
-Fortniteのリプレイファイルを解析して、プレイヤーデータを取得・集計・ソートできるNode.jsのモジュールです。
+- [English](./README.md)
+- [日本語](./README.ja.md)
 
-## 特徴
+# Fortnite Replay Analysis
 
-* OS判定してC#でビルドされた自己完結バイナリを呼び出すから、高速解析できる
-* botプレイヤーの除外や順位ソートなどオプション対応
-* 複数マッチのスコアをパーティ単位でマージして集計可能
-* 公式準拠でのスコアのソートも可能
+Fortnite Replay Analysis is a Node.js module for reading Fortnite replay files, extracting player data, and ranking results.
 
-## インストール
+## Features
 
-```
-npm install fortnite-replay-analysis@latest
-```
+* Detects the operating system and invokes a prebuilt, self-contained binary for fast parsing.
+* Supports excluding bot players and optional placement sorting.
+* Merges scores across multiple matches by party.
+* Sorts scores following the official Fortnite scoring rules.
 
-## 使い方
+## Installation
 
-```js
-const { ReplayAnalysis, mergeScores, sortScores, calculateScore } = require('fortnite-replay-analysis');
-
-(async () => {
-  try {
-    // 1試合分のリプレイ解析（返り値はJSON形式）
-    // rawPlayerData: 元の解析結果、生データ
-    // processedPlayerInfo: bot除外や順位ソート済みのプレイヤーデータ
-    const { rawReplayData, 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);
-  }
-})();
+```bash
+npm install fortnite-replay-analysis@latest
 ```
 
-## calculateScoreの使い方
-
-リプレイ解析済みの`ReplayAnalysis` の `result.processedPlayerInfo` を保存した JSON ファイル（ファイル名は任意でOK）から、大会形式のスコアを計算したいときに使える。
+## Usage
 
 ```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);
+    const {
+        ReplayAnalysis,
+        calculateScore,
+        sortScores,
+        mergeScores
+    } = require('fortnite-replay-analysis');
+
+    (async () => {
+        // Parse a single match (directory: first .replay file; file: specific .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);
+
+        // Sort by official rules
+        const sortedScores = sortScores(processedPlayerInfo);
+
+        // Calculate points & kills
+        const score = await calculateScore({
+            matchData: processedPlayerInfo,
+            points: { 1: 11, 2: 6, 3: 5, 4: 4, 5: 3, 6: 2 },
+            killCountUpperLimit: 10,      // optional, default null (no limit)
+            killPointMultiplier: 1        // points per kill multiplier, optional, default 1
+        });
+
+        console.log('Score:', score);
+
+        // Merge and re-sort multiple matches
+        const merged = mergeScores([sortedScores, sortedScores2]);
+        const finalSorted = sortScores(merged);
+
+        console.log('Merged & Sorted:', finalSorted);
+    })();
 ```
 
 ## API
 
-### `ReplayAnalysis(replayFileDir, options)`
+### `ReplayAnalysis(inputPath, options)`
 
-* `replayFileDir`：リプレイファイルが入ったディレクトリのパス
-* `options`：
+* `inputPath`: Path to a directory or a `.replay` file.
+* `options` (optional):
 
-  * `bot`（boolean）：botプレイヤーを結果に含めるか（デフォルトfalse）
-  * `sort`（boolean）：順位でソートするか（デフォルトtrue）
-* 返り値はPromiseで、`rawPlayerData`と`processedPlayerInfo`を含むオブジェクトを返す
+  * `bot` (boolean): Include bot players (default: `false`).
+  * `sort` (boolean): Sort by placement (default: `true`).
+* Returns: `Promise<{ rawReplayData: Object, rawPlayerData: Array, processedPlayerInfo: Array }>`
 
-### `mergeScores(scoreArrays)`
+### `calculateScore({ matchData, points, killCountUpperLimit, killPointMultiplier })`
 
-* 複数マッチのスコア配列をパーティ単位でマージする
-* 返り値はマージされたスコア配列
+* `matchData`: The `processedPlayerInfo` array from `ReplayAnalysis`, or a path to its JSON file.
+* `points`: Object mapping placement to points (e.g., `{1:11,2:6,...}`).
+* `killCountUpperLimit`: Upper limit for kills (optional, default `null` for unlimited).
+* `killPointMultiplier`: Points multiplier per kill (optional, default `1`).
+* Returns: `Promise<Array>` of aggregated results per party.
 
 ### `sortScores(scoreArray)`
 
-* 公式準拠のルールでスコアをソートする
-* 引数はマージ済みのスコア配列
+Sorts scores according to official Fortnite rules:
+
+1. Total points (descending)
+2. Victory Royale count (descending)
+3. Average kills (descending)
+4. Average placement (ascending)
+5. Total survival time (descending)
+6. First party number (ascending)
+
+### `mergeScores(scoreArrays)`
 
-### `calculateScore({ matchDataPath, points, killCountUpperLimit, killPointMultiplier })`
+* Merges multiple sorted score arrays by party.
+* `scoreArrays`: Array of sorted score arrays (e.g., `[sorted1, sorted2, ...]`).
+* Returns: Merged score array.
 
-* `matchDataPath`：`ReplayAnalysis` の `result.processedPlayerInfo` を保存した JSON ファイルのパス（ファイル名は任意でOK）
-* `points`：順位に対するポイント設定（例：{ 1: 11, 2: 6, ... }）
-* `killCountUpperLimit`：キル数制限（nullで無制限）
-* `killPointMultiplier`：キル数倍率（例：1なら1キル1ポイント、2なら1キル2ポイント）
+## Notes
 
-## 動作環境
+* When a directory is provided, the first `.replay` file found will be processed.
+* When a file is specified, that file will be processed; if no `.replay` is found, the first one in the directory is used.
+* This software is provided without any warranty. Use it at your own risk.
+* When forking this repository, please use GitHub’s "Fork" feature to retain commit history.
+* I’m not very good at English, so the translation might be incorrect.
 
-* Node.js v22以上
-* Windows / Linux対応（Macは未対応）
-* C#で作られた自己完結バイナリが`CSproj/bin/Release/net8.0/`配下に同補されていること
+## 🔗 Acknowledgements
 
-## 注意事項
+This project uses the following open-source library:
 
-* リプレイファイルはディレクトリに1つ以上`.replay`ファイルが必要
-* ディレクトリ内に複数ファイルある場合は現状最初の1つのみ処理される
-* 何か問題起こっても俺は責任追わない
-* このリポジトリをフォークする際は、GitHubの「Fork」ボタンからフォークしてください。
-git cloneして新しく別リポジトリを作るのではなく、GitHub上のフォーク機能を使っていただけると、変更履歴を正しく追えます。
-ご協力よろしくお願いします！
+- [FortniteReplayDecompressor](https://github.com/Shiqan/FortniteReplayDecompressor)  
+  © Shiqan — Licensed under the MIT License.

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;
-        }
-
-        if (replayFiles.length === 0) {
-            reject(new Error(`No replay file found in directory: ${replayFileDir}`));
-            return;
+            return reject(new Error(`Failed to access path: ${e.message}`));
         }
-
-        // とりあえず1個目のファイルを処理（複数ある場合は要拡張）
-        const replayFilePath = path.join(replayFileDir, replayFiles[0]);
         const binPath = getBinaryPath();
 
         execFile(binPath, [replayFilePath], (error, stdout, stderr) => {
@@ -114,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
@@ -168,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) { // 公式準拠のスコアソート関数
@@ -208,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,7 +1,7 @@
 {
   "name": "fortnite-replay-analysis",
-  "version": "1.0.9",
-  "description": "Fortniteのリプレイ解析をNode.jsから呼べる自己完結型C#バイナリラッパー",
+  "version": "1.1.1",
+  "description": "Fortnite replay analysis tool (Node.js用Fortniteリプレイ解析バイナリラッパー)",
   "repository": {
     "type": "git",
     "url": "https://github.com/yuyutti/Fortnite_Replay_Analysis"
@@ -16,7 +16,18 @@
     "analysis",
     "decimal",
     "csharp",
-    "nodejs"
+    "nodejs",
+    "C#",
+    "fortnite-replay",
+    "fortnite解析",
+    "リプレイ解析",
+    "自動スコア計算",
+    "tournament",
+    "game-analysis",
+    "epicgames",
+    "fortnite-scoring",
+    "match-result",
+    "yuyutti"
   ],
   "author": "yuyutti",
   "license": "MIT",