diff --git a/backend/CollabApp.sln b/backend/CollabApp.sln new file mode 100644 index 0000000000000000000000000000000000000000..36d092da6c82a8575da8cb349e8de167948c0e56 --- /dev/null +++ b/backend/CollabApp.sln @@ -0,0 +1,131 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.0.31903.59 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{827E0CD3-B72D-47B6-A68D-7590B98EB39B}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CollabApp.API", "src\CollabApp.API\CollabApp.API.csproj", "{5665D919-F5F1-41A6-AD0E-4DFAA9A7AC6F}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CollabApp.Domain", "src\CollabApp.Domain\CollabApp.Domain.csproj", "{170263DD-CBBB-4106-9D78-A38A001F1F3B}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CollabApp.Application", "src\CollabApp.Application\CollabApp.Application.csproj", "{2505E022-6542-40FF-9725-1DA669A36A20}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CollabApp.Infrastructure", "src\CollabApp.Infrastructure\CollabApp.Infrastructure.csproj", "{78700058-9673-47E0-9993-2274A7BCD49C}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{0AB3BF05-4346-4AA6-1389-037BE0695223}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CollabApp.Tests", "tests\CollabApp.Tests\CollabApp.Tests.csproj", "{59589A24-0675-42A4-B373-48410E57AC47}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CollabApp.Application.Tests", "tests\CollabApp.Application.Tests\CollabApp.Application.Tests.csproj", "{1E791B3C-5FF9-42C6-9F32-F71944C7F092}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CollabApp.Domain.Tests", "tests\CollabApp.Domain.Tests\CollabApp.Domain.Tests.csproj", "{5014B908-8BFF-484B-B9F8-9CB7FA87E16D}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|Any CPU = Release|Any CPU + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {5665D919-F5F1-41A6-AD0E-4DFAA9A7AC6F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5665D919-F5F1-41A6-AD0E-4DFAA9A7AC6F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5665D919-F5F1-41A6-AD0E-4DFAA9A7AC6F}.Debug|x64.ActiveCfg = Debug|Any CPU + {5665D919-F5F1-41A6-AD0E-4DFAA9A7AC6F}.Debug|x64.Build.0 = Debug|Any CPU + {5665D919-F5F1-41A6-AD0E-4DFAA9A7AC6F}.Debug|x86.ActiveCfg = Debug|Any CPU + {5665D919-F5F1-41A6-AD0E-4DFAA9A7AC6F}.Debug|x86.Build.0 = Debug|Any CPU + {5665D919-F5F1-41A6-AD0E-4DFAA9A7AC6F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5665D919-F5F1-41A6-AD0E-4DFAA9A7AC6F}.Release|Any CPU.Build.0 = Release|Any CPU + {5665D919-F5F1-41A6-AD0E-4DFAA9A7AC6F}.Release|x64.ActiveCfg = Release|Any CPU + {5665D919-F5F1-41A6-AD0E-4DFAA9A7AC6F}.Release|x64.Build.0 = Release|Any CPU + {5665D919-F5F1-41A6-AD0E-4DFAA9A7AC6F}.Release|x86.ActiveCfg = Release|Any CPU + {5665D919-F5F1-41A6-AD0E-4DFAA9A7AC6F}.Release|x86.Build.0 = Release|Any CPU + {170263DD-CBBB-4106-9D78-A38A001F1F3B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {170263DD-CBBB-4106-9D78-A38A001F1F3B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {170263DD-CBBB-4106-9D78-A38A001F1F3B}.Debug|x64.ActiveCfg = Debug|Any CPU + {170263DD-CBBB-4106-9D78-A38A001F1F3B}.Debug|x64.Build.0 = Debug|Any CPU + {170263DD-CBBB-4106-9D78-A38A001F1F3B}.Debug|x86.ActiveCfg = Debug|Any CPU + {170263DD-CBBB-4106-9D78-A38A001F1F3B}.Debug|x86.Build.0 = Debug|Any CPU + {170263DD-CBBB-4106-9D78-A38A001F1F3B}.Release|Any CPU.ActiveCfg = Release|Any CPU + {170263DD-CBBB-4106-9D78-A38A001F1F3B}.Release|Any CPU.Build.0 = Release|Any CPU + {170263DD-CBBB-4106-9D78-A38A001F1F3B}.Release|x64.ActiveCfg = Release|Any CPU + {170263DD-CBBB-4106-9D78-A38A001F1F3B}.Release|x64.Build.0 = Release|Any CPU + {170263DD-CBBB-4106-9D78-A38A001F1F3B}.Release|x86.ActiveCfg = Release|Any CPU + {170263DD-CBBB-4106-9D78-A38A001F1F3B}.Release|x86.Build.0 = Release|Any CPU + {2505E022-6542-40FF-9725-1DA669A36A20}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2505E022-6542-40FF-9725-1DA669A36A20}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2505E022-6542-40FF-9725-1DA669A36A20}.Debug|x64.ActiveCfg = Debug|Any CPU + {2505E022-6542-40FF-9725-1DA669A36A20}.Debug|x64.Build.0 = Debug|Any CPU + {2505E022-6542-40FF-9725-1DA669A36A20}.Debug|x86.ActiveCfg = Debug|Any CPU + {2505E022-6542-40FF-9725-1DA669A36A20}.Debug|x86.Build.0 = Debug|Any CPU + {2505E022-6542-40FF-9725-1DA669A36A20}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2505E022-6542-40FF-9725-1DA669A36A20}.Release|Any CPU.Build.0 = Release|Any CPU + {2505E022-6542-40FF-9725-1DA669A36A20}.Release|x64.ActiveCfg = Release|Any CPU + {2505E022-6542-40FF-9725-1DA669A36A20}.Release|x64.Build.0 = Release|Any CPU + {2505E022-6542-40FF-9725-1DA669A36A20}.Release|x86.ActiveCfg = Release|Any CPU + {2505E022-6542-40FF-9725-1DA669A36A20}.Release|x86.Build.0 = Release|Any CPU + {78700058-9673-47E0-9993-2274A7BCD49C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {78700058-9673-47E0-9993-2274A7BCD49C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {78700058-9673-47E0-9993-2274A7BCD49C}.Debug|x64.ActiveCfg = Debug|Any CPU + {78700058-9673-47E0-9993-2274A7BCD49C}.Debug|x64.Build.0 = Debug|Any CPU + {78700058-9673-47E0-9993-2274A7BCD49C}.Debug|x86.ActiveCfg = Debug|Any CPU + {78700058-9673-47E0-9993-2274A7BCD49C}.Debug|x86.Build.0 = Debug|Any CPU + {78700058-9673-47E0-9993-2274A7BCD49C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {78700058-9673-47E0-9993-2274A7BCD49C}.Release|Any CPU.Build.0 = Release|Any CPU + {78700058-9673-47E0-9993-2274A7BCD49C}.Release|x64.ActiveCfg = Release|Any CPU + {78700058-9673-47E0-9993-2274A7BCD49C}.Release|x64.Build.0 = Release|Any CPU + {78700058-9673-47E0-9993-2274A7BCD49C}.Release|x86.ActiveCfg = Release|Any CPU + {78700058-9673-47E0-9993-2274A7BCD49C}.Release|x86.Build.0 = Release|Any CPU + {59589A24-0675-42A4-B373-48410E57AC47}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {59589A24-0675-42A4-B373-48410E57AC47}.Debug|Any CPU.Build.0 = Debug|Any CPU + {59589A24-0675-42A4-B373-48410E57AC47}.Debug|x64.ActiveCfg = Debug|Any CPU + {59589A24-0675-42A4-B373-48410E57AC47}.Debug|x64.Build.0 = Debug|Any CPU + {59589A24-0675-42A4-B373-48410E57AC47}.Debug|x86.ActiveCfg = Debug|Any CPU + {59589A24-0675-42A4-B373-48410E57AC47}.Debug|x86.Build.0 = Debug|Any CPU + {59589A24-0675-42A4-B373-48410E57AC47}.Release|Any CPU.ActiveCfg = Release|Any CPU + {59589A24-0675-42A4-B373-48410E57AC47}.Release|Any CPU.Build.0 = Release|Any CPU + {59589A24-0675-42A4-B373-48410E57AC47}.Release|x64.ActiveCfg = Release|Any CPU + {59589A24-0675-42A4-B373-48410E57AC47}.Release|x64.Build.0 = Release|Any CPU + {59589A24-0675-42A4-B373-48410E57AC47}.Release|x86.ActiveCfg = Release|Any CPU + {59589A24-0675-42A4-B373-48410E57AC47}.Release|x86.Build.0 = Release|Any CPU + {1E791B3C-5FF9-42C6-9F32-F71944C7F092}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {1E791B3C-5FF9-42C6-9F32-F71944C7F092}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1E791B3C-5FF9-42C6-9F32-F71944C7F092}.Debug|x64.ActiveCfg = Debug|Any CPU + {1E791B3C-5FF9-42C6-9F32-F71944C7F092}.Debug|x64.Build.0 = Debug|Any CPU + {1E791B3C-5FF9-42C6-9F32-F71944C7F092}.Debug|x86.ActiveCfg = Debug|Any CPU + {1E791B3C-5FF9-42C6-9F32-F71944C7F092}.Debug|x86.Build.0 = Debug|Any CPU + {1E791B3C-5FF9-42C6-9F32-F71944C7F092}.Release|Any CPU.ActiveCfg = Release|Any CPU + {1E791B3C-5FF9-42C6-9F32-F71944C7F092}.Release|Any CPU.Build.0 = Release|Any CPU + {1E791B3C-5FF9-42C6-9F32-F71944C7F092}.Release|x64.ActiveCfg = Release|Any CPU + {1E791B3C-5FF9-42C6-9F32-F71944C7F092}.Release|x64.Build.0 = Release|Any CPU + {1E791B3C-5FF9-42C6-9F32-F71944C7F092}.Release|x86.ActiveCfg = Release|Any CPU + {1E791B3C-5FF9-42C6-9F32-F71944C7F092}.Release|x86.Build.0 = Release|Any CPU + {5014B908-8BFF-484B-B9F8-9CB7FA87E16D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5014B908-8BFF-484B-B9F8-9CB7FA87E16D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5014B908-8BFF-484B-B9F8-9CB7FA87E16D}.Debug|x64.ActiveCfg = Debug|Any CPU + {5014B908-8BFF-484B-B9F8-9CB7FA87E16D}.Debug|x64.Build.0 = Debug|Any CPU + {5014B908-8BFF-484B-B9F8-9CB7FA87E16D}.Debug|x86.ActiveCfg = Debug|Any CPU + {5014B908-8BFF-484B-B9F8-9CB7FA87E16D}.Debug|x86.Build.0 = Debug|Any CPU + {5014B908-8BFF-484B-B9F8-9CB7FA87E16D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5014B908-8BFF-484B-B9F8-9CB7FA87E16D}.Release|Any CPU.Build.0 = Release|Any CPU + {5014B908-8BFF-484B-B9F8-9CB7FA87E16D}.Release|x64.ActiveCfg = Release|Any CPU + {5014B908-8BFF-484B-B9F8-9CB7FA87E16D}.Release|x64.Build.0 = Release|Any CPU + {5014B908-8BFF-484B-B9F8-9CB7FA87E16D}.Release|x86.ActiveCfg = Release|Any CPU + {5014B908-8BFF-484B-B9F8-9CB7FA87E16D}.Release|x86.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(NestedProjects) = preSolution + {5665D919-F5F1-41A6-AD0E-4DFAA9A7AC6F} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B} + {170263DD-CBBB-4106-9D78-A38A001F1F3B} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B} + {2505E022-6542-40FF-9725-1DA669A36A20} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B} + {78700058-9673-47E0-9993-2274A7BCD49C} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B} + {59589A24-0675-42A4-B373-48410E57AC47} = {0AB3BF05-4346-4AA6-1389-037BE0695223} + {1E791B3C-5FF9-42C6-9F32-F71944C7F092} = {0AB3BF05-4346-4AA6-1389-037BE0695223} + {5014B908-8BFF-484B-B9F8-9CB7FA87E16D} = {0AB3BF05-4346-4AA6-1389-037BE0695223} + EndGlobalSection +EndGlobal diff --git a/backend/docs/API_DOCUMENTATION.md b/backend/docs/API_DOCUMENTATION.md new file mode 100644 index 0000000000000000000000000000000000000000..c6a52f901fad3295c63259981400566611e21d83 --- /dev/null +++ b/backend/docs/API_DOCUMENTATION.md @@ -0,0 +1,603 @@ +# 画线圈地游戏 - API接口文档 + +## 文档概述 + +本文档详细描述了画线圈地游戏的所有REST API接口，包括请求格式、响应格式、错误处理和使用示例。 + +--- + +## API基础信息 + +- **基础URL**: `http://localhost:5000/api` +- **协议**: HTTP/HTTPS +- **数据格式**: JSON +- **字符编码**: UTF-8 +- **实时通信**: SignalR WebSocket + +--- + +## 通用响应格式 + +所有API接口都使用统一的响应格式： + +```json +{ + "success": true, + "data": { /* 具体数据 */ }, + "message": "操作成功", + "messages": ["成功信息1", "成功信息2"] +} +``` + +错误响应格式： + +```json +{ + "success": false, + "data": null, + "message": "错误描述", + "messages": ["错误信息1", "错误信息2"] +} +``` + +--- + +## 1. 游戏控制器 (GameController) + +### 1.1 加入游戏 + +**接口地址**: `POST /api/game/join` + +**描述**: 玩家加入指定游戏并初始化状态 + +**请求参数**: +```json +{ + "gameId": "游戏ID (GUID)", + "userId": "用户ID (GUID)", + "playerName": "玩家名称", + "playerColor": "玩家颜色 (#FF0000)" +} +``` + +**响应数据**: +```json +{ + "success": true, + "data": { + "playerId": "玩家ID", + "playerName": "玩家名称", + "playerColor": "#FF5733", + "currentPosition": { "x": 100.0, "y": 150.0 }, + "drawingState": "Moving", + "currentTrail": [], + "ownedTerritories": [ + { + "id": "领土ID", + "playerId": "玩家ID", + "boundary": [ + { "x": 50.0, "y": 50.0 }, + { "x": 150.0, "y": 50.0 }, + { "x": 150.0, "y": 150.0 }, + { "x": 50.0, "y": 150.0 } + ], + "area": 10000.0 + } + ], + "totalTerritoryArea": 10000.0, + "inventory": ["SpeedBoost", "Shield"], + "activeEffects": [], + "isInvulnerable": false, + "statistics": { + "deaths": 0, + "kills": 0, + "maxTerritoryArea": 10000.0, + "totalDistanceMoved": 0.0, + "itemsUsed": 0, + "itemsPickedUp": 0, + "territoryCaptures": 1 + } + }, + "message": "成功加入游戏" +} +``` + +**错误响应示例**: +```json +{ + "success": false, + "message": "游戏ID不能为空" +} +``` + +--- + +### 1.2 获取玩家状态 + +**接口地址**: `GET /api/game/{gameId}/player/{playerId}/state` + +**描述**: 获取指定游戏中玩家的完整状态信息 + +**路径参数**: +- `gameId`: 游戏ID (GUID) +- `playerId`: 玩家ID (GUID) + +**响应数据**: 与加入游戏接口相同的玩家状态数据 + +--- + +### 1.3 移动玩家 + +**接口地址**: `POST /api/game/move` + +**描述**: 更新玩家位置并处理移动逻辑 + +**请求参数**: +```json +{ + "gameId": "游戏ID (GUID)", + "playerId": "玩家ID (GUID)", + "x": 200.5, + "y": 150.3, + "isDrawing": true +} +``` + +**响应数据**: +```json +{ + "success": true, + "data": { + "oldPosition": { "x": 180.0, "y": 140.0 }, + "newPosition": { "x": 200.5, "y": 150.3 }, + "distanceMoved": 25.2, + "currentSpeed": 5.0, + "isDrawing": true, + "collisionResult": null, + "events": [ + { + "type": "Move", + "timestamp": "2025-01-16T10:30:00Z", + "data": { "distance": 25.2 } + } + ] + }, + "message": "移动成功" +} +``` + +**碰撞响应示例**: +```json +{ + "success": true, + "data": { + "oldPosition": { "x": 180.0, "y": 140.0 }, + "newPosition": { "x": 200.5, "y": 150.3 }, + "distanceMoved": 25.2, + "currentSpeed": 5.0, + "isDrawing": true, + "collisionResult": { + "collisionType": "PlayerBody", + "collisionPoint": { "x": 195.0, "y": 145.0 }, + "otherPlayerId": "其他玩家ID", + "severity": "Fatal" + }, + "events": [ + { + "type": "PlayerDeath", + "timestamp": "2025-01-16T10:30:00Z", + "data": { "cause": "PlayerBody", "killerId": "击杀者ID" } + } + ] + }, + "message": "碰撞到其他玩家，死亡" +} +``` + +--- + +### 1.4 开始绘制 + +**接口地址**: `POST /api/game/{gameId}/player/{playerId}/start-drawing` + +**描述**: 玩家开始绘制领土线条 + +**路径参数**: +- `gameId`: 游戏ID (GUID) +- `playerId`: 玩家ID (GUID) + +**响应数据**: +```json +{ + "success": true, + "data": true, + "message": "开始绘制领土" +} +``` + +--- + +### 1.5 停止绘制 + +**接口地址**: `POST /api/game/{gameId}/player/{playerId}/stop-drawing` + +**描述**: 玩家停止绘制并尝试形成领土 + +**路径参数**: +- `gameId`: 游戏ID (GUID) +- `playerId`: 玩家ID (GUID) + +**响应数据**: +```json +{ + "success": true, + "data": { + "success": true, + "newTerritoryArea": 5000.0, + "capturedTerritoryArea": 1200.0, + "totalTerritoryArea": 15000.0, + "newTerritory": { + "id": "领土ID", + "playerId": "玩家ID", + "boundary": [ + { "x": 100.0, "y": 100.0 }, + { "x": 200.0, "y": 100.0 }, + { "x": 200.0, "y": 200.0 }, + { "x": 100.0, "y": 200.0 } + ], + "area": 5000.0 + }, + "capturedTerritories": [ + { + "originalPlayerId": "被夺取玩家ID", + "capturedArea": 1200.0 + } + ], + "rankingChange": 2 + }, + "message": "成功形成领土，获得 5000.0 平方单位" +} +``` + +--- + +### 1.6 拾取道具 + +**接口地址**: `POST /api/game/{gameId}/player/{playerId}/pickup-item/{itemId}` + +**描述**: 拾取地图上的道具 + +**路径参数**: +- `gameId`: 游戏ID (GUID) +- `playerId`: 玩家ID (GUID) +- `itemId`: 道具ID (GUID) + +**响应数据**: +```json +{ + "success": true, + "data": { + "success": true, + "itemId": "道具ID", + "itemType": "SpeedBoost", + "position": { "x": 250.0, "y": 180.0 }, + "addedToInventory": true + }, + "message": "成功拾取 SpeedBoost 道具" +} +``` + +--- + +### 1.7 使用道具 + +**接口地址**: `POST /api/game/use-item` + +**描述**: 使用背包中的道具 + +**请求参数**: +```json +{ + "gameId": "游戏ID (GUID)", + "playerId": "玩家ID (GUID)", + "itemType": "SpeedBoost", + "targetX": 300.0, + "targetY": 200.0 +} +``` + +**响应数据**: +```json +{ + "success": true, + "data": { + "success": true, + "itemType": "SpeedBoost", + "effectDuration": 10, + "effectStartTime": "2025-01-16T10:30:00Z", + "targetPosition": { "x": 300.0, "y": 200.0 }, + "appliedEffects": [ + { + "type": "SpeedMultiplier", + "value": 1.3, + "duration": 10 + } + ] + }, + "message": "SpeedBoost 道具使用成功" +} +``` + +**道具类型说明**: +- `SpeedBoost`: 加速药剂，提高移动速度30%，持续10秒 +- `Shield`: 保护盾，免疫一次碰撞死亡，持续15秒 +- `Teleport`: 传送术，瞬间传送到指定位置 +- `Bomb`: 炸弹，清除指定区域内的所有轨迹线 +- `Freeze`: 冰冻术，冻结附近玩家8秒 + +--- + +### 1.8 获取游戏排名 + +**接口地址**: `GET /api/game/{gameId}/ranking` + +**描述**: 获取当前游戏的玩家排名 + +**路径参数**: +- `gameId`: 游戏ID (GUID) + +**响应数据**: +```json +{ + "success": true, + "data": [ + { + "rank": 1, + "playerId": "玩家ID", + "playerName": "冠军玩家", + "playerColor": "#FFD700", + "territoryArea": 25000.0, + "territoryCount": 5, + "areaPercentage": 35.5, + "currentState": "Moving", + "lastUpdate": "2025-01-16T10:30:00Z" + }, + { + "rank": 2, + "playerId": "玩家ID", + "playerName": "亚军玩家", + "playerColor": "#C0C0C0", + "territoryArea": 18000.0, + "territoryCount": 4, + "areaPercentage": 25.7, + "currentState": "Drawing", + "lastUpdate": "2025-01-16T10:30:00Z" + } + ], + "message": "" +} +``` + +--- + +### 1.9 获取玩家统计 + +**接口地址**: `GET /api/game/{gameId}/player/{playerId}/statistics` + +**描述**: 获取指定玩家的详细统计信息 + +**路径参数**: +- `gameId`: 游戏ID (GUID) +- `playerId`: 玩家ID (GUID) + +**响应数据**: +```json +{ + "success": true, + "data": { + "deaths": 2, + "kills": 3, + "maxTerritoryArea": 28000.0, + "totalDistanceMoved": 5420.8, + "itemsUsed": 8, + "itemsPickedUp": 12, + "territoryCaptures": 4 + }, + "message": "" +} +``` + +--- + +## 2. SignalR实时通信 + +### 连接信息 +- **Hub地址**: `/gameHub` +- **协议**: WebSocket +- **认证**: 可选Bearer Token + +### 客户端可发送的方法 + +#### 2.1 加入游戏房间 +```javascript +connection.invoke("JoinGameAsync", gameId, playerName) +``` + +#### 2.2 移动玩家 +```javascript +connection.invoke("MovePlayerAsync", x, y, isDrawing) +``` + +#### 2.3 使用道具 +```javascript +connection.invoke("UseItemAsync", itemType, targetX, targetY) +``` + +### 服务器推送的事件 + +#### 2.1 玩家移动 +```javascript +connection.on("PlayerMoved", (data) => { + // data: { playerId, position, oldPosition, speed, distanceMoved, isDrawing, events } +}); +``` + +#### 2.2 玩家死亡 +```javascript +connection.on("PlayerDied", (data) => { + // data: { playerId, killerId, deathCause, position, respawnTime } +}); +``` + +#### 2.3 玩家复活 +```javascript +connection.on("PlayerRespawned", (data) => { + // data: { playerId, position, invulnerabilityTime } +}); +``` + +#### 2.4 领土变化 +```javascript +connection.on("TerritoryChanged", (data) => { + // data: { playerId, newTerritory, capturedTerritories, totalArea } +}); +``` + +#### 2.5 道具拾取 +```javascript +connection.on("ItemPickedUp", (data) => { + // data: { playerId, itemId, itemType, position } +}); +``` + +#### 2.6 道具使用 +```javascript +connection.on("ItemUsed", (data) => { + // data: { playerId, itemType, effects, targetPosition } +}); +``` + +#### 2.7 排名更新 +```javascript +connection.on("RankingUpdated", (data) => { + // data: [ { rank, playerId, playerName, territoryArea, ... } ] +}); +``` + +--- + +## 3. 错误码说明 + +| 错误码 | 描述 | 解决方案 | +|--------|------|----------| +| 400 | 请求参数错误 | 检查请求参数格式和必填字段 | +| 401 | 未授权访问 | 提供有效的认证信息 | +| 404 | 资源不存在 | 确认游戏ID或玩家ID是否正确 | +| 409 | 操作冲突 | 检查游戏状态或玩家状态是否允许该操作 | +| 500 | 服务器内部错误 | 稍后重试或联系技术支持 | + +## 4. 使用示例 + +### 完整的游戏流程示例 + +```javascript +// 1. 加入游戏 +const joinResponse = await fetch('/api/game/join', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ + gameId: 'game-123', + userId: 'user-456', + playerName: '玩家1', + playerColor: '#FF5733' + }) +}); + +const joinData = await joinResponse.json(); +if (joinData.success) { + console.log('成功加入游戏', joinData.data); +} + +// 2. 建立SignalR连接 +const connection = new signalR.HubConnectionBuilder() + .withUrl("/gameHub") + .build(); + +await connection.start(); +await connection.invoke("JoinGameAsync", gameId, playerName); + +// 3. 监听事件 +connection.on("PlayerMoved", (data) => { + updatePlayerPosition(data.playerId, data.position); +}); + +connection.on("TerritoryChanged", (data) => { + updateTerritoryDisplay(data); +}); + +// 4. 移动玩家 +await fetch('/api/game/move', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ + gameId: gameId, + playerId: playerId, + x: 200, + y: 150, + isDrawing: true + }) +}); + +// 5. 使用道具 +await fetch('/api/game/use-item', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ + gameId: gameId, + playerId: playerId, + itemType: 'SpeedBoost' + }) +}); + +// 6. 获取排名 +const rankingResponse = await fetch(`/api/game/${gameId}/ranking`); +const rankingData = await rankingResponse.json(); +if (rankingData.success) { + displayRanking(rankingData.data); +} +``` + +--- + +## 5. 性能建议 + +### 5.1 请求频率限制 +- 移动请求：最高20次/秒 +- 状态查询：最高5次/秒 +- 道具使用：最高2次/秒 + +### 5.2 数据压缩 +- 启用gzip压缩减少传输量 +- 使用增量更新减少数据量 +- 合并相似请求减少网络调用 + +### 5.3 缓存策略 +- 缓存玩家状态数据5秒 +- 缓存排名数据10秒 +- 缓存统计数据30秒 + +--- + +## 6. 调试工具 + +### 6.1 API测试页面 +访问 `/api-test.html` 可以使用内置的API测试工具。 + +### 6.2 开发者工具 +- 浏览器开发者工具查看网络请求 +- SignalR连接状态监控 +- 实时数据流监控 + +--- + +这份API文档提供了完整的接口说明和使用指南，帮助前端开发者正确集成游戏后端服务。 diff --git a/backend/docs/METHOD_SIGNATURES.md b/backend/docs/METHOD_SIGNATURES.md new file mode 100644 index 0000000000000000000000000000000000000000..017f03582891d1cde5dfb0fca1e95228118dd985 --- /dev/null +++ b/backend/docs/METHOD_SIGNATURES.md @@ -0,0 +1,551 @@ +# 画线圈地游戏 - 服务方法签名详解 + +## 文档概述 + +本文档详细列出了所有服务接口中的方法签名、参数说明、返回值类型和使用示例，为开发者提供精确的API参考。 + +--- + +## 1. IPlayerStateService 接口方法 + +### 1.1 基础状态管理 + +#### GetPlayerStateAsync +```csharp +Task GetPlayerStateAsync(Guid gameId, Guid playerId); +``` +**参数**: +- `gameId`: 游戏唯一标识符 +- `playerId`: 玩家唯一标识符 + +**返回**: `PlayerGameState?` - 玩家完整状态信息，如果不存在则返回null + +**使用示例**: +```csharp +var playerState = await _playerStateService.GetPlayerStateAsync(gameId, playerId); +if (playerState != null) +{ + Console.WriteLine($"玩家 {playerState.PlayerName} 当前位置: ({playerState.CurrentPosition.X}, {playerState.CurrentPosition.Y})"); +} +``` + +--- + +#### GetAllPlayerStatesAsync +```csharp +Task> GetAllPlayerStatesAsync(Guid gameId); +``` +**参数**: +- `gameId`: 游戏唯一标识符 + +**返回**: `List` - 游戏中所有玩家的状态列表 + +**使用示例**: +```csharp +var allPlayers = await _playerStateService.GetAllPlayerStatesAsync(gameId); +foreach (var player in allPlayers) +{ + Console.WriteLine($"玩家: {player.PlayerName}, 领土面积: {player.TotalTerritoryArea}"); +} +``` + +--- + +#### InitializePlayerStateAsync +```csharp +Task InitializePlayerStateAsync(Guid gameId, Guid playerId, string playerName); +``` +**参数**: +- `gameId`: 游戏唯一标识符 +- `playerId`: 玩家唯一标识符 +- `playerName`: 玩家显示名称 + +**返回**: `PlayerInitResult` - 初始化结果，包含分配的颜色和出生点 + +**PlayerInitResult 结构**: +```csharp +public class PlayerInitResult +{ + public bool Success { get; set; } + public string PlayerColor { get; set; } = string.Empty; + public Position SpawnPosition { get; set; } = new(); + public Territory InitialTerritory { get; set; } = new(); + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} +``` + +--- + +### 1.2 移动与绘制系统 + +#### UpdatePlayerPositionAsync +```csharp +Task UpdatePlayerPositionAsync( + Guid gameId, + Guid playerId, + Position newPosition, + DateTime timestamp, + bool isDrawing = false); +``` +**参数**: +- `gameId`: 游戏唯一标识符 +- `playerId`: 玩家唯一标识符 +- `newPosition`: 目标位置坐标 +- `timestamp`: 移动时间戳 +- `isDrawing`: 是否正在绘制（默认false） + +**返回**: `PositionUpdateResult` - 位置更新结果 + +**PositionUpdateResult 结构**: +```csharp +public class PositionUpdateResult +{ + public bool Success { get; set; } + public Position OldPosition { get; set; } = new(); + public Position NewPosition { get; set; } = new(); + public float DistanceMoved { get; set; } + public float CurrentSpeed { get; set; } + public bool CollisionDetected { get; set; } + public CollisionInfo? CollisionInfo { get; set; } + public List Events { get; set; } = new(); + public List Errors { get; set; } = new(); +} +``` + +--- + +#### StartDrawingAsync +```csharp +Task StartDrawingAsync(Guid gameId, Guid playerId, Position startPosition); +``` +**参数**: +- `gameId`: 游戏唯一标识符 +- `playerId`: 玩家唯一标识符 +- `startPosition`: 开始绘制的位置 + +**返回**: `DrawingStartResult` - 开始绘制的结果 + +**DrawingStartResult 结构**: +```csharp +public class DrawingStartResult +{ + public bool Success { get; set; } + public Position StartPosition { get; set; } = new(); + public DateTime StartTime { get; set; } + public PlayerDrawingState NewState { get; set; } + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} +``` + +--- + +#### StopDrawingAsync +```csharp +Task StopDrawingAsync(Guid gameId, Guid playerId, Position endPosition); +``` +**参数**: +- `gameId`: 游戏唯一标识符 +- `playerId`: 玩家唯一标识符 +- `endPosition`: 结束绘制的位置 + +**返回**: `DrawingEndResult` - 绘制结束结果 + +**DrawingEndResult 结构**: +```csharp +public class DrawingEndResult +{ + public bool Success { get; set; } + public bool TerritoryFormed { get; set; } + public Territory? NewTerritory { get; set; } + public float NewTerritoryArea { get; set; } + public List CapturedTerritories { get; set; } = new(); + public float TotalTerritoryArea { get; set; } + public int RankingChange { get; set; } + public List TrailPoints { get; set; } = new(); + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} +``` + +--- + +### 1.3 碰撞与战斗系统 + +#### HandleTrailCollisionAsync +```csharp +Task HandleTrailCollisionAsync( + Guid gameId, + Guid victimPlayerId, + Position collisionPosition, + Guid? attackerPlayerId = null); +``` +**参数**: +- `gameId`: 游戏唯一标识符 +- `victimPlayerId`: 被攻击玩家标识符 +- `collisionPosition`: 碰撞发生位置 +- `attackerPlayerId`: 攻击者标识符（可选） + +**返回**: `PlayerCollisionResult` - 碰撞处理结果 + +--- + +#### HandlePlayerDeathAsync +```csharp +Task HandlePlayerDeathAsync( + Guid gameId, + Guid playerId, + string deathReason, + Guid? killerId = null, + Position? deathPosition = null); +``` +**参数**: +- `gameId`: 游戏唯一标识符 +- `playerId`: 死亡玩家标识符 +- `deathReason`: 死亡原因描述 +- `killerId`: 击杀者标识符（可选） +- `deathPosition`: 死亡位置（可选） + +**返回**: `DeathResult` - 死亡处理结果 + +--- + +#### RespawnPlayerAsync +```csharp +Task RespawnPlayerAsync(Guid gameId, Guid playerId); +``` +**参数**: +- `gameId`: 游戏唯一标识符 +- `playerId`: 要复活的玩家标识符 + +**返回**: `RespawnResult` - 复活操作结果 + +--- + +### 1.4 领土计算系统 + +#### CalculatePlayerTerritoryAsync +```csharp +Task CalculatePlayerTerritoryAsync(Guid gameId, Guid playerId); +``` +**参数**: +- `gameId`: 游戏唯一标识符 +- `playerId`: 玩家标识符 + +**返回**: `TerritoryResult` - 领土计算结果 + +**TerritoryResult 结构**: +```csharp +public class TerritoryResult +{ + public bool Success { get; set; } + public float NewTerritoryArea { get; set; } + public float CapturedTerritoryArea { get; set; } + public float TotalTerritoryArea { get; set; } + public List NewTerritories { get; set; } = new(); + public List CapturedTerritories { get; set; } = new(); + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} +``` + +--- + +### 1.5 道具系统 + +#### PickupItemAsync +```csharp +Task PickupItemAsync( + Guid gameId, + Guid playerId, + Guid itemId); +``` +**参数**: +- `gameId`: 游戏唯一标识符 +- `playerId`: 玩家标识符 +- `itemId`: 道具标识符 + +**返回**: `ItemPickupResult` - 道具拾取结果 + +**ItemPickupResult 结构**: +```csharp +public class ItemPickupResult +{ + public bool Success { get; set; } + public Guid ItemId { get; set; } + public DrawingGameItemType ItemType { get; set; } + public Position ItemPosition { get; set; } = new(); + public bool AddedToInventory { get; set; } + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} +``` + +--- + +#### UseItemAsync +```csharp +Task UseItemAsync( + Guid gameId, + Guid playerId, + DrawingGameItemType itemType, + float? targetX = null, + float? targetY = null); +``` +**参数**: +- `gameId`: 游戏唯一标识符 +- `playerId`: 玩家标识符 +- `itemType`: 道具类型枚举 +- `targetX`: 目标X坐标（某些道具需要） +- `targetY`: 目标Y坐标（某些道具需要） + +**返回**: `ItemUseResult` - 道具使用结果 + +**ItemUseResult 结构**: +```csharp +public class ItemUseResult +{ + public bool Success { get; set; } + public DrawingGameItemType ItemType { get; set; } + public int EffectDuration { get; set; } + public DateTime EffectStartTime { get; set; } + public Position? TargetPosition { get; set; } + public List AppliedEffects { get; set; } = new(); + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} +``` + +--- + +### 1.6 排名与统计 + +#### GetGameRankingAsync +```csharp +Task> GetGameRankingAsync(Guid gameId); +``` +**参数**: +- `gameId`: 游戏唯一标识符 + +**返回**: `List` - 玩家排名信息列表 + +**PlayerRankingInfo 结构**: +```csharp +public class PlayerRankingInfo +{ + public int Rank { get; set; } + public Guid PlayerId { get; set; } + public string PlayerName { get; set; } = string.Empty; + public string PlayerColor { get; set; } = string.Empty; + public float TerritoryArea { get; set; } + public int TerritoryCount { get; set; } + public float AreaPercentage { get; set; } + public PlayerDrawingState CurrentState { get; set; } + public DateTime LastUpdate { get; set; } +} +``` + +--- + +#### GetPlayerStatisticsAsync +```csharp +Task GetPlayerStatisticsAsync(Guid gameId, Guid playerId); +``` +**参数**: +- `gameId`: 游戏唯一标识符 +- `playerId`: 玩家标识符 + +**返回**: `PlayerGameStatistics?` - 玩家统计信息，如果不存在则返回null + +--- + +## 2. 数据类型定义 + +### 2.1 基础数据类型 + +#### Position +```csharp +public class Position +{ + public float X { get; set; } + public float Y { get; set; } + + public Position() { } + public Position(float x, float y) { X = x; Y = y; } + + public float DistanceTo(Position other) => + (float)Math.Sqrt(Math.Pow(X - other.X, 2) + Math.Pow(Y - other.Y, 2)); +} +``` + +#### Territory +```csharp +public class Territory +{ + public Guid Id { get; set; } = Guid.NewGuid(); + public Guid PlayerId { get; set; } + public List Boundary { get; set; } = new(); + public float Area { get; set; } + public DateTime CreatedAt { get; set; } +} +``` + +### 2.2 枚举类型 + +#### PlayerDrawingState +```csharp +public enum PlayerDrawingState +{ + Moving, // 正在移动 + Drawing, // 正在绘制 + Dead, // 已死亡 + Invulnerable // 无敌状态 +} +``` + +#### DrawingGameItemType +```csharp +public enum DrawingGameItemType +{ + SpeedBoost, // 加速药剂 + Shield, // 保护盾 + Teleport, // 传送术 + Bomb, // 炸弹 + Freeze // 冰冻术 +} +``` + +#### DrawingGameCollisionType +```csharp +public enum DrawingGameCollisionType +{ + None, // 无碰撞 + PlayerBody, // 玩家身体 + PlayerTrail, // 玩家轨迹 + GameBoundary, // 游戏边界 + Obstacle // 障碍物 +} +``` + +### 2.3 复杂数据类型 + +#### PlayerGameState +```csharp +public class PlayerGameState +{ + public Guid PlayerId { get; set; } + public string PlayerName { get; set; } = string.Empty; + public string PlayerColor { get; set; } = string.Empty; + public Position CurrentPosition { get; set; } = new(); + public PlayerDrawingState DrawingState { get; set; } + public List CurrentTrail { get; set; } = new(); + public List OwnedTerritories { get; set; } = new(); + public float TotalTerritoryArea { get; set; } + public List Inventory { get; set; } = new(); + public List ActiveEffects { get; set; } = new(); + public bool IsInvulnerable { get; set; } + public DateTime? RespawnTime { get; set; } + public PlayerGameStatistics Statistics { get; set; } = new(); +} +``` + +#### PlayerGameStatistics +```csharp +public class PlayerGameStatistics +{ + public int Deaths { get; set; } + public int Kills { get; set; } + public float MaxTerritoryArea { get; set; } + public float TotalDistanceMoved { get; set; } + public int ItemsUsed { get; set; } + public int ItemsPickedUp { get; set; } + public int TerritoryCaptures { get; set; } +} +``` + +#### ActiveEffect +```csharp +public class ActiveEffect +{ + public DrawingGameItemType ItemType { get; set; } + public string EffectType { get; set; } = string.Empty; + public float EffectValue { get; set; } + public DateTime StartTime { get; set; } + public int Duration { get; set; } + public DateTime EndTime => StartTime.AddSeconds(Duration); + public bool IsExpired => DateTime.UtcNow > EndTime; +} +``` + +--- + +## 3. 错误处理模式 + +所有服务方法都遵循统一的错误处理模式： + +### 3.1 Result对象模式 +```csharp +public class ServiceResult +{ + public bool Success { get; set; } + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} +``` + +### 3.2 常见错误类型 +- **参数验证错误**: `ArgumentException` +- **状态不一致错误**: `InvalidOperationException` +- **资源不存在错误**: `KeyNotFoundException` +- **并发操作错误**: `InvalidOperationException` + +### 3.3 错误处理示例 +```csharp +try +{ + var result = await _playerStateService.UpdatePlayerPositionAsync(gameId, playerId, newPosition, timestamp); + if (!result.Success) + { + // 处理业务逻辑错误 + foreach (var error in result.Errors) + { + Console.WriteLine($"错误: {error}"); + } + } +} +catch (ArgumentException ex) +{ + // 处理参数错误 + Console.WriteLine($"参数错误: {ex.Message}"); +} +catch (InvalidOperationException ex) +{ + // 处理操作错误 + Console.WriteLine($"操作错误: {ex.Message}"); +} +``` + +--- + +## 4. 性能注意事项 + +### 4.1 异步操作 +- 所有方法都是异步的，使用 `async/await` 模式 +- 避免在UI线程中直接调用，使用 `ConfigureAwait(false)` + +### 4.2 批量操作优化 +```csharp +// 获取多个玩家状态 +var tasks = playerIds.Select(id => _playerStateService.GetPlayerStateAsync(gameId, id)); +var results = await Task.WhenAll(tasks); +``` + +### 4.3 缓存策略 +- 玩家状态缓存5秒 +- 排名数据缓存10秒 +- 统计数据缓存30秒 + +--- + +这份详细的方法签名文档为开发者提供了精确的API参考，确保正确使用所有服务接口。 diff --git a/backend/docs/SERVICES_OVERVIEW.md b/backend/docs/SERVICES_OVERVIEW.md new file mode 100644 index 0000000000000000000000000000000000000000..112b7206ff211a28d7391729342297e402250c2d --- /dev/null +++ b/backend/docs/SERVICES_OVERVIEW.md @@ -0,0 +1,396 @@ +# 画线圈地游戏 - 服务架构总览 + +## 文档概述 + +本文档详细描述了画线圈地游戏后端系统中所有服务的职责、核心方法和业务逻辑。系统采用领域驱动设计(DDD)架构，将业务逻辑封装在各个专门的服务中。 + +--- + +## 服务架构图 + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ API层 (Controllers & Hubs) │ +├─────────────────────────────────────────────────────────────────┤ +│ 应用服务层 (Application) │ +│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ +│ │ 玩家状态服务 │ │ 游戏玩法服务 │ │ 领地计算服务 │ │ +│ └─────────────────┘ └─────────────────┘ └─────────────────┘ │ +│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ +│ │ 碰撞检测服务 │ │ 广播通知服务 │ │ 道具效果服务 │ │ +│ └─────────────────┘ └─────────────────┘ └─────────────────┘ │ +│ ┌─────────────────┐ ┌─────────────────┐ │ +│ │ 游戏状态服务 │ │ 结算统计服务 │ │ +│ └─────────────────┘ └─────────────────┘ │ +├─────────────────────────────────────────────────────────────────┤ +│ 领域层 (Domain Interfaces) │ +└─────────────────────────────────────────────────────────────────┘ +``` + +--- + +## 1. 玩家状态服务 (PlayerStateService) + +### 职责概述 +负责管理游戏中所有玩家的完整状态，包括位置、画线轨迹、领地、道具、统计数据等。这是整个游戏系统的核心服务。 + +### 核心方法详解 + +#### 🎮 基础状态管理 +- **`GetPlayerStateAsync`**: 获取玩家完整游戏状态 + - 返回玩家的所有信息：位置、状态、领地、道具、统计数据 + - 支持缓存机制，提高查询性能 + +- **`GetAllPlayerStatesAsync`**: 获取游戏中所有玩家状态 + - 用于排行榜显示和游戏监控 + - 批量查询优化，减少数据库负载 + +- **`InitializePlayerStateAsync`**: 初始化新玩家游戏状态 + - 分配专属颜色和出生点位置 + - 创建初始安全区域 + - 设置初始统计数据 + +#### 🏃 移动与绘制系统 +- **`UpdatePlayerPositionAsync`**: 更新玩家位置并处理移动逻辑 + - 验证移动合法性（速度限制、边界检查） + - 执行碰撞检测（边界、其他玩家轨迹） + - 如果正在画线，添加轨迹点 + - 更新移动统计数据 + +- **`StartDrawingAsync`**: 开始绘制领土线条 + - 验证玩家当前状态是否允许画线 + - 初始化绘制轨迹数据 + - 设置玩家状态为Drawing + +- **`StopDrawingAsync`**: 停止绘制并尝试形成领土 + - 验证绘制路径的完整性 + - 计算新领土面积 + - 检测是否夺取其他玩家领土 + - 更新玩家排名 + +#### 💀 死亡与复活机制 +- **`HandlePlayerDeathAsync`**: 处理玩家死亡 + - 清除当前绘制轨迹 + - 记录死亡统计 + - 启动复活倒计时（5秒） + - 通知其他玩家 + +- **`RespawnPlayerAsync`**: 复活玩家 + - 重新分配出生点 + - 设置无敌状态（3秒） + - 重置玩家状态为Moving + - 更新复活统计 + +#### 🎁 道具系统 +- **`PickupItemAsync`**: 拾取地图道具 + - 验证道具是否存在且可拾取 + - 检查背包空间 + - 更新玩家背包 + - 从地图移除道具 + +- **`UseItemAsync`**: 使用背包道具 + - 验证道具是否存在于背包 + - 根据道具类型执行不同效果 + - 更新玩家状态和效果时间 + - 记录道具使用统计 + +#### 📊 排名与统计 +- **`GetGameRankingAsync`**: 获取游戏实时排名 + - 按领土面积排序所有玩家 + - 计算面积占比和排名变化 + - 返回详细排名信息 + +- **`GetPlayerStatisticsAsync`**: 获取玩家详细统计 + - 移动距离、死亡次数、击杀次数 + - 道具使用情况、领土变化历史 + - 最大领土面积记录 + +--- + +## 2. 游戏玩法服务 (GamePlayService) + +### 职责概述 +管理游戏的核心玩法逻辑，处理玩家行为验证、游戏规则执行、事件处理等。 + +### 核心方法详解 + +#### 🎯 移动处理 +- **`ProcessPlayerMoveAsync`**: 处理玩家移动请求 + - 验证移动命令的合法性 + - 计算实际移动距离和方向 + - 检查移动限制（速度、边界） + - 返回移动结果和事件 + +#### ⚔️ 碰撞处理 +- **`HandleCollisionAsync`**: 处理碰撞事件 + - 判断碰撞类型（玩家身体、轨迹线、边界） + - 执行相应的碰撞后果 + - 更新玩家状态 + - 触发死亡或其他效果 + +#### 🏆 游戏结束 +- **`ProcessGameEndAsync`**: 处理游戏结束逻辑 + - 计算最终排名 + - 统计各玩家成绩 + - 保存游戏结果 + - 发送结束通知 + +--- + +## 3. 领地计算服务 (TerritoryService) + +### 职责概述 +专门负责领土面积计算、领地边界检测、领土变化处理等几何计算相关的业务逻辑。 + +### 核心方法详解 + +#### 📐 面积计算 +- **`CalculateTerritoryAreaAsync`**: 计算领土面积 + - 使用多边形面积算法 + - 处理复杂形状和自相交情况 + - 优化计算性能 + +- **`ValidateTerritory`**: 验证领土有效性 + - 检查边界是否闭合 + - 验证最小面积要求 + - 确保领土形状合理 + +#### 🎯 边界检测 +- **`CheckTerritoryBoundary`**: 检测点是否在领土内 + - 使用射线投射算法 + - 处理边界特殊情况 + - 支持批量检测优化 + +#### 🏴 领土争夺 +- **`ProcessTerritoryCapture`**: 处理领土夺取 + - 计算被夺取的领土面积 + - 更新领土归属 + - 重新计算相关玩家排名 + +--- + +## 4. 碰撞检测服务 (CollisionDetectionService) + +### 职责概述 +提供高性能的碰撞检测算法，支持点与线、线与线、点与区域的各种碰撞检测需求。 + +### 核心方法详解 + +#### 🎯 基础检测 +- **`CheckPointCollision`**: 检测点碰撞 + - 点与玩家身体碰撞 + - 点与轨迹线碰撞 + - 点与边界碰撞 + +- **`CheckLineCollision`**: 检测线段碰撞 + - 移动路径与轨迹线交叉 + - 绘制路径与现有领土重叠 + - 优化算法减少计算量 + +#### 🚀 性能优化 +- **空间分割**: 使用四叉树等数据结构提高检测效率 +- **批量检测**: 支持一次检测多个碰撞对象 +- **缓存机制**: 缓存频繁查询的碰撞结果 + +--- + +## 5. 广播通知服务 (GameBroadcastService) + +### 职责概述 +管理游戏中的实时消息广播，确保所有玩家及时收到游戏状态变化通知。 + +### 核心方法详解 + +#### 📢 消息广播 +- **`BroadcastToGameAsync`**: 向游戏中所有玩家广播消息 +- **`BroadcastToPlayerAsync`**: 向特定玩家发送消息 +- **`BroadcastGameEventAsync`**: 广播游戏事件（死亡、复活、道具使用等） + +#### 🔔 事件通知 +- **玩家移动通知**: 实时同步玩家位置变化 +- **领土变化通知**: 通知领土获得或失去 +- **道具效果通知**: 同步道具使用和效果 +- **游戏状态通知**: 游戏开始、暂停、结束等 + +--- + +## 6. 道具效果服务 (PowerUpService) + +### 职责概述 +管理游戏中各种道具的生成、效果处理、持续时间控制等逻辑。 + +### 核心方法详解 + +#### 🎁 道具生成 +- **`GenerateRandomPowerUpAsync`**: 随机生成地图道具 + - 根据游戏进程调整生成频率 + - 确保道具分布均匀 + - 避免在玩家领土内生成 + +#### ⚡ 效果处理 +- **`ApplyPowerUpEffectAsync`**: 应用道具效果 + - **加速药剂**: 提高移动速度30%，持续10秒 + - **保护盾**: 免疫一次碰撞死亡，持续15秒 + - **传送术**: 瞬间传送到指定位置 + - **炸弹**: 清除指定区域内的所有轨迹线 + - **冰冻术**: 冻结附近玩家8秒 + +#### ⏱️ 时间管理 +- **`UpdateActiveEffectsAsync`**: 更新活跃效果状态 +- **`RemoveExpiredEffectsAsync`**: 移除过期效果 +- **`GetRemainingTimeAsync`**: 获取效果剩余时间 + +--- + +## 7. 游戏状态服务 (GameStateService) + +### 职责概述 +管理整个游戏的全局状态，包括游戏阶段、计时器、参数配置等。 + +### 核心方法详解 + +#### 🎮 状态管理 +- **`GetGameStateAsync`**: 获取当前游戏状态 +- **`UpdateGameStateAsync`**: 更新游戏状态 +- **`StartGameAsync`**: 开始游戏 +- **`PauseGameAsync`**: 暂停游戏 +- **`EndGameAsync`**: 结束游戏 + +#### ⏰ 时间控制 +- **`GetRemainingTimeAsync`**: 获取游戏剩余时间 +- **`ExtendGameTimeAsync`**: 延长游戏时间 +- **`GetGameDurationAsync`**: 获取已进行时间 + +--- + +## 8. 结算统计服务 (GameResultService) + +### 职责概述 +负责游戏结束后的数据统计、排名计算、积分结算等业务逻辑。 + +### 核心方法详解 + +#### 🏆 结果计算 +- **`CalculateFinalRankingAsync`**: 计算最终排名 + - 按领土面积排序 + - 考虑特殊加分项 + - 处理平分情况 + +- **`GenerateGameSummaryAsync`**: 生成游戏总结报告 + - 详细的玩家表现统计 + - 游戏过程关键事件 + - 数据可视化支持 + +#### 💎 积分系统 +- **`CalculateScoreChangesAsync`**: 计算积分变化 + - 排名积分：第1名+100分，第2名+50分，第3名+25分 + - 领土积分：每1000平方单位+10分 + - 击杀积分：每击杀一名玩家+20分 + - 生存积分：存活时间越长积分越高 + +--- + +## 服务交互流程 + +### 典型游戏流程 + +1. **玩家加入游戏** + ``` + PlayerStateService.InitializePlayerStateAsync() + → GameBroadcastService.BroadcastToGameAsync() + ``` + +2. **玩家移动** + ``` + GamePlayService.ProcessPlayerMoveAsync() + → CollisionDetectionService.CheckPointCollision() + → PlayerStateService.UpdatePlayerPositionAsync() + → GameBroadcastService.BroadcastToGameAsync() + ``` + +3. **开始绘制** + ``` + PlayerStateService.StartDrawingAsync() + → GameBroadcastService.BroadcastGameEventAsync() + ``` + +4. **碰撞死亡** + ``` + CollisionDetectionService.CheckLineCollision() + → GamePlayService.HandleCollisionAsync() + → PlayerStateService.HandlePlayerDeathAsync() + → GameBroadcastService.BroadcastGameEventAsync() + ``` + +5. **形成领土** + ``` + PlayerStateService.StopDrawingAsync() + → TerritoryService.CalculateTerritoryAreaAsync() + → TerritoryService.ProcessTerritoryCapture() + → PlayerStateService.GetGameRankingAsync() + → GameBroadcastService.BroadcastToGameAsync() + ``` + +6. **道具使用** + ``` + PlayerStateService.UseItemAsync() + → PowerUpService.ApplyPowerUpEffectAsync() + → GameBroadcastService.BroadcastGameEventAsync() + ``` + +7. **游戏结束** + ``` + GameStateService.EndGameAsync() + → GameResultService.CalculateFinalRankingAsync() + → GameResultService.CalculateScoreChangesAsync() + → GameBroadcastService.BroadcastToGameAsync() + ``` + +--- + +## 性能优化策略 + +### 1. 缓存机制 +- **玩家状态缓存**: 使用内存缓存减少数据库查询 +- **碰撞检测缓存**: 缓存频繁检测的结果 +- **排名缓存**: 定期更新排名，避免实时计算 + +### 2. 异步处理 +- 所有服务方法都是异步的 +- 使用任务并行库处理批量操作 +- 事件驱动的消息处理 + +### 3. 数据结构优化 +- 使用空间索引加速碰撞检测 +- 采用高效的几何算法 +- 线程安全的并发集合 + +--- + +## 错误处理与日志 + +### 错误处理策略 +- 所有服务方法都包含完整的异常处理 +- 使用自定义异常类型区分不同错误 +- 提供详细的错误信息和恢复建议 + +### 日志记录 +- 记录所有关键操作和状态变化 +- 性能指标监控 +- 错误和异常追踪 +- 游戏数据分析支持 + +--- + +## 总结 + +这个服务架构设计遵循了以下原则： + +1. **单一职责**: 每个服务专注于特定的业务领域 +2. **低耦合**: 服务之间通过接口交互，减少依赖 +3. **高内聚**: 相关的功能组织在同一个服务中 +4. **可扩展**: 易于添加新功能和优化现有逻辑 +5. **可测试**: 每个服务都可以独立测试 +6. **高性能**: 优化关键路径，支持高并发 + +通过这种设计，我们创建了一个robust、scalable和maintainable的画线圈地游戏后端系统。 diff --git a/backend/src/CollabApp.API/CollabApp.API.csproj b/backend/src/CollabApp.API/CollabApp.API.csproj new file mode 100644 index 0000000000000000000000000000000000000000..957da69ef7ae8361e765b637137227aa7095b8d5 --- /dev/null +++ b/backend/src/CollabApp.API/CollabApp.API.csproj @@ -0,0 +1,25 @@ + + + + net9.0 + enable + enable + + + + + + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + + + + + + + + diff --git a/backend/src/CollabApp.API/CollabApp.API.http b/backend/src/CollabApp.API/CollabApp.API.http new file mode 100644 index 0000000000000000000000000000000000000000..501c392d7e28eccca177fd21da1352f15c56ca95 --- /dev/null +++ b/backend/src/CollabApp.API/CollabApp.API.http @@ -0,0 +1,2 @@ +@url = http://localhost:5128 + diff --git a/backend/src/CollabApp.API/DTOs/Game/GameControllerDTOs.cs b/backend/src/CollabApp.API/DTOs/Game/GameControllerDTOs.cs new file mode 100644 index 0000000000000000000000000000000000000000..05d1cd09dc930f89aafde1f730130f21648ba01a --- /dev/null +++ b/backend/src/CollabApp.API/DTOs/Game/GameControllerDTOs.cs @@ -0,0 +1,314 @@ +using CollabApp.Domain.Services.Game; + +namespace CollabApp.API.DTOs.Game; + +/// +/// 游戏控制器相关的数据传输对象 - 画线圈地游戏API接口 +/// + +#region 请求DTOs + +/// +/// 加入游戏请求 +/// +public class JoinGameRequest +{ + /// 游戏ID + public Guid GameId { get; set; } + + /// 玩家名称 + public string PlayerName { get; set; } = string.Empty; +} + +/// +/// 玩家移动请求 +/// +public class MovePlayerRequest +{ + /// 游戏ID + public Guid GameId { get; set; } + + /// 新位置X坐标 + public float X { get; set; } + + /// 新位置Y坐标 + public float Y { get; set; } + + /// 是否正在绘制 + public bool IsDrawing { get; set; } + + /// 时间戳 + public DateTime Timestamp { get; set; } = DateTime.UtcNow; +} + +/// +/// 开始绘制请求 +/// +public class StartDrawingRequest +{ + /// 游戏ID + public Guid GameId { get; set; } + + /// 起始位置X坐标 + public float X { get; set; } + + /// 起始位置Y坐标 + public float Y { get; set; } +} + +/// +/// 停止绘制请求 +/// +public class StopDrawingRequest +{ + /// 游戏ID + public Guid GameId { get; set; } + + /// 结束位置X坐标 + public float X { get; set; } + + /// 结束位置Y坐标 + public float Y { get; set; } +} + +/// +/// 使用道具请求 +/// +public class UseItemRequest +{ + /// 游戏ID + public Guid GameId { get; set; } + + /// 道具类型 + public string ItemType { get; set; } = string.Empty; + + /// 目标位置X坐标（可选） + public float? TargetX { get; set; } + + /// 目标位置Y坐标（可选） + public float? TargetY { get; set; } +} + +/// +/// 拾取道具请求 +/// +public class PickupItemRequest +{ + /// 游戏ID + public Guid GameId { get; set; } + + /// 道具ID + public Guid ItemId { get; set; } + + /// 道具位置X坐标 + public float X { get; set; } + + /// 道具位置Y坐标 + public float Y { get; set; } +} + +#endregion + +#region 响应DTOs + +/// +/// API响应基类 +/// +/// 数据类型 +public class ApiResponse +{ + /// 是否成功 + public bool Success { get; set; } + + /// 响应数据 + public T? Data { get; set; } + + /// 错误消息 + public string? Error { get; set; } + + /// 详细消息列表 + public List Messages { get; set; } = new(); + + /// 时间戳 + public DateTime Timestamp { get; set; } = DateTime.UtcNow; + + /// 创建成功响应 + public static ApiResponse CreateSuccess(T data, List? messages = null) + { + return new ApiResponse + { + Success = true, + Data = data, + Messages = messages ?? new List() + }; + } + + /// 创建错误响应 + public static ApiResponse CreateError(string error, List? messages = null) + { + return new ApiResponse + { + Success = false, + Error = error, + Messages = messages ?? new List() + }; + } +} + +/// +/// 玩家状态响应 +/// +public class PlayerStateResponse +{ + /// 玩家ID + public Guid PlayerId { get; set; } + + /// 玩家名称 + public string PlayerName { get; set; } = string.Empty; + + /// 玩家颜色 + public string PlayerColor { get; set; } = string.Empty; + + /// 当前位置 + public PositionDto CurrentPosition { get; set; } = new(); + + /// 当前状态 + public string State { get; set; } = string.Empty; + + /// 当前轨迹 + public List CurrentTrail { get; set; } = new(); + + /// 拥有的领土 + public List OwnedTerritories { get; set; } = new(); + + /// 领土总面积 + public float TotalTerritoryArea { get; set; } + + /// 背包道具 + public List Inventory { get; set; } = new(); + + /// 活跃效果 + public List ActiveEffects { get; set; } = new(); + + /// 是否无敌 + public bool IsInvulnerable { get; set; } + + /// 统计信息 + public PlayerStatisticsDto Statistics { get; set; } = new(); +} + +/// +/// 位置DTO +/// +public class PositionDto +{ + /// X坐标 + public float X { get; set; } + + /// Y坐标 + public float Y { get; set; } +} + +/// +/// 领土DTO +/// +public class TerritoryDto +{ + /// 领土ID + public Guid Id { get; set; } + + /// 所属玩家ID + public Guid PlayerId { get; set; } + + /// 边界点 + public List Boundary { get; set; } = new(); + + /// 面积 + public float Area { get; set; } +} + +/// +/// 活跃效果DTO +/// +public class ActiveEffectDto +{ + /// 效果ID + public Guid Id { get; set; } + + /// 效果类型 + public string EffectType { get; set; } = string.Empty; + + /// 开始时间 + public DateTime StartTime { get; set; } + + /// 持续时间（秒） + public int DurationSeconds { get; set; } + + /// 结束时间 + public DateTime EndTime { get; set; } + + /// 是否已过期 + public bool IsExpired { get; set; } +} + +/// +/// 玩家统计DTO +/// +public class PlayerStatisticsDto +{ + /// 死亡次数 + public int Deaths { get; set; } + + /// 击杀次数 + public int Kills { get; set; } + + /// 最大领土面积 + public float MaxTerritoryArea { get; set; } + + /// 总移动距离 + public float TotalDistanceMoved { get; set; } + + /// 使用道具数 + public int ItemsUsed { get; set; } + + /// 拾取道具数 + public int ItemsPickedUp { get; set; } + + /// 领土捕获次数 + public int TerritoryCaptures { get; set; } +} + +/// +/// 游戏排名响应 +/// +public class GameRankingResponse +{ + /// 排名 + public int Rank { get; set; } + + /// 玩家ID + public Guid PlayerId { get; set; } + + /// 玩家名称 + public string PlayerName { get; set; } = string.Empty; + + /// 玩家颜色 + public string PlayerColor { get; set; } = string.Empty; + + /// 领土面积 + public float TerritoryArea { get; set; } + + /// 领土数量 + public int TerritoryCount { get; set; } + + /// 面积占比 + public float AreaPercentage { get; set; } + + /// 当前状态 + public string CurrentState { get; set; } = string.Empty; + + /// 最后更新时间 + public DateTime LastUpdate { get; set; } +} + +#endregion diff --git a/backend/src/CollabApp.API/Hubs/GameHub.cs b/backend/src/CollabApp.API/Hubs/GameHub.cs new file mode 100644 index 0000000000000000000000000000000000000000..e1d038ec7273e89e698b02d88a21c0702d5f6339 --- /dev/null +++ b/backend/src/CollabApp.API/Hubs/GameHub.cs @@ -0,0 +1,603 @@ +using Microsoft.AspNetCore.SignalR; +using Microsoft.Extensions.Logging; +using CollabApp.Domain.Entities.Game; +using CollabApp.Domain.Repositories; +using CollabApp.Domain.Services.Game; +using System.Security.Claims; + +namespace CollabApp.API.Hubs; + +/// +/// 游戏实时通信Hub - 处理画线圈地游戏的实时交互 +/// 提供玩家移动、绘制、状态同步等实时功能，严格按照业务规则实现 +/// +public class GameHub : Hub +{ + private readonly IRepository _gameRepository; + private readonly IRepository _gamePlayerRepository; + private readonly IRepository _gameActionRepository; + private readonly IPlayerStateService _playerStateService; + private readonly IGamePlayService _gamePlayService; + private readonly ILogger _logger; + + public GameHub( + IRepository gameRepository, + IRepository gamePlayerRepository, + IRepository gameActionRepository, + IPlayerStateService playerStateService, + IGamePlayService gamePlayService, + ILogger logger) + { + _gameRepository = gameRepository; + _gamePlayerRepository = gamePlayerRepository; + _gameActionRepository = gameActionRepository; + _playerStateService = playerStateService; + _gamePlayService = gamePlayService; + _logger = logger; + } + + /// + /// 玩家加入游戏房间 + /// + /// 游戏ID + /// 玩家ID + public async Task JoinGameRoom(Guid gameId, Guid playerId) + { + try + { + // 验证游戏是否存在且可加入 + var game = await _gameRepository.GetByIdAsync(gameId); + if (game == null) + { + await Clients.Caller.SendAsync("Error", "游戏不存在"); + return; + } + + if (game.Status != GameStatus.Preparing && game.Status != GameStatus.Playing) + { + await Clients.Caller.SendAsync("Error", "游戏状态不允许加入"); + return; + } + + // 验证玩家是否在游戏中 - 使用UserId而不是PlayerId + var gamePlayer = (await _gamePlayerRepository.GetAllAsync()) + .FirstOrDefault(gp => gp.GameId == gameId && gp.UserId == playerId); + + if (gamePlayer == null) + { + await Clients.Caller.SendAsync("Error", "玩家未参与此游戏"); + return; + } + + // 获取玩家实时状态 + var playerState = await _playerStateService.GetPlayerStateAsync(gameId, playerId); + if (playerState == null) + { + await Clients.Caller.SendAsync("Error", "无法获取玩家状态"); + return; + } + + // 加入SignalR组 + var groupName = $"game_{gameId}"; + await Groups.AddToGroupAsync(Context.ConnectionId, groupName); + + // 通知房间内其他玩家 + await Clients.Group(groupName).SendAsync("PlayerJoined", new + { + PlayerId = playerId, + PlayerName = playerState.PlayerName, + PlayerColor = playerState.PlayerColor, + ConnectionId = Context.ConnectionId, + JoinedAt = DateTime.UtcNow + }); + + // 发送当前游戏状态给新加入的玩家 + var gameStates = await _playerStateService.GetAllPlayerStatesAsync(gameId); + + await Clients.Caller.SendAsync("GameState", new + { + GameId = gameId, + Status = game.Status.ToString(), + Players = gameStates.Select(p => new + { + p.PlayerId, + p.PlayerName, + p.PlayerColor, + Position = p.CurrentPosition, + Territory = p.TotalTerritoryArea, + State = p.State.ToString(), + CurrentTrail = p.CurrentTrail, + IsInvulnerable = p.IsInvulnerable, + InvulnerabilityEndTime = p.InvulnerabilityEndTime, + Inventory = p.Inventory, + Rank = p.CurrentRank + }).ToList(), + StartedAt = game.StartedAt, + FinishedAt = game.FinishedAt + }); + + _logger.LogInformation("玩家 {PlayerId} 加入游戏 {GameId} 的实时房间", playerId, gameId); + } + catch (Exception ex) + { + _logger.LogError(ex, "玩家加入游戏房间时发生错误: GameId={GameId}, PlayerId={PlayerId}", gameId, playerId); + await Clients.Caller.SendAsync("Error", "加入游戏房间失败"); + } + } + + /// + /// 玩家离开游戏房间 + /// + /// 游戏ID + /// 玩家ID + public async Task LeaveGameRoom(Guid gameId, Guid playerId) + { + try + { + var groupName = $"game_{gameId}"; + await Groups.RemoveFromGroupAsync(Context.ConnectionId, groupName); + + // 通知房间内其他玩家 + await Clients.Group(groupName).SendAsync("PlayerLeft", new + { + PlayerId = playerId, + ConnectionId = Context.ConnectionId, + LeftAt = DateTime.UtcNow + }); + + _logger.LogInformation("玩家 {PlayerId} 离开游戏 {GameId} 的实时房间", playerId, gameId); + } + catch (Exception ex) + { + _logger.LogError(ex, "玩家离开游戏房间时发生错误: GameId={GameId}, PlayerId={PlayerId}", gameId, playerId); + } + } + + /// + /// 玩家移动 - 使用完整的业务逻辑和Position类型 + /// + /// 游戏ID + /// 玩家ID + /// 新位置 + /// 是否正在绘制 + public async Task PlayerMove(Guid gameId, Guid playerId, Position newPosition, bool isDrawing) + { + try + { + // 验证游戏状态 + var game = await _gameRepository.GetByIdAsync(gameId); + if (game?.Status != GameStatus.Playing) + { + await Clients.Caller.SendAsync("Error", "游戏未进行中"); + return; + } + + // 验证玩家是否在游戏中 + var gamePlayer = (await _gamePlayerRepository.GetAllAsync()) + .FirstOrDefault(gp => gp.GameId == gameId && gp.UserId == playerId); + + if (gamePlayer == null) + { + await Clients.Caller.SendAsync("Error", "玩家不在游戏中"); + return; + } + + // 获取当前玩家状态 + var currentState = await _playerStateService.GetPlayerStateAsync(gameId, playerId); + if (currentState == null || currentState.State == PlayerDrawingState.Dead) + { + await Clients.Caller.SendAsync("Error", "玩家状态异常或已死亡"); + return; + } + + // 调用领域服务更新位置 + var moveResult = await _playerStateService.UpdatePlayerPositionAsync( + gameId, playerId, newPosition, DateTime.UtcNow, isDrawing); + + if (!moveResult.Success) + { + await Clients.Caller.SendAsync("MoveRejected", new + { + PlayerId = playerId, + Reason = string.Join("; ", moveResult.Errors), + OldPosition = moveResult.OldPosition, + Timestamp = DateTime.UtcNow + }); + return; + } + + // 记录移动动作 + var moveAction = GameAction.CreateGameAction( + gameId: gameId, + userId: playerId, + actionType: "Move", + actionData: $"{{\"from\":{moveResult.OldPosition},\"to\":{moveResult.NewPosition},\"isDrawing\":{isDrawing.ToString().ToLower()},\"speed\":{moveResult.CurrentSpeed}}}", + timestamp: DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() + ); + + await _gameActionRepository.AddAsync(moveAction); + + // 如果正在画线，开始或继续绘制 + if (isDrawing && currentState.State == PlayerDrawingState.Idle) + { + var drawingResult = await _playerStateService.StartDrawingAsync(gameId, playerId, newPosition); + if (!drawingResult.Success) + { + _logger.LogWarning("玩家 {PlayerId} 开始绘制失败: {Errors}", + playerId, string.Join("; ", drawingResult.Errors)); + } + } + + // 实时广播给房间内所有玩家 + var groupName = $"game_{gameId}"; + var broadcastData = new + { + PlayerId = playerId, + Position = moveResult.NewPosition, + OldPosition = moveResult.OldPosition, + Speed = moveResult.CurrentSpeed, + DistanceMoved = moveResult.DistanceMoved, + IsDrawing = isDrawing, + Events = moveResult.Events, + Timestamp = DateTime.UtcNow + }; + + await Clients.Group(groupName).SendAsync("PlayerMoved", broadcastData); + + // 如果有碰撞事件，特殊处理 + if (moveResult.CollisionDetected && moveResult.CollisionInfo != null) + { + await HandleCollisionEventAsync(gameId, playerId, moveResult.CollisionInfo); + } + + _logger.LogDebug("玩家 {PlayerId} 在游戏 {GameId} 中移动: {OldPos} -> {NewPos}, 速度: {Speed}", + playerId, gameId, moveResult.OldPosition, moveResult.NewPosition, moveResult.CurrentSpeed); + } + catch (Exception ex) + { + _logger.LogError(ex, "玩家移动时发生错误: GameId={GameId}, PlayerId={PlayerId}", gameId, playerId); + await Clients.Caller.SendAsync("Error", "移动失败"); + } + } + + /// + /// 玩家完成路径绘制 + /// + /// 游戏ID + /// 玩家ID + public async Task CompleteDrawing(Guid gameId, Guid playerId) + { + try + { + // 验证游戏状态 + var game = await _gameRepository.GetByIdAsync(gameId); + if (game?.Status != GameStatus.Playing) + { + await Clients.Caller.SendAsync("Error", "游戏未进行中"); + return; + } + + // 验证玩家是否在游戏中 + var gamePlayer = (await _gamePlayerRepository.GetAllAsync()) + .FirstOrDefault(gp => gp.GameId == gameId && gp.UserId == playerId); + + if (gamePlayer == null) + { + await Clients.Caller.SendAsync("Error", "玩家不在游戏中"); + return; + } + + // 获取当前玩家状态 + var currentState = await _playerStateService.GetPlayerStateAsync(gameId, playerId); + if (currentState == null || currentState.State != PlayerDrawingState.Drawing) + { + await Clients.Caller.SendAsync("Error", "玩家未在绘制状态"); + return; + } + + // 调用领域服务停止绘制 + var drawingResult = await _playerStateService.StopDrawingAsync( + gameId, playerId, currentState.CurrentPosition); + + if (!drawingResult.Success) + { + await Clients.Caller.SendAsync("DrawingFailed", new + { + PlayerId = playerId, + Reason = string.Join("; ", drawingResult.Errors), + Timestamp = DateTime.UtcNow + }); + return; + } + + // 记录完成绘制动作 + var completeAction = GameAction.CreateGameAction( + gameId: gameId, + userId: playerId, + actionType: "CompletePath", + actionData: $"{{\"path\":[{string.Join(",", drawingResult.CompletedTrail.Select(p => p.ToString()))}],\"areaGained\":{drawingResult.AreaGained},\"isClosedLoop\":{drawingResult.IsClosedLoop.ToString().ToLower()}}}", + timestamp: DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() + ); + + await _gameActionRepository.AddAsync(completeAction); + + // 如果成功获得新领土，计算并更新排名 + if (drawingResult.NewTerritory != null && drawingResult.AreaGained > 0) + { + var territoryResult = await _playerStateService.CalculatePlayerTerritoryAsync(gameId, playerId); + if (territoryResult.Success) + { + // 更新游戏排名 + var rankings = await _playerStateService.GetGameRankingAsync(gameId); + + // 广播排名更新 + var groupName = $"game_{gameId}"; + await Clients.Group(groupName).SendAsync("RankingUpdated", new + { + Rankings = rankings.Select(r => new + { + r.PlayerId, + r.PlayerName, + r.Rank, + r.TerritoryArea, + r.AreaPercentage + }).ToList(), + Timestamp = DateTime.UtcNow + }); + } + } + + // 实时广播给房间内所有玩家 + var groupName2 = $"game_{gameId}"; + await Clients.Group(groupName2).SendAsync("DrawingCompleted", new + { + PlayerId = playerId, + CompletedTrail = drawingResult.CompletedTrail, + NewTerritory = drawingResult.NewTerritory, + AreaGained = drawingResult.AreaGained, + IsClosedLoop = drawingResult.IsClosedLoop, + Messages = drawingResult.Messages, + Timestamp = DateTime.UtcNow + }); + + _logger.LogInformation("玩家 {PlayerId} 在游戏 {GameId} 中完成路径绘制，获得面积: {Area}", + playerId, gameId, drawingResult.AreaGained); + } + catch (Exception ex) + { + _logger.LogError(ex, "完成绘制时发生错误: GameId={GameId}, PlayerId={PlayerId}", gameId, playerId); + await Clients.Caller.SendAsync("Error", "完成绘制失败"); + } + } + + /// + /// 玩家使用道具 - 完整业务逻辑版本 + /// + /// 游戏ID + /// 玩家ID + /// 道具类型 + /// 目标玩家ID（如果需要） + public async Task UseItem(Guid gameId, Guid playerId, DrawingGameItemType itemType, Guid? targetPlayerId = null) + { + try + { + // 验证游戏状态 + var game = await _gameRepository.GetByIdAsync(gameId); + if (game?.Status != GameStatus.Playing) + { + await Clients.Caller.SendAsync("Error", "游戏未进行中"); + return; + } + + // 验证玩家是否在游戏中 + var gamePlayer = (await _gamePlayerRepository.GetAllAsync()) + .FirstOrDefault(gp => gp.GameId == gameId && gp.UserId == playerId); + + if (gamePlayer == null) + { + await Clients.Caller.SendAsync("Error", "玩家不在游戏中"); + return; + } + + // 获取当前玩家状态 + var currentState = await _playerStateService.GetPlayerStateAsync(gameId, playerId); + if (currentState == null || currentState.State == PlayerDrawingState.Dead) + { + await Clients.Caller.SendAsync("Error", "玩家状态异常或已死亡"); + return; + } + + // 调用领域服务使用道具 + var useResult = await _playerStateService.UseItemAsync( + gameId, playerId, itemType, currentState.CurrentPosition); + + if (!useResult.Success) + { + await Clients.Caller.SendAsync("ItemUseFailed", new + { + PlayerId = playerId, + ItemType = itemType.ToString(), + Reason = string.Join("; ", useResult.Errors), + Timestamp = DateTime.UtcNow + }); + return; + } + + // 记录使用道具动作 + var effectData = useResult.AppliedEffect != null ? + $"{{\"effectType\":\"{useResult.AppliedEffect.EffectType}\",\"duration\":{useResult.AppliedEffect.Duration.TotalSeconds}}}" : "null"; + var itemAction = GameAction.CreateGameAction( + gameId: gameId, + userId: playerId, + actionType: "UseItem", + actionData: $"{{\"itemType\":\"{itemType}\",\"targetPlayerId\":\"{targetPlayerId}\",\"appliedEffect\":{effectData},\"messages\":[{string.Join(",", useResult.Messages.Select(m => $"\"{m}\""))}]}}", + timestamp: DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() + ); + + await _gameActionRepository.AddAsync(itemAction); + + // 实时广播给房间内所有玩家 + var groupName = $"game_{gameId}"; + await Clients.Group(groupName).SendAsync("ItemUsed", new + { + PlayerId = playerId, + ItemType = itemType.ToString(), + TargetPlayerId = targetPlayerId, + AppliedEffect = useResult.AppliedEffect, + ClearedTrails = useResult.ClearedTrails, + AffectedPlayers = useResult.AffectedPlayers, + TargetPosition = useResult.TargetPosition, + Messages = useResult.Messages, + Timestamp = DateTime.UtcNow + }); + + // 如果道具影响其他玩家，单独通知目标玩家 + if (targetPlayerId.HasValue && useResult.AffectedPlayers?.Contains(targetPlayerId.Value) == true) + { + // 这里需要根据连接管理来找到目标玩家的ConnectionId + // 简化处理：通过组广播，让客户端自己判断 + await Clients.Group(groupName).SendAsync("PlayerAffectedByItem", new + { + AffectedPlayerId = targetPlayerId.Value, + SourcePlayerId = playerId, + ItemType = itemType.ToString(), + AppliedEffect = useResult.AppliedEffect, + Messages = useResult.Messages, + Timestamp = DateTime.UtcNow + }); + } + + _logger.LogInformation("玩家 {PlayerId} 在游戏 {GameId} 中使用道具 {ItemType}, 目标: {TargetPlayerId}, 消息: {Messages}", + playerId, gameId, itemType, targetPlayerId, string.Join("; ", useResult.Messages)); + } + catch (Exception ex) + { + _logger.LogError(ex, "使用道具时发生错误: GameId={GameId}, PlayerId={PlayerId}, ItemType={ItemType}", + gameId, playerId, itemType); + await Clients.Caller.SendAsync("Error", "使用道具失败"); + } + } + + /// + /// 连接断开时的处理 + /// + /// 异常信息 + /// + public override async Task OnDisconnectedAsync(Exception? exception) + { + try + { + // TODO: 从上下文中获取玩家信息并处理断线 + // 这里可以根据ConnectionId查找对应的玩家并通知其他玩家 + + _logger.LogInformation("连接 {ConnectionId} 断开", Context.ConnectionId); + + if (exception != null) + { + _logger.LogWarning(exception, "连接 {ConnectionId} 异常断开", Context.ConnectionId); + } + } + catch (Exception ex) + { + _logger.LogError(ex, "处理连接断开时发生错误: ConnectionId={ConnectionId}", Context.ConnectionId); + } + + await base.OnDisconnectedAsync(exception); + } + + /// + /// 连接建立时的处理 + /// + /// + public override async Task OnConnectedAsync() + { + try + { + _logger.LogInformation("新连接建立: {ConnectionId}", Context.ConnectionId); + await Clients.Caller.SendAsync("Connected", new { ConnectionId = Context.ConnectionId }); + } + catch (Exception ex) + { + _logger.LogError(ex, "处理连接建立时发生错误: ConnectionId={ConnectionId}", Context.ConnectionId); + } + + await base.OnConnectedAsync(); + } + + /// + /// 处理碰撞事件 - 内部辅助方法 + /// + /// 游戏ID + /// 玩家ID + /// 碰撞信息 + private async Task HandleCollisionEventAsync(Guid gameId, Guid playerId, PlayerCollisionInfo collisionInfo) + { + try + { + var groupName = $"game_{gameId}"; + + // 根据碰撞类型处理 + switch (collisionInfo.Type) + { + case DrawingGameCollisionType.TrailCollision: + // 轨迹碰撞 - 玩家死亡 + var collisionResult = await _playerStateService.HandleTrailCollisionAsync( + gameId, playerId, collisionInfo.CollisionPoint, collisionInfo.OtherPlayerId); + + if (collisionResult.PlayerDied) + { + await Clients.Group(groupName).SendAsync("PlayerDied", new + { + DeadPlayerId = playerId, + KillerId = collisionResult.KillerId, + KillerName = collisionResult.KillerName, + DeathReason = collisionResult.DeathReason, + CollisionPoint = collisionInfo.CollisionPoint, + ClearedTrail = collisionResult.ClearedTrail, + Timestamp = DateTime.UtcNow + }); + + _logger.LogInformation("玩家 {PlayerId} 在游戏 {GameId} 中死亡: {Reason}", + playerId, gameId, collisionResult.DeathReason); + } + break; + + case DrawingGameCollisionType.TerritoryEntry: + // 进入领地 - 仅通知 + await Clients.Group(groupName).SendAsync("PlayerEnteredTerritory", new + { + PlayerId = playerId, + TerritoryOwnerId = collisionInfo.OtherPlayerId, + EntryPoint = collisionInfo.CollisionPoint, + Timestamp = DateTime.UtcNow + }); + break; + + case DrawingGameCollisionType.BoundaryHit: + // 边界碰撞 - 阻止移动 + await Clients.Caller.SendAsync("BoundaryHit", new + { + PlayerId = playerId, + HitPoint = collisionInfo.CollisionPoint, + Timestamp = DateTime.UtcNow + }); + break; + + case DrawingGameCollisionType.ObstacleHit: + // 障碍物碰撞 - 阻止移动 + await Clients.Caller.SendAsync("ObstacleHit", new + { + PlayerId = playerId, + HitPoint = collisionInfo.CollisionPoint, + ObstacleId = collisionInfo.OtherPlayerId, // 这里用作障碍物ID + Timestamp = DateTime.UtcNow + }); + break; + } + } + catch (Exception ex) + { + _logger.LogError(ex, "处理碰撞事件时发生错误: GameId={GameId}, PlayerId={PlayerId}", gameId, playerId); + } + } +} diff --git a/backend/src/CollabApp.API/Middleware/README.md b/backend/src/CollabApp.API/Middleware/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1d09869d0a5992c1849d910e46ad5c9b8dec8777 --- /dev/null +++ b/backend/src/CollabApp.API/Middleware/README.md @@ -0,0 +1,44 @@ +# 中间件层 (Middleware) + +## 目的 +处理HTTP请求管道中的横切关注点，如异常处理、日志记录等。 + +## 内容 +- **异常中间件**: 全局异常捕获和处理 +- **日志中间件**: 请求和响应的日志记录 +- **认证中间件**: 用户身份验证和授权 +- **CORS中间件**: 跨域请求处理 + +## 特点 +- 在请求管道中执行 +- 处理横切关注点 +- 支持请求和响应的拦截 +- 可组合和可配置 + +## 示例 +```csharp +public class ExceptionHandlingMiddleware +{ + private readonly RequestDelegate _next; + private readonly ILogger _logger; + + public ExceptionHandlingMiddleware(RequestDelegate next, ILogger logger) + { + _next = next; + _logger = logger; + } + + public async Task InvokeAsync(HttpContext context) + { + try + { + await _next(context); + } + catch (Exception ex) + { + _logger.LogError(ex, "An unhandled exception occurred"); + await HandleExceptionAsync(context, ex); + } + } +} +``` diff --git a/backend/src/CollabApp.API/Program.cs b/backend/src/CollabApp.API/Program.cs new file mode 100644 index 0000000000000000000000000000000000000000..7fa725466a5d9294dd9024800802957bf6e8841f --- /dev/null +++ b/backend/src/CollabApp.API/Program.cs @@ -0,0 +1,178 @@ +using CollabApp.Infrastructure; +using CollabApp.Application; + +namespace CollabApp.API; + +public class Program +{ + public static void Main(string[] args) + { + var builder = WebApplication.CreateBuilder(args); + + // ==================================== + // 注册应用服务 + // ==================================== + RegisterApplicationServices(builder); + + // ==================================== + // 添加 CORS 服务 + // ==================================== + builder.Services.AddCors(options => + { + options.AddPolicy("AllowAll", + policy => policy + .AllowAnyOrigin() + .AllowAnyHeader() + .AllowAnyMethod()); + + // 为SignalR配置特定的CORS策略 + options.AddPolicy("SignalRPolicy", + policy => policy + .AllowAnyOrigin() + .AllowAnyHeader() + .AllowAnyMethod() + .SetIsOriginAllowed(_ => true)); + }); + + // ==================================== + // 配置数据库连接 + // ==================================== + ConfigureDatabase(builder); + + var app = builder.Build(); + + // ==================================== + // 数据库初始化 + // ==================================== + InitializeDatabase(app); + + // ==================================== + // 配置中间件管道 + // ==================================== + ConfigurePipeline(app); + + app.Run(); + } + + // 注册应用服务 + private static void RegisterApplicationServices(WebApplicationBuilder builder) + { + // Add services to the container. + // Learn more about configuring OpenAPI at https://aka.ms/aspnet/openapi + builder.Services.AddOpenApi(); + + // 注册基础设施层服务 + builder.Services.AddInfrastructure(builder.Configuration); + + // ==================================== + // 添加 SignalR 服务 + // ==================================== + builder.Services.AddSignalR(options => + { + // 配置SignalR选项 + options.EnableDetailedErrors = builder.Environment.IsDevelopment(); + options.KeepAliveInterval = TimeSpan.FromSeconds(15); + options.ClientTimeoutInterval = TimeSpan.FromSeconds(30); + options.HandshakeTimeout = TimeSpan.FromSeconds(15); + }); + + // ==================================== + // 添加控制器支持 + // ==================================== + builder.Services.AddControllers(); + + // ==================================== + // 添加身份验证支持（如果需要） + // ==================================== + // builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme) + // .AddJwtBearer(options => { ... }); + + // 注册应用层服务 + builder.Services.AddApplication(builder.Configuration); + + } + + // 配置中间件管道 + private static void ConfigurePipeline(WebApplication app) + { + // Configure the HTTP request pipeline. + if (app.Environment.IsDevelopment()) + { + app.MapOpenApi(); + } + + // 启用 CORS + app.UseCors("AllowAll"); + + // ==================================== + // 启用身份验证和授权（如果需要） + // ==================================== + // app.UseAuthentication(); + // app.UseAuthorization(); + + app.UseHttpsRedirection(); + + // ==================================== + // 映射控制器路由 + // ==================================== + app.MapControllers(); + + // ==================================== + // 映射 SignalR Hubs + // ==================================== + app.MapHub("/gameHub"); + + // ==================================== + // 测试端点（可删除） + // ==================================== + var summaries = new[] + { + "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching" + }; + + app.MapGet("/weatherforecast", () => + { + var forecast = Enumerable.Range(1, 5).Select(index => + new WeatherForecast + ( + DateOnly.FromDateTime(DateTime.Now.AddDays(index)), + Random.Shared.Next(-20, 55), + summaries[Random.Shared.Next(summaries.Length)] + )) + .ToArray(); + return forecast; + }) + .WithName("GetWeatherForecast"); + } + + // 配置数据库连接 + private static void ConfigureDatabase(WebApplicationBuilder builder) + { + var postgresConfig = builder.Configuration.GetConnectionString("Postgres"); + var redisConfig = builder.Configuration.GetConnectionString("Redis"); + // 这里可以添加数据库上下文的配置代码 + + + } + // 天气预报模型 + private record WeatherForecast(DateOnly Date, int TemperatureC, string? Summary) + { + public int TemperatureF => 32 + (int)(TemperatureC / 0.5556); + } + private static void InitializeDatabase(WebApplication app) + { + // 立即初始化数据库并添加系统数据 + using var scope = app.Services.CreateScope(); + try + { + // 使用新的数据库初始化服务 + } + catch (Exception ex) + { + // 处理数据库初始化异常 + var logger = scope.ServiceProvider.GetService>(); + logger?.LogError(ex, "数据库初始化失败"); + } + } +} + diff --git a/backend/src/CollabApp.API/Properties/launchSettings.json b/backend/src/CollabApp.API/Properties/launchSettings.json new file mode 100644 index 0000000000000000000000000000000000000000..839547a97a8b29a4454409e242b54d015a97bdc2 --- /dev/null +++ b/backend/src/CollabApp.API/Properties/launchSettings.json @@ -0,0 +1,23 @@ +{ + "$schema": "https://json.schemastore.org/launchsettings.json", + "profiles": { + "http": { + "commandName": "Project", + "dotnetRunMessages": true, + "launchBrowser": false, + "applicationUrl": "http://localhost:5128", + "environmentVariables": { + "ASPNETCORE_ENVIRONMENT": "Development" + } + }, + "https": { + "commandName": "Project", + "dotnetRunMessages": true, + "launchBrowser": false, + "applicationUrl": "https://localhost:7028;http://localhost:5128", + "environmentVariables": { + "ASPNETCORE_ENVIRONMENT": "Development" + } + } + } +} diff --git a/backend/src/CollabApp.API/appsettings.json b/backend/src/CollabApp.API/appsettings.json new file mode 100644 index 0000000000000000000000000000000000000000..40f897201ba322126255e76e212db6302631837e --- /dev/null +++ b/backend/src/CollabApp.API/appsettings.json @@ -0,0 +1,19 @@ +{ + "Logging": { + "LogLevel": { + "Default": "Information", + "Microsoft.AspNetCore": "Warning" + } + }, + "AllowedHosts": "*", + "ConnectionStrings": { + "pgsql": "server=gdsswshfxfcz.cn;port=5432;database=collabapp;uid=postgres;pwd=Wjy@13432773538@;", + "redis": "gdsswshfxfcz.cn:6379,password=wjy20040506,defaultDatabase=10" + }, + "Jwt": { + "SecretKey": "中华人民共和国万岁中华人民万岁中国共产党万岁毛主席万岁", + "Issuer": "CollabApp.API", + "Audience": "CollabApp.APIUser", + "ExpireMinutes": 120 + } +} \ No newline at end of file diff --git a/backend/src/CollabApp.Application/CollabApp.Application.csproj b/backend/src/CollabApp.Application/CollabApp.Application.csproj new file mode 100644 index 0000000000000000000000000000000000000000..045109eecaa4b5abe01edf6c5fa271db755b85a0 --- /dev/null +++ b/backend/src/CollabApp.Application/CollabApp.Application.csproj @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + net9.0 + enable + enable + + + diff --git a/backend/src/CollabApp.Application/Commands/README.md b/backend/src/CollabApp.Application/Commands/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1d8abd47088bf97f05a906b96ad7bfc40d3fa6d8 --- /dev/null +++ b/backend/src/CollabApp.Application/Commands/README.md @@ -0,0 +1,32 @@ +# 命令层 (Commands) + +## 目的 +实现CQRS模式中的命令端，处理写操作和业务逻辑执行。 + +## 内容 +- **命令定义**: 表示用户意图的数据结构 +- **命令处理器**: 执行具体业务逻辑的处理类 +- **命令验证**: 输入数据的验证逻辑 + +## 特点 +- 代表用户的操作意图 +- 包含修改数据的业务逻辑 +- 通过MediatR进行解耦 +- 支持事务处理 + +## 示例 +```csharp +public class CreateUserCommand : IRequest +{ + public string Name { get; set; } + public string Email { get; set; } +} + +public class CreateUserCommandHandler : IRequestHandler +{ + public async Task Handle(CreateUserCommand request, CancellationToken cancellationToken) + { + // 实现创建用户的业务逻辑 + } +} +``` diff --git a/backend/src/CollabApp.Application/DTOs/JwtSettings.cs b/backend/src/CollabApp.Application/DTOs/JwtSettings.cs new file mode 100644 index 0000000000000000000000000000000000000000..027488f8ab64d1137b74a4ee557814f8bc74d5f7 --- /dev/null +++ b/backend/src/CollabApp.Application/DTOs/JwtSettings.cs @@ -0,0 +1,24 @@ +namespace CollabApp.Application.DTOs; + +/// +/// Jwt 配置 +/// +public class JwtSettings +{ + /// + /// 密钥 + /// + public string SecretKey { get; set; } = string.Empty; + /// + /// 发行者 + /// + public string Issuer { get; set; } = string.Empty; + /// + /// 受众 + /// + public string Audience { get; set; } = string.Empty; + /// + /// 过期时间 + /// + public int ExpireMinutes { get; set; } = 120; +} \ No newline at end of file diff --git a/backend/src/CollabApp.Application/Interfaces/IJwtTokenService.cs b/backend/src/CollabApp.Application/Interfaces/IJwtTokenService.cs new file mode 100644 index 0000000000000000000000000000000000000000..13cbe19ab0113e201e8eb48cb3f347f72f438b99 --- /dev/null +++ b/backend/src/CollabApp.Application/Interfaces/IJwtTokenService.cs @@ -0,0 +1,15 @@ +namespace CollabApp.Application.Interfaces; + +/// +/// JWT令牌服务接口 +/// +public interface IJwtTokenService +{ + /// + /// 生成JWT令牌 + /// + /// 用户ID + /// 用户名 + /// JWT令牌 + string GenerateToken(Guid userId, string userName); +} \ No newline at end of file diff --git a/backend/src/CollabApp.Application/Interfaces/IRedisService.cs b/backend/src/CollabApp.Application/Interfaces/IRedisService.cs new file mode 100644 index 0000000000000000000000000000000000000000..683345127e9dd4dc3ba45743d4bee14f4ab407df --- /dev/null +++ b/backend/src/CollabApp.Application/Interfaces/IRedisService.cs @@ -0,0 +1,41 @@ +namespace CollabApp.Application.Interfaces; + +/// +/// Redis 服务接口 +/// 提供Redis数据库操作的统一接口，支持Hash、List、Set等数据结构 +/// +public interface IRedisService +{ + // Hash操作 + Task> GetHashAllAsync(string key); + Task HashSetAsync(string key, string field, string value); + Task HashDeleteAsync(string key, string field); + Task HashGetAsync(string key, string field); + Task SetHashMultipleAsync(string key, Dictionary hash); + Task SetHashAsync(string key, string field, string value); + + // List操作 + Task> ListRangeAsync(string key, long start = 0, long stop = -1); + Task ListLeftPushAsync(string key, string value); + Task ListRightPushAsync(string key, string value); + Task ListLeftPopAsync(string key); + Task ListRightPopAsync(string key); + Task ListPushAsync(string key, string value); + + // Set操作 + Task> GetSetMembersAsync(string key); + Task SetAddAsync(string key, string value); + Task SetRemoveAsync(string key, string value); + Task SetContainsAsync(string key, string value); + Task GetSetCardinalityAsync(string key); + + // String操作 + Task StringSetAsync(string key, string value, TimeSpan? expiry = null); + Task StringGetAsync(string key); + Task KeyDeleteAsync(string key); + Task KeyExistsAsync(string key); + + // 过期时间 + Task KeyExpireAsync(string key, TimeSpan expiry); + Task SetExpireAsync(string key, TimeSpan expiry); +} \ No newline at end of file diff --git a/backend/src/CollabApp.Application/Queries/README.md b/backend/src/CollabApp.Application/Queries/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f61d48ebeca47083b9f63d07d84251b10c01d457 --- /dev/null +++ b/backend/src/CollabApp.Application/Queries/README.md @@ -0,0 +1,31 @@ +# 查询层 (Queries) + +## 目的 +实现CQRS模式中的查询端，处理数据读取和展示逻辑。 + +## 内容 +- **查询定义**: 表示数据获取需求的结构 +- **查询处理器**: 执行具体查询逻辑的处理类 +- **查询优化**: 针对读取场景的性能优化 + +## 特点 +- 只读操作，不修改数据 +- 可以绕过领域模型直接访问数据 +- 针对UI需求优化数据结构 +- 支持复杂的数据聚合和筛选 + +## 示例 +```csharp +public class GetUserByIdQuery : IRequest +{ + public int UserId { get; set; } +} + +public class GetUserByIdQueryHandler : IRequestHandler +{ + public async Task Handle(GetUserByIdQuery request, CancellationToken cancellationToken) + { + // 实现用户查询逻辑 + } +} +``` diff --git a/backend/src/CollabApp.Application/ServiceCollectionExtenstion.cs b/backend/src/CollabApp.Application/ServiceCollectionExtenstion.cs new file mode 100644 index 0000000000000000000000000000000000000000..5263773653ccb6383ae9e2e8286426cd92e546e1 --- /dev/null +++ b/backend/src/CollabApp.Application/ServiceCollectionExtenstion.cs @@ -0,0 +1,20 @@ +using CollabApp.Application.Services.Auth; +using CollabApp.Domain.Services.Auth; +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.DependencyInjection; + +namespace CollabApp.Application; + +/// +/// 扩展方法。应用服务注册。 +/// +public static class ServiceCollectionExtenstion +{ + public static IServiceCollection AddApplication(this IServiceCollection services, IConfiguration configuration) + { + // 注册认证服务 + services.AddScoped(); + + return services; + } +} \ No newline at end of file diff --git a/backend/src/CollabApp.Application/Services/Auth/AuthService.cs b/backend/src/CollabApp.Application/Services/Auth/AuthService.cs new file mode 100644 index 0000000000000000000000000000000000000000..821b74b226353e9c3950b0c457f4f2c552ac65f9 --- /dev/null +++ b/backend/src/CollabApp.Application/Services/Auth/AuthService.cs @@ -0,0 +1,231 @@ +using CollabApp.Domain.Services.Auth; +using CollabApp.Domain.Entities.Auth; +using CollabApp.Domain.Repositories; +using CollabApp.Application.Interfaces; + +namespace CollabApp.Application.Services.Auth; + +/// +/// 认证服务实现 +/// +public class AuthService : IAuthService +{ + private readonly IRepository _userRep; + private readonly IJwtTokenService _jwtTokenService; + + /// + /// 认证服务实现 + /// + /// 用户仓储 + /// JWT令牌服务 + public AuthService(IRepository userRep, IJwtTokenService jwtTokenService) + { + _userRep = userRep; + _jwtTokenService = jwtTokenService; + } + + /// + /// 登录 + /// + /// 用户名 + /// 密码 + /// JWT令牌 + public async Task LoginAsync(string username, string password) + { + // 1. 查找用户 + var user = await _userRep.GetSingleAsync(u => u.Username == username); + if (user == null) + { + return new + { + Code = 1001, + Message = "用户不存在，请重新输入！！！", + Data = "用户不存在！" + }; + } + + // 2. 校验密码（使用User实体的实例方法） + if (!user.VerifyPassword(password)) + { + return new + { + Code = 1002, + Message = "密码错误，请重新输入！！！", + Data = "密码错误！" + }; + } + + // 3. 检查用户状态 + if (user.Status == UserStatus.Banned) + { + return new + { + Code = 1003, + Message = "用户被封禁，请联系管理员！！！", + Data = "用户被封禁！" + }; + } + + // 4. 生成JWT令牌和刷新令牌 + var token = _jwtTokenService.GenerateToken(user.Id, user.Username); + var refreshToken = Guid.NewGuid().ToString("N"); // 生成简单的刷新令牌 + var accessTokenExpires = DateTime.UtcNow.AddMinutes(120); // 刷新后的token还是两小时时效 + var refreshTokenExpires = DateTime.UtcNow.AddDays(7); //刷新token7天时效 + + // 5. 设置令牌信息 + user.SetTokens(token, refreshToken, accessTokenExpires, refreshTokenExpires); + await _userRep.UpdateAsync(user); + await _userRep.SaveChangesAsync(); + + // 6. 返回令牌和用户信息 + return new + { + Code = 1000, + Message = "登录成功！", + Data = new + { + Token = token, + RefreshToken = refreshToken, + AccessTokenExpires = accessTokenExpires, + RefreshTokenExpires = refreshTokenExpires, + } + }; + } + + /// + /// 注册 + /// + /// 用户名 + /// 密码 + /// 昵称 + /// JWT令牌 + public async Task RegisterAsync(string username, string password, string nickname) + { + // 1. 检查用户名是否已存在 + var existUser = await _userRep.GetSingleAsync(u => u.Username == username); + if (existUser != null) + { + return new + { + Code = 1001, + Message = "用户名已存在，请重新输入！！！", + Data = "用户名已存在！" + }; + } + + // 2. 创建新用户（使用User工厂方法） + var user = User.Create(username, password, nickname); + + // 3. 保存到仓储 + await _userRep.AddAsync(user); + await _userRep.SaveChangesAsync(); + + // 4. 返回注册成功信息 + return new + { + Code = 1000, + Message = "注册成功，请前往登录界面登录！", + Data = "注册成功！" + }; + } + + /// + /// 刷新令牌 + /// + /// 刷新令牌 + /// 新的JWT令牌 + public async Task RefreshTokenAsync(string refreshToken) + { + // 1. 查找用户 + var user = await _userRep.GetSingleAsync(u => u.RefreshToken == refreshToken); + if (user == null) + { + return new + { + Code = 1001, + Message = "无效的刷新令牌！", + Data = "RefreshToken无效！" + }; + } + + // 2. 校验刷新令牌是否过期 + if (!user.RefreshTokenExpiresAt.HasValue || user.RefreshTokenExpiresAt.Value < DateTime.UtcNow) + { + return new + { + Code = 1002, + Message = "刷新令牌已过期，请重新登录！", + Data = "RefreshToken已过期！" + }; + } + + // 3. 检查用户状态 + if (user.Status == UserStatus.Banned) + { + return new + { + Code = 1003, + Message = "用户被封禁，请联系管理员！", + Data = "用户被封禁！" + }; + } + + // 4. 生成新accessToken和新的refreshToken（可选，安全性更高） + var newAccessToken = _jwtTokenService.GenerateToken(user.Id, user.Username); + var newRefreshToken = Guid.NewGuid().ToString("N"); + var newAccessTokenExpires = DateTime.UtcNow.AddMinutes(120); + var newRefreshTokenExpires = DateTime.UtcNow.AddDays(7); + + // 5. 更新用户令牌信息 + user.SetTokens(newAccessToken, newRefreshToken, newAccessTokenExpires, newRefreshTokenExpires); + await _userRep.UpdateAsync(user); + await _userRep.SaveChangesAsync(); + + // 6. 返回新令牌 + return new + { + Code = 1000, + Message = "令牌刷新成功！", + Data = new + { + Token = newAccessToken, + RefreshToken = newRefreshToken, + AccessTokenExpires = newAccessTokenExpires, + RefreshTokenExpires = newRefreshTokenExpires + } + }; + } + + /// + /// 忘记密码 + /// + /// 用户名 + /// 新密码 + /// 操作结果 + public async Task ForgotPasswordAsync(string username, string newPassword) + { + // 1. 查找用户 + var user = await _userRep.GetSingleAsync(u => u.Username == username); + if (user == null) + { + return new + { + Code = 1001, + Message = "用户不存在！", + Data = "用户名无效！" + }; + } + + // 2. 更新密码 + user.UpdatePassword(newPassword); + await _userRep.UpdateAsync(user); + await _userRep.SaveChangesAsync(); + + return new + { + Code = 1000, + Message = "密码重置成功！", + Data = "密码已更新，请使用新密码登录。" + }; + } +} \ No newline at end of file diff --git a/backend/src/CollabApp.Application/Services/Game/CollisionDetectionService.cs b/backend/src/CollabApp.Application/Services/Game/CollisionDetectionService.cs new file mode 100644 index 0000000000000000000000000000000000000000..22506a375993d479389a4c13986d9f6874ab9046 --- /dev/null +++ b/backend/src/CollabApp.Application/Services/Game/CollisionDetectionService.cs @@ -0,0 +1,2502 @@ +using CollabApp.Application.Interfaces; +using CollabApp.Domain.Entities.Game; +using CollabApp.Domain.Services.Game; +using Microsoft.Extensions.Logging; +using System.Numerics; + +namespace CollabApp.Application.Services.Game; + +/// +/// 碰撞检测服务实现 +/// 负责处理圈地游戏中的各种碰撞检测逻辑，包括轨迹碰撞、边界检测、道具拾取等 +/// 采用高精度算法确保检测准确性，支持并发处理提升性能 +/// +public class CollisionDetectionService : ICollisionDetectionService +{ + private readonly ILogger _logger; + private readonly IRedisService _redisService; + + public CollisionDetectionService( + ILogger logger, + IRedisService redisService) + { + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + _redisService = redisService ?? throw new ArgumentNullException(nameof(redisService)); + } + + /// + /// 检测轨迹截断碰撞 + /// 使用线段相交算法检测玩家移动路径是否与其他玩家轨迹相交 + /// 这是游戏中最核心的死亡判定逻辑 + /// + /// 游戏标识 + /// 移动的玩家标识 + /// 移动起始位置 + /// 移动目标位置 + /// 该玩家是否正在画线 + /// 轨迹碰撞检测结果 + public async Task CheckTrailCollisionAsync( + Guid gameId, + Guid playerId, + Position fromPosition, + Position toPosition, + bool isDrawing) + { + try + { + _logger.LogDebug("开始检测玩家 {PlayerId} 的轨迹碰撞，从 ({FromX},{FromY}) 到 ({ToX},{ToY})", + playerId, fromPosition.X, fromPosition.Y, toPosition.X, toPosition.Y); + + var result = new TrailCollisionResult(); + + // 获取游戏状态数据 + var gameStateKey = $"game:{gameId}:state"; + var gameState = await _redisService.GetHashAllAsync(gameStateKey); + + if (!gameState.Any()) + { + _logger.LogWarning("游戏 {GameId} 状态不存在", gameId); + return result; + } + + // 获取当前玩家状态 + var playerStateKey = $"game:{gameId}:player:{playerId}"; + var playerState = await _redisService.GetHashAllAsync(playerStateKey); + + // 检查玩家是否有护盾或幽灵状态 + bool hasShield = playerState.ContainsKey("shield_active") && + bool.Parse(playerState["shield_active"]); + bool hasGhost = playerState.ContainsKey("ghost_active") && + bool.Parse(playerState["ghost_active"]); + + // 获取所有其他玩家的轨迹数据 + var playersKey = $"game:{gameId}:players"; + var allPlayers = await _redisService.GetSetMembersAsync(playersKey); + + foreach (var otherPlayerIdStr in allPlayers) + { + if (!Guid.TryParse(otherPlayerIdStr, out var otherPlayerId) || otherPlayerId == playerId) + continue; + + // 检查与其他玩家轨迹的碰撞 + var collisionPoint = await CheckLineSegmentCollisionAsync(gameId, playerId, otherPlayerId, + fromPosition, toPosition, isDrawing); + + if (collisionPoint != null) + { + result.HasCollision = true; + result.CollidedWithPlayerId = otherPlayerId; + result.CollisionPoint = collisionPoint; + + // 判断碰撞是否致命 + if (hasGhost) + { + result.CanPassThrough = true; + result.IsDeadly = false; + _logger.LogDebug("玩家 {PlayerId} 处于幽灵状态，可以穿越轨迹", playerId); + } + else if (hasShield && isDrawing) + { + result.ShieldBlocked = true; + result.IsDeadly = false; + _logger.LogDebug("玩家 {PlayerId} 护盾阻挡了致命碰撞", playerId); + + // 消耗护盾 + await _redisService.HashDeleteAsync(playerStateKey, "shield_active"); + } + else if (isDrawing) + { + result.IsDeadly = true; + result.CollisionType = "Trail"; + _logger.LogDebug("玩家 {PlayerId} 轨迹被截断，导致死亡", playerId); + } + + break; + } + } + + // 检查与自己轨迹的碰撞（自杀检测） + if (!result.HasCollision && isDrawing) + { + var selfCollisionPoint = await CheckSelfTrailCollisionAsync(gameId, playerId, fromPosition, toPosition); + if (selfCollisionPoint != null) + { + result.HasCollision = true; + result.CollidedWithPlayerId = playerId; + result.CollisionPoint = selfCollisionPoint; + result.IsDeadly = true; + result.CollisionType = "SelfTrail"; + _logger.LogDebug("玩家 {PlayerId} 与自己的轨迹碰撞", playerId); + } + } + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "检测轨迹碰撞时发生错误，GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new TrailCollisionResult(); + } + } + + /// + /// 检测两条线段是否相交的核心算法 + /// 使用向量叉积判断线段相交关系 + /// + private async Task CheckLineSegmentCollisionAsync( + Guid gameId, Guid currentPlayerId, Guid otherPlayerId, + Position fromPos, Position toPos, bool isDrawing) + { + try + { + // 获取其他玩家的当前轨迹 + var otherTrailKey = $"game:{gameId}:player:{otherPlayerId}:trail"; + var otherTrailData = await _redisService.ListRangeAsync(otherTrailKey); + + if (otherTrailData.Count < 2) return null; + + // 将轨迹数据转换为位置点 + var otherTrail = new List(); + foreach (var pointData in otherTrailData) + { + var parts = pointData.Split(','); + if (parts.Length >= 2 && + float.TryParse(parts[0], out float x) && + float.TryParse(parts[1], out float y)) + { + otherTrail.Add(new Position { X = x, Y = y }); + } + } + + // 检查当前移动线段与其他玩家轨迹的每个线段是否相交 + for (int i = 0; i < otherTrail.Count - 1; i++) + { + var trailStart = otherTrail[i]; + var trailEnd = otherTrail[i + 1]; + + var intersectionPoint = GetLineSegmentIntersection( + fromPos, toPos, trailStart, trailEnd); + + if (intersectionPoint != null) + { + return intersectionPoint; + } + } + + return null; + } + catch (Exception ex) + { + _logger.LogError(ex, "检查线段碰撞时发生错误"); + return null; + } + } + + /// + /// 计算两条线段的交点 + /// 使用参数方程和线性代数方法计算交点 + /// + private Position? GetLineSegmentIntersection(Position p1, Position p2, Position p3, Position p4) + { + var denominator = (p1.X - p2.X) * (p3.Y - p4.Y) - (p1.Y - p2.Y) * (p3.X - p4.X); + + // 平行线检测 + if (Math.Abs(denominator) < 1e-10) return null; + + var t = ((p1.X - p3.X) * (p3.Y - p4.Y) - (p1.Y - p3.Y) * (p3.X - p4.X)) / denominator; + var u = -((p1.X - p2.X) * (p1.Y - p3.Y) - (p1.Y - p2.Y) * (p1.X - p3.X)) / denominator; + + // 检查交点是否在两条线段上 + if (t >= 0 && t <= 1 && u >= 0 && u <= 1) + { + return new Position + { + X = p1.X + t * (p2.X - p1.X), + Y = p1.Y + t * (p2.Y - p1.Y) + }; + } + + return null; + } + + /// + /// 检测与自己轨迹的碰撞（自杀检测） + /// + private async Task CheckSelfTrailCollisionAsync( + Guid gameId, Guid playerId, Position fromPos, Position toPos) + { + try + { + var trailKey = $"game:{gameId}:player:{playerId}:trail"; + var trailData = await _redisService.ListRangeAsync(trailKey); + + if (trailData.Count < 4) return null; // 至少需要2个线段才可能自相交 + + var trail = new List(); + foreach (var pointData in trailData.Take(trailData.Count - 1)) // 排除最后一个点避免相邻检测 + { + var parts = pointData.Split(','); + if (parts.Length >= 2 && + float.TryParse(parts[0], out float x) && + float.TryParse(parts[1], out float y)) + { + trail.Add(new Position { X = x, Y = y }); + } + } + + // 检查当前移动与历史轨迹的交点（排除相邻线段） + for (int i = 0; i < trail.Count - 3; i++) + { + var intersectionPoint = GetLineSegmentIntersection( + fromPos, toPos, trail[i], trail[i + 1]); + + if (intersectionPoint != null) + { + return intersectionPoint; + } + } + + return null; + } + catch (Exception ex) + { + _logger.LogError(ex, "检查自我轨迹碰撞时发生错误"); + return null; + } + } + + /// + /// 检测地图边界碰撞 + /// 检查玩家移动是否超出圆形地图边界 + /// + /// 游戏标识 + /// 要检测的位置 + /// 边界碰撞结果 + public async Task CheckMapBoundaryAsync(Guid gameId, Position position) + { + try + { + _logger.LogDebug("检测地图边界碰撞，位置: ({X},{Y})", position.X, position.Y); + + var result = new BoundaryCollisionResult(); + + // 获取地图配置 + var gameConfigKey = $"game:{gameId}:config"; + var gameConfig = await _redisService.GetHashAllAsync(gameConfigKey); + + if (!gameConfig.Any()) + { + _logger.LogWarning("游戏 {GameId} 配置不存在", gameId); + return result; + } + + // 获取地图大小和中心点 + var mapWidth = float.Parse(gameConfig.GetValueOrDefault("map_width", "1000")); + var mapHeight = float.Parse(gameConfig.GetValueOrDefault("map_height", "1000")); + var mapRadius = Math.Min(mapWidth, mapHeight) / 2f; + var centerX = mapWidth / 2f; + var centerY = mapHeight / 2f; + + // 计算距离地图中心的距离 + var distanceFromCenter = (float)Math.Sqrt( + Math.Pow(position.X - centerX, 2) + Math.Pow(position.Y - centerY, 2)); + + result.DistanceFromCenter = distanceFromCenter; + result.MapRadius = mapRadius; + result.BoundaryType = "Circle"; + + // 检查是否超出边界 + if (distanceFromCenter > mapRadius) + { + result.IsOutOfBounds = true; + + // 计算修正后的有效位置（投影到边界上） + var angle = Math.Atan2(position.Y - centerY, position.X - centerX); + result.ValidPosition = new Position + { + X = centerX + (float)(mapRadius * Math.Cos(angle)), + Y = centerY + (float)(mapRadius * Math.Sin(angle)) + }; + + _logger.LogDebug("位置超出边界，原位置: ({X},{Y})，修正位置: ({ValidX},{ValidY})", + position.X, position.Y, result.ValidPosition.X, result.ValidPosition.Y); + } + else + { + result.ValidPosition = position; + } + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "检测地图边界碰撞时发生错误，GameId: {GameId}", gameId); + return new BoundaryCollisionResult { ValidPosition = position }; + } + } + + /// + /// 解析Redis中的障碍物数据为MapObstacle对象 + /// + private MapObstacle? ParseMapObstacle(Guid obstacleId, Dictionary obstacleData) + { + try + { + if (!obstacleData.ContainsKey("type")) return null; + + var obstacle = new MapObstacle + { + Id = obstacleId, + ObstacleType = obstacleData["type"], + IsDestructible = obstacleData.GetValueOrDefault("destructible", "false") == "true" + }; + + // 解析中心点 + if (obstacleData.ContainsKey("center_x") && obstacleData.ContainsKey("center_y")) + { + obstacle.Center = new Position + { + X = float.Parse(obstacleData["center_x"]), + Y = float.Parse(obstacleData["center_y"]) + }; + } + + // 解析半径（圆形障碍物） + if (obstacleData.ContainsKey("radius")) + { + obstacle.Radius = float.Parse(obstacleData["radius"]); + } + + // 解析边界点（多边形障碍物） + if (obstacleData.ContainsKey("boundary")) + { + var boundaryStr = obstacleData["boundary"]; + var points = boundaryStr.Split(';'); + + foreach (var pointStr in points) + { + var coords = pointStr.Split(','); + if (coords.Length >= 2 && + float.TryParse(coords[0], out float x) && + float.TryParse(coords[1], out float y)) + { + obstacle.Boundary.Add(new Position { X = x, Y = y }); + } + } + } + + return obstacle; + } + catch (Exception ex) + { + _logger.LogError(ex, "解析障碍物数据时发生错误，ObstacleId: {ObstacleId}", obstacleId); + return null; + } + } + + /// + /// 检测线段与圆形的碰撞 + /// 使用精确的几何算法，考虑边界情况和数值精度 + /// + private bool CheckLineCircleCollision(Position lineStart, Position lineEnd, Position circleCenter, float radius) + { + // 将坐标转换为相对于圆心的坐标系 + var relativeStart = new Vector2(lineStart.X - circleCenter.X, lineStart.Y - circleCenter.Y); + var relativeEnd = new Vector2(lineEnd.X - circleCenter.X, lineEnd.Y - circleCenter.Y); + + // 检查端点是否在圆内 + if (relativeStart.LengthSquared() <= radius * radius || + relativeEnd.LengthSquared() <= radius * radius) + { + return true; + } + + // 计算线段向量 + var lineVector = relativeEnd - relativeStart; + var lineLength = lineVector.Length(); + + if (lineLength < 1e-6f) // 线段长度几乎为0 + { + return relativeStart.LengthSquared() <= radius * radius; + } + + // 标准化线段向量 + var normalizedLine = lineVector / lineLength; + + // 计算圆心到线段起点的向量 + var toStart = -relativeStart; + + // 计算投影长度 + var projectionLength = Vector2.Dot(toStart, normalizedLine); + + // 限制投影在线段范围内 + projectionLength = Math.Max(0, Math.Min(lineLength, projectionLength)); + + // 计算线段上最近点 + var closestPoint = relativeStart + normalizedLine * projectionLength; + + // 检查最近点到圆心的距离 + var distanceSquared = closestPoint.LengthSquared(); + var radiusSquared = radius * radius; + + return distanceSquared <= radiusSquared; + } + + /// + /// 检测线段与多边形的碰撞 + /// 检查线段是否与多边形的任何边相交 + /// + private bool CheckLinePolygonCollision(Position lineStart, Position lineEnd, List polygon) + { + if (polygon.Count < 3) return false; + + // 检查线段与多边形每条边是否相交 + for (int i = 0; i < polygon.Count; i++) + { + var polyStart = polygon[i]; + var polyEnd = polygon[(i + 1) % polygon.Count]; + + if (GetLineSegmentIntersection(lineStart, lineEnd, polyStart, polyEnd) != null) + { + return true; + } + } + + return false; + } + + /// + /// 计算绕过障碍物的有效位置 + /// 使用A*寻路算法的简化版本，找到绕过障碍物的最佳路径 + /// + private Position CalculateValidPositionAroundObstacles(Position fromPosition, Position toPosition, List obstacles) + { + // 如果没有障碍物，直接返回目标位置 + if (!obstacles.Any()) return toPosition; + + // 尝试多个避障方向 + var avoidanceDirections = new[] + { + new Vector2(0, 1), // 上 + new Vector2(0, -1), // 下 + new Vector2(-1, 0), // 左 + new Vector2(1, 0), // 右 + new Vector2(-1, 1), // 左上 + new Vector2(1, 1), // 右上 + new Vector2(-1, -1), // 左下 + new Vector2(1, -1) // 右下 + }; + + const float AVOIDANCE_STEP = 10f; + const int MAX_ATTEMPTS = 8; + + // 尝试每个方向，找到第一个无碰撞的位置 + for (int attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) + { + var stepSize = AVOIDANCE_STEP * attempt; + + foreach (var direction in avoidanceDirections) + { + var candidatePosition = new Position + { + X = fromPosition.X + direction.X * stepSize, + Y = fromPosition.Y + direction.Y * stepSize + }; + + // 检查这个位置是否与所有障碍物都无碰撞 + bool hasCollision = false; + foreach (var obstacle in obstacles) + { + if (obstacle.ObstacleType == "Circular") + { + var distance = CalculateDistance(candidatePosition, obstacle.Center); + if (distance <= obstacle.Radius + 2f) // 额外2像素安全距离 + { + hasCollision = true; + break; + } + } + else + { + if (IsPointInPolygon(candidatePosition, obstacle.Boundary)) + { + hasCollision = true; + break; + } + } + } + + if (!hasCollision) + { + return candidatePosition; + } + } + } + + // 如果所有方向都被阻挡，返回起始位置 + return fromPosition; + } + + /// + /// 解析Redis中的道具数据为PickupablePowerUp对象 + /// + private PickupablePowerUp? ParsePickupablePowerUp(Guid powerUpId, Dictionary powerUpData) + { + try + { + if (!powerUpData.ContainsKey("type") || !powerUpData.ContainsKey("position_x") || !powerUpData.ContainsKey("position_y")) + return null; + + // 解析道具类型 + if (!Enum.TryParse(powerUpData["type"], out var powerUpType)) + return null; + + var powerUp = new PickupablePowerUp + { + Id = powerUpId, + Type = powerUpType, + Position = new Position + { + X = float.Parse(powerUpData["position_x"]), + Y = float.Parse(powerUpData["position_y"]) + }, + IsPickupable = powerUpData.GetValueOrDefault("status", "") == "active" + }; + + // 解析生成时间 + if (powerUpData.ContainsKey("spawn_time") && DateTime.TryParse(powerUpData["spawn_time"], out var spawnTime)) + { + powerUp.SpawnTime = spawnTime; + } + + return powerUp; + } + catch (Exception ex) + { + _logger.LogError(ex, "解析道具数据时发生错误，PowerUpId: {PowerUpId}", powerUpId); + return null; + } + } + + /// + /// 计算两点之间的欧几里得距离 + /// + private float CalculateDistance(Position pos1, Position pos2) + { + var dx = pos1.X - pos2.X; + var dy = pos1.Y - pos2.Y; + return (float)Math.Sqrt(dx * dx + dy * dy); + } + + /// + /// 检查位置的领地归属 + /// + private async Task CheckPositionTerritoryOwnershipAsync(Guid gameId, Position position) + { + try + { + // 获取所有玩家的领地数据 + var playersKey = $"game:{gameId}:players"; + var allPlayers = await _redisService.GetSetMembersAsync(playersKey); + + foreach (var playerIdStr in allPlayers) + { + if (!Guid.TryParse(playerIdStr, out var ownerId)) + continue; + + // 获取玩家领地边界 + var territoryKey = $"game:{gameId}:player:{ownerId}:territory"; + var territoryData = await _redisService.ListRangeAsync(territoryKey); + + if (territoryData.Count < 3) continue; // 至少需要3个点构成区域 + + var territory = new List(); + foreach (var pointData in territoryData) + { + var parts = pointData.Split(','); + if (parts.Length >= 2 && + float.TryParse(parts[0], out float x) && + float.TryParse(parts[1], out float y)) + { + territory.Add(new Position { X = x, Y = y }); + } + } + + // 检查位置是否在这个玩家的领地内 + if (IsPointInPolygon(position, territory)) + { + return new TerritoryOwnershipInfo + { + OwnerId = ownerId, + IsOwned = true, + IsNeutralZone = false + }; + } + } + + // 如果不在任何玩家领地内，则为中立区域 + return new TerritoryOwnershipInfo + { + OwnerId = null, + IsOwned = false, + IsNeutralZone = true + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "检查位置领地归属时发生错误"); + return null; + } + } + + /// + /// 判断点是否在多边形内部 + /// 使用射线交点算法 + /// + private bool IsPointInPolygon(Position point, List polygon) + { + if (polygon.Count < 3) return false; + + bool inside = false; + int j = polygon.Count - 1; + + for (int i = 0; i < polygon.Count; i++) + { + var pi = polygon[i]; + var pj = polygon[j]; + + if (((pi.Y > point.Y) != (pj.Y > point.Y)) && + (point.X < (pj.X - pi.X) * (point.Y - pi.Y) / (pj.Y - pi.Y) + pi.X)) + { + inside = !inside; + } + j = i; + } + + return inside; + } + + /// + /// 获取玩家名称 + /// + private async Task GetPlayerNameAsync(Guid gameId, Guid playerId) + { + try + { + var playerKey = $"game:{gameId}:player:{playerId}:info"; + var playerInfo = await _redisService.GetHashAllAsync(playerKey); + return playerInfo.GetValueOrDefault("name", playerId.ToString()[..8]); + } + catch (Exception ex) + { + _logger.LogError(ex, "获取玩家名称时发生错误"); + return playerId.ToString()[..8]; + } + } + + /// + /// 确定领地转换类型 + /// + private TerritoryTransitionType DetermineTransitionType(TerritoryOwnershipInfo? previous, TerritoryOwnershipInfo? current) + { + if (previous?.IsNeutralZone == true && current?.IsOwned == true) + return TerritoryTransitionType.NeutralToOwned; + + if (previous?.IsOwned == true && current?.IsNeutralZone == true) + return TerritoryTransitionType.OwnedToNeutral; + + if (previous?.IsOwned == true && current?.IsOwned == true && previous.OwnerId != current.OwnerId) + return TerritoryTransitionType.OwnedToOtherOwned; + + return TerritoryTransitionType.NoChange; + } + + /// + /// 计算速度修正值 + /// 根据领地归属和转换类型计算移动速度修正 + /// + private float CalculateSpeedModifier(Guid playerId, TerritoryOwnershipInfo? ownership, TerritoryTransitionType transitionType) + { + // 基础速度 + float modifier = 1.0f; + + if (ownership?.IsOwned == true) + { + if (ownership.OwnerId == playerId) + { + // 在自己领地内：速度提升15% + modifier = 1.15f; + } + else + { + // 在敌方领地内：速度降低20% + modifier = 0.8f; + } + } + + return modifier; + } + + /// + /// 领地归属信息内部类 + /// + private class TerritoryOwnershipInfo + { + public Guid? OwnerId { get; set; } + public bool IsOwned { get; set; } + public bool IsNeutralZone { get; set; } + } + + /// + /// 计算点到线段的最短距离 + /// + private float CalculatePointToLineSegmentDistance(Position point, Position lineStart, Position lineEnd) + { + // 线段向量 + var lineVector = new Vector2(lineEnd.X - lineStart.X, lineEnd.Y - lineStart.Y); + var lineLength = lineVector.Length(); + + if (lineLength == 0) + return CalculateDistance(point, lineStart); + + // 点到线段起点的向量 + var pointVector = new Vector2(point.X - lineStart.X, point.Y - lineStart.Y); + + // 计算投影长度（标量投影） + var projection = Vector2.Dot(pointVector, lineVector) / lineLength; + + // 限制投影在线段范围内 + projection = Math.Max(0, Math.Min(lineLength, projection)); + + // 计算投影点 + var normalizedLineVector = lineVector / lineLength; + var projectionPoint = new Vector2(lineStart.X, lineStart.Y) + normalizedLineVector * projection; + + // 计算距离 + return Vector2.Distance(new Vector2(point.X, point.Y), projectionPoint); + } + + /// + /// 找到线段上距离指定点最近的点 + /// + private Position FindNearestPointOnLineSegment(Position point, Position lineStart, Position lineEnd) + { + var lineVector = new Vector2(lineEnd.X - lineStart.X, lineEnd.Y - lineStart.Y); + var lineLength = lineVector.Length(); + + if (lineLength == 0) + return lineStart; + + var pointVector = new Vector2(point.X - lineStart.X, point.Y - lineStart.Y); + var projection = Vector2.Dot(pointVector, lineVector) / lineLength; + + projection = Math.Max(0, Math.Min(lineLength, projection)); + + var normalizedLineVector = lineVector / lineLength; + var nearestPoint = new Vector2(lineStart.X, lineStart.Y) + normalizedLineVector * projection; + + return new Position { X = nearestPoint.X, Y = nearestPoint.Y }; + } + + /// + /// 计算威胁等级 + /// + private ThreatLevel CalculateThreatLevel(float distance, float warningDistance) + { + var ratio = distance / warningDistance; + + if (ratio <= 0.3f) return ThreatLevel.Critical; + if (ratio <= 0.5f) return ThreatLevel.High; + if (ratio <= 0.7f) return ThreatLevel.Medium; + if (ratio <= 1.0f) return ThreatLevel.Low; + + return ThreatLevel.None; + } + + // 其他方法将在后续逐步实现... + + /// + /// 检测障碍物碰撞 + /// 检测玩家移动路径是否与地图中的固定障碍物或可破坏障碍物相交 + /// + /// 游戏标识 + /// 移动起始位置 + /// 移动目标位置 + /// 障碍物碰撞结果 + public async Task CheckObstacleCollisionAsync(Guid gameId, Position fromPosition, Position toPosition) + { + try + { + _logger.LogDebug("检测障碍物碰撞，从 ({FromX},{FromY}) 到 ({ToX},{ToY})", + fromPosition.X, fromPosition.Y, toPosition.X, toPosition.Y); + + var result = new ObstacleCollisionResult(); + + // 获取地图障碍物配置 + var obstaclesKey = $"game:{gameId}:obstacles"; + var obstacleIds = await _redisService.GetSetMembersAsync(obstaclesKey); + + if (!obstacleIds.Any()) + { + _logger.LogDebug("游戏 {GameId} 没有配置障碍物", gameId); + result.ValidPosition = toPosition; + return result; + } + + var collidedObstacles = new List(); + + foreach (var obstacleIdStr in obstacleIds) + { + if (!Guid.TryParse(obstacleIdStr, out var obstacleId)) + continue; + + // 获取障碍物详细信息 + var obstacleKey = $"game:{gameId}:obstacle:{obstacleId}"; + var obstacleData = await _redisService.GetHashAllAsync(obstacleKey); + + if (!obstacleData.Any()) continue; + + var obstacle = ParseMapObstacle(obstacleId, obstacleData); + if (obstacle == null) continue; + + // 检测与障碍物的碰撞 + bool hasCollision = false; + + if (obstacle.ObstacleType == "Circular") + { + // 圆形障碍物碰撞检测 + hasCollision = CheckLineCircleCollision(fromPosition, toPosition, obstacle.Center, obstacle.Radius); + } + else + { + // 多边形障碍物碰撞检测 + hasCollision = CheckLinePolygonCollision(fromPosition, toPosition, obstacle.Boundary); + } + + if (hasCollision) + { + result.HasCollision = true; + collidedObstacles.Add(obstacle); + + _logger.LogDebug("检测到与障碍物 {ObstacleId} 的碰撞，类型: {Type}", + obstacleId, obstacle.ObstacleType); + } + } + + result.CollidedObstacles = collidedObstacles; + + // 如果有碰撞，计算有效的移动位置 + if (result.HasCollision) + { + result.ValidPosition = CalculateValidPositionAroundObstacles(fromPosition, toPosition, collidedObstacles); + result.BlocksMovement = true; + } + else + { + result.ValidPosition = toPosition; + result.BlocksMovement = false; + } + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "检测障碍物碰撞时发生错误，GameId: {GameId}", gameId); + return new ObstacleCollisionResult { ValidPosition = toPosition }; + } + } + + /// + /// 检测道具拾取碰撞 + /// 检测玩家是否接近地图上的道具，支持自定义拾取半径 + /// + /// 游戏标识 + /// 玩家标识 + /// 玩家当前位置 + /// 拾取范围，默认20像素 + /// 道具拾取碰撞结果 + public async Task CheckPowerUpPickupAsync(Guid gameId, Guid playerId, Position playerPosition, float pickupRadius = 20f) + { + try + { + _logger.LogDebug("检测道具拾取碰撞，玩家 {PlayerId}，位置: ({X},{Y})，半径: {Radius}", + playerId, playerPosition.X, playerPosition.Y, pickupRadius); + + var result = new PowerUpPickupCollisionResult(); + + // 检查玩家是否已持有道具 + var playerStateKey = $"game:{gameId}:player:{playerId}"; + var playerState = await _redisService.GetHashAllAsync(playerStateKey); + + bool hasActivePowerUp = playerState.ContainsKey("active_powerup") && + !string.IsNullOrEmpty(playerState["active_powerup"]); + + if (hasActivePowerUp) + { + _logger.LogDebug("玩家 {PlayerId} 已持有道具，无法拾取新道具", playerId); + return result; + } + + // 获取地图上的所有道具 + var powerUpsKey = $"game:{gameId}:powerups"; + var powerUpIds = await _redisService.GetSetMembersAsync(powerUpsKey); + + if (!powerUpIds.Any()) + { + _logger.LogDebug("游戏 {GameId} 地图上没有道具", gameId); + return result; + } + + var nearbyPowerUps = new List(); + PickupablePowerUp? closestPowerUp = null; + float closestDistance = float.MaxValue; + + foreach (var powerUpIdStr in powerUpIds) + { + if (!Guid.TryParse(powerUpIdStr, out var powerUpId)) + continue; + + // 获取道具详细信息 + var powerUpKey = $"game:{gameId}:powerup:{powerUpId}"; + var powerUpData = await _redisService.GetHashAllAsync(powerUpKey); + + if (!powerUpData.Any() || powerUpData.GetValueOrDefault("status", "") != "active") + continue; + + var powerUp = ParsePickupablePowerUp(powerUpId, powerUpData); + if (powerUp == null) continue; + + // 计算距离 + var distance = CalculateDistance(playerPosition, powerUp.Position); + powerUp.DistanceFromPlayer = distance; + + // 检查是否在拾取范围内 + if (distance <= pickupRadius) + { + powerUp.IsPickupable = true; + nearbyPowerUps.Add(powerUp); + + // 记录最近的道具 + if (distance < closestDistance) + { + closestDistance = distance; + closestPowerUp = powerUp; + } + + _logger.LogDebug("检测到可拾取道具 {PowerUpId}，类型: {Type}，距离: {Distance}", + powerUpId, powerUp.Type, distance); + } + else if (distance <= pickupRadius * 2) // 预警范围 + { + nearbyPowerUps.Add(powerUp); + } + } + + result.NearbyPowerUps = nearbyPowerUps; + result.ClosestPowerUp = closestPowerUp; + result.ClosestDistance = closestDistance; + result.CanPickup = closestPowerUp != null; + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "检测道具拾取碰撞时发生错误，GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new PowerUpPickupCollisionResult(); + } + } + + /// + /// 检测领地进入/离开 + /// 检测玩家移动是否导致领地归属变化，用于触发速度修正和视觉效果 + /// + /// 游戏标识 + /// 移动的玩家标识 + /// 移动起始位置 + /// 移动目标位置 + /// 领地转换结果 + public async Task CheckTerritoryTransitionAsync(Guid gameId, Guid playerId, Position fromPosition, Position toPosition) + { + try + { + _logger.LogDebug("检测领地转换，玩家 {PlayerId}，从 ({FromX},{FromY}) 到 ({ToX},{ToY})", + playerId, fromPosition.X, fromPosition.Y, toPosition.X, toPosition.Y); + + var result = new TerritoryTransitionResult(); + + // 检测起始位置的领地归属 + var previousOwnership = await CheckPositionTerritoryOwnershipAsync(gameId, fromPosition); + + // 检测目标位置的领地归属 + var currentOwnership = await CheckPositionTerritoryOwnershipAsync(gameId, toPosition); + + // 判断是否发生了领地转换 + if (previousOwnership?.OwnerId != currentOwnership?.OwnerId) + { + result.TerritoryChanged = true; + result.PreviousOwnerId = previousOwnership?.OwnerId; + result.CurrentOwnerId = currentOwnership?.OwnerId; + + // 获取玩家名称信息 + if (result.PreviousOwnerId.HasValue) + { + result.PreviousOwnerName = await GetPlayerNameAsync(gameId, result.PreviousOwnerId.Value); + } + + if (result.CurrentOwnerId.HasValue) + { + result.CurrentOwnerName = await GetPlayerNameAsync(gameId, result.CurrentOwnerId.Value); + } + + // 确定转换类型 + result.TransitionType = DetermineTransitionType(previousOwnership, currentOwnership); + + // 计算速度修正 + result.SpeedModifier = CalculateSpeedModifier(playerId, currentOwnership, result.TransitionType); + + _logger.LogDebug("检测到领地转换，玩家 {PlayerId}，转换类型: {TransitionType}，速度修正: {SpeedModifier}", + playerId, result.TransitionType, result.SpeedModifier); + } + else + { + result.SpeedModifier = CalculateSpeedModifier(playerId, currentOwnership, TerritoryTransitionType.NoChange); + } + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "检测领地转换时发生错误，GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new TerritoryTransitionResult { SpeedModifier = 1.0f }; + } + } + + /// + /// 检测轨迹预警 + /// 当敌方玩家接近自己的轨迹时发出预警，提醒玩家注意危险 + /// + /// 游戏标识 + /// 轨迹所有者 + /// 威胁玩家位置 + /// 预警距离，默认3像素 + /// 轨迹预警结果 + public async Task CheckTrailWarningAsync(Guid gameId, Guid playerId, Position threatPlayerPosition, float warningDistance = 3f) + { + try + { + _logger.LogDebug("检测轨迹预警，玩家 {PlayerId}，威胁位置: ({X},{Y})，预警距离: {Distance}", + playerId, threatPlayerPosition.X, threatPlayerPosition.Y, warningDistance); + + var result = new TrailWarningResult(); + + // 获取目标玩家的当前轨迹 + var trailKey = $"game:{gameId}:player:{playerId}:trail"; + var trailData = await _redisService.ListRangeAsync(trailKey); + + if (trailData.Count < 2) + { + _logger.LogDebug("玩家 {PlayerId} 当前没有活跃轨迹", playerId); + return result; + } + + // 解析轨迹数据 + var trail = new List(); + foreach (var pointData in trailData) + { + var parts = pointData.Split(','); + if (parts.Length >= 2 && + float.TryParse(parts[0], out float x) && + float.TryParse(parts[1], out float y)) + { + trail.Add(new Position { X = x, Y = y }); + } + } + + var threats = new List(); + float minDistance = float.MaxValue; + TrailThreat? immediateThreat = null; + + // 检查威胁位置与轨迹每个线段的距离 + for (int i = 0; i < trail.Count - 1; i++) + { + var segmentStart = trail[i]; + var segmentEnd = trail[i + 1]; + + // 计算点到线段的最短距离 + var distance = CalculatePointToLineSegmentDistance(threatPlayerPosition, segmentStart, segmentEnd); + var nearestPoint = FindNearestPointOnLineSegment(threatPlayerPosition, segmentStart, segmentEnd); + + if (distance <= warningDistance) + { + // 计算威胁等级 + var threatLevel = CalculateThreatLevel(distance, warningDistance); + + // 估算接触时间（简单估算，假设匀速移动） + var timeToContact = distance / 100f; // 假设平均速度为100像素/秒 + + var threat = new TrailThreat + { + ThreatPlayerId = playerId, // 这里需要传入威胁玩家的ID + ThreatPosition = threatPlayerPosition, + NearestTrailPoint = nearestPoint, + Distance = distance, + Level = threatLevel, + TimeToContact = timeToContact + }; + + threats.Add(threat); + + if (distance < minDistance) + { + minDistance = distance; + immediateThreat = threat; + } + + _logger.LogDebug("检测到轨迹威胁，距离: {Distance}，威胁等级: {Level}", distance, threatLevel); + } + } + + result.ShouldWarn = threats.Any(); + result.Threats = threats; + result.ImmediateThreat = immediateThreat; + result.MinimumDistance = minDistance == float.MaxValue ? 0 : minDistance; + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "检测轨迹预警时发生错误，GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new TrailWarningResult(); + } + } + + /// + /// 检测炸弹道具影响范围 + /// 检测炸弹道具爆炸范围内的所有轨迹和玩家，计算新领地区域 + /// + /// 游戏标识 + /// 爆炸中心位置 + /// 爆炸半径，默认30像素 + /// 爆炸影响检测结果 + public async Task CheckBombExplosionAsync(Guid gameId, Position explosionCenter, float explosionRadius = 30f) + { + try + { + _logger.LogDebug("检测炸弹爆炸影响，中心: ({X},{Y})，半径: {Radius}", + explosionCenter.X, explosionCenter.Y, explosionRadius); + + var result = new ExplosionCollisionResult(); + + // 获取所有玩家列表 + var playersKey = $"game:{gameId}:players"; + var allPlayers = await _redisService.GetSetMembersAsync(playersKey); + + var affectedPlayerTrails = new List(); + var clearedTrailPoints = new List(); + + // 检查每个玩家的轨迹是否受到爆炸影响 + foreach (var playerIdStr in allPlayers) + { + if (!Guid.TryParse(playerIdStr, out var playerId)) + continue; + + // 获取玩家当前轨迹 + var trailKey = $"game:{gameId}:player:{playerId}:trail"; + var trailData = await _redisService.ListRangeAsync(trailKey); + + if (!trailData.Any()) continue; + + // 解析轨迹数据 + var trail = new List(); + foreach (var pointData in trailData) + { + var parts = pointData.Split(','); + if (parts.Length >= 2 && + float.TryParse(parts[0], out float x) && + float.TryParse(parts[1], out float y)) + { + var trailPoint = new Position { X = x, Y = y }; + trail.Add(trailPoint); + + // 检查轨迹点是否在爆炸范围内 + var distance = CalculateDistance(explosionCenter, trailPoint); + if (distance <= explosionRadius) + { + clearedTrailPoints.Add(trailPoint); + if (!affectedPlayerTrails.Contains(playerId)) + { + affectedPlayerTrails.Add(playerId); + } + } + } + } + } + + // 生成新的圆形领地边界 + var newTerritoryBoundary = GenerateCircularTerritory(explosionCenter, explosionRadius); + + // 计算新增领地面积 + var areaGained = CalculateCircularArea(explosionRadius); + + result.HasTargets = affectedPlayerTrails.Any() || clearedTrailPoints.Any(); + result.AffectedPlayerTrails = affectedPlayerTrails; + result.ClearedTrailPoints = clearedTrailPoints; + result.TerritoryAreaGained = areaGained; + result.NewTerritoryBoundary = newTerritoryBoundary; + + _logger.LogDebug("炸弹爆炸影响检测完成，受影响玩家: {Count}，清除轨迹点: {Points}，新增面积: {Area}", + affectedPlayerTrails.Count, clearedTrailPoints.Count, areaGained); + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "检测炸弹爆炸影响时发生错误，GameId: {GameId}", gameId); + return new ExplosionCollisionResult(); + } + } + + /// + /// 生成圆形领地边界点 + /// 根据中心点和半径生成圆形边界的多边形近似 + /// + private List GenerateCircularTerritory(Position center, float radius, int segments = 32) + { + var boundary = new List(); + var angleStep = 2 * Math.PI / segments; + + for (int i = 0; i < segments; i++) + { + var angle = i * angleStep; + var x = center.X + radius * (float)Math.Cos(angle); + var y = center.Y + radius * (float)Math.Sin(angle); + boundary.Add(new Position { X = x, Y = y }); + } + + return boundary; + } + + /// + /// 计算圆形面积 + /// + private decimal CalculateCircularArea(float radius) + { + return (decimal)(Math.PI * radius * radius); + } + + /// + /// 检测圈地闭合 + /// 检测玩家画线轨迹是否与自己的领地形成闭合回路，实现圈地功能 + /// + /// 游戏标识 + /// 玩家标识 + /// 当前画线轨迹 + /// 结束位置 + /// 圈地闭合检测结果 + public async Task CheckTerritoryEnclosureAsync(Guid gameId, Guid playerId, List currentTrail, Position endPosition) + { + try + { + _logger.LogDebug("检测圈地闭合，玩家 {PlayerId}，轨迹点数: {TrailCount}", playerId, currentTrail.Count); + + var result = new EnclosureDetectionResult(); + + if (currentTrail.Count < 3) + { + result.InvalidReason = "轨迹点数不足，至少需要3个点"; + return result; + } + + // 获取玩家当前领地 + var territoryKey = $"game:{gameId}:player:{playerId}:territory"; + var territoryData = await _redisService.ListRangeAsync(territoryKey); + + if (!territoryData.Any()) + { + result.InvalidReason = "玩家没有现有领地，无法形成闭合"; + return result; + } + + // 解析现有领地 + var existingTerritory = new List(); + foreach (var pointData in territoryData) + { + var parts = pointData.Split(','); + if (parts.Length >= 2 && + float.TryParse(parts[0], out float x) && + float.TryParse(parts[1], out float y)) + { + existingTerritory.Add(new Position { X = x, Y = y }); + } + } + + // 检查结束位置是否接触现有领地边界 + var connectionPoint = FindTerritoryConnectionPoint(endPosition, existingTerritory); + if (connectionPoint == null) + { + result.InvalidReason = "结束位置未接触现有领地边界"; + return result; + } + + // 构建完整的闭合区域 + var completeEnclosure = BuildCompleteEnclosure(currentTrail, endPosition, connectionPoint, existingTerritory); + + if (!IsValidEnclosure(completeEnclosure)) + { + result.InvalidReason = "形成的区域不是有效的闭合多边形"; + return result; + } + + // 检查画线长度限制 + var trailLength = CalculateTrailLength(currentTrail); + var maxAllowedLength = await GetMaxTrailLengthAsync(gameId); + + if (trailLength > maxAllowedLength) + { + result.InvalidReason = $"画线长度超过限制 {trailLength:F1}/{maxAllowedLength:F1}"; + return result; + } + + // 计算新增领地面积 + var newArea = CalculatePolygonArea(completeEnclosure); + + // 检查是否包围了其他玩家的领地 + var enclosedTerritories = await CheckEnclosedPlayerTerritories(gameId, playerId, completeEnclosure); + + result.IsEnclosed = true; + result.EnclosedArea = completeEnclosure; + result.AreaSize = newArea; + result.EnclosedPlayerTerritories = enclosedTerritories; + result.IsValidEnclosure = true; + + _logger.LogDebug("检测到有效圈地闭合，玩家 {PlayerId}，新增面积: {Area}，包围敌方领地: {Count}", + playerId, newArea, enclosedTerritories.Count); + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "检测圈地闭合时发生错误，GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new EnclosureDetectionResult { InvalidReason = "检测过程发生内部错误" }; + } + } + + /// + /// 寻找领地连接点 + /// 使用精确的几何算法找到结束位置与现有领地边界的最佳连接点 + /// + private Position? FindTerritoryConnectionPoint(Position endPosition, List existingTerritory) + { + if (existingTerritory.Count < 2) return null; + + Position? bestConnectionPoint = null; + float minDistance = float.MaxValue; + const float CONNECTION_TOLERANCE = 8f; // 连接容差提升到8像素 + + // 检查与每条边界线段的最近点 + for (int i = 0; i < existingTerritory.Count; i++) + { + var segmentStart = existingTerritory[i]; + var segmentEnd = existingTerritory[(i + 1) % existingTerritory.Count]; + + // 计算点到线段的最近点和距离 + var nearestPoint = FindNearestPointOnLineSegment(endPosition, segmentStart, segmentEnd); + var distance = CalculateDistance(endPosition, nearestPoint); + + if (distance <= CONNECTION_TOLERANCE && distance < minDistance) + { + minDistance = distance; + bestConnectionPoint = nearestPoint; + } + } + + // 如果没有找到线段连接点，检查与顶点的直接连接 + if (bestConnectionPoint == null) + { + foreach (var vertex in existingTerritory) + { + var distance = CalculateDistance(endPosition, vertex); + if (distance <= CONNECTION_TOLERANCE * 1.5f && distance < minDistance) + { + minDistance = distance; + bestConnectionPoint = vertex; + } + } + } + + return bestConnectionPoint; + } + + /// + /// 构建完整的闭合区域 + /// 使用精确的几何算法将当前轨迹与现有领地连接形成有效的多边形 + /// + private List BuildCompleteEnclosure(List currentTrail, Position endPosition, + Position connectionPoint, List existingTerritory) + { + var completeEnclosure = new List(); + + // 1. 添加轨迹起点（如果不在现有领地边界上） + var trailStart = currentTrail[0]; + if (!IsPointOnTerritoryBoundary(trailStart, existingTerritory)) + { + // 找到轨迹起点在现有领地上的连接点 + var startConnectionPoint = FindTerritoryConnectionPoint(trailStart, existingTerritory); + if (startConnectionPoint != null) + { + completeEnclosure.Add(startConnectionPoint); + } + } + else + { + completeEnclosure.Add(trailStart); + } + + // 2. 添加完整的当前轨迹路径 + for (int i = 1; i < currentTrail.Count; i++) + { + completeEnclosure.Add(currentTrail[i]); + } + + // 3. 添加结束位置（如果与轨迹最后一点不同） + var lastTrailPoint = currentTrail[currentTrail.Count - 1]; + if (CalculateDistance(lastTrailPoint, endPosition) > 1f) + { + completeEnclosure.Add(endPosition); + } + + // 4. 添加连接点 + if (CalculateDistance(endPosition, connectionPoint) > 1f) + { + completeEnclosure.Add(connectionPoint); + } + + // 5. 找到连接点在现有领地边界上的位置 + var connectionSegmentIndex = FindConnectionSegmentIndex(connectionPoint, existingTerritory); + if (connectionSegmentIndex >= 0) + { + // 沿着领地边界回到起始连接点 + var boundaryPath = ExtractBoundaryPath(existingTerritory, connectionSegmentIndex, trailStart); + completeEnclosure.AddRange(boundaryPath); + } + + // 6. 移除重复点和共线点 + completeEnclosure = RemoveDuplicateAndCollinearPoints(completeEnclosure); + + return completeEnclosure; + } + + /// + /// 检查点是否在领地边界上 + /// + private bool IsPointOnTerritoryBoundary(Position point, List territory) + { + const float BOUNDARY_TOLERANCE = 3f; + + for (int i = 0; i < territory.Count; i++) + { + var segmentStart = territory[i]; + var segmentEnd = territory[(i + 1) % territory.Count]; + + var distance = CalculatePointToLineSegmentDistance(point, segmentStart, segmentEnd); + if (distance <= BOUNDARY_TOLERANCE) + { + return true; + } + } + + return false; + } + + /// + /// 找到连接点所在的边界线段索引 + /// + private int FindConnectionSegmentIndex(Position connectionPoint, List territory) + { + const float SEGMENT_TOLERANCE = 2f; + + for (int i = 0; i < territory.Count; i++) + { + var segmentStart = territory[i]; + var segmentEnd = territory[(i + 1) % territory.Count]; + + var distance = CalculatePointToLineSegmentDistance(connectionPoint, segmentStart, segmentEnd); + if (distance <= SEGMENT_TOLERANCE) + { + return i; + } + } + + return -1; + } + + /// + /// 提取边界路径 + /// 从连接点沿边界提取到起始点的路径 + /// + private List ExtractBoundaryPath(List territory, int startSegmentIndex, Position targetStart) + { + var boundaryPath = new List(); + + // 找到最接近目标起始点的领地顶点 + int targetVertexIndex = FindNearestBoundaryPointIndex(targetStart, territory); + + if (targetVertexIndex < 0) return boundaryPath; + + // 从连接线段的结束点开始 + int currentIndex = (startSegmentIndex + 1) % territory.Count; + + // 沿着边界路径添加点，直到到达目标顶点 + while (currentIndex != targetVertexIndex) + { + boundaryPath.Add(territory[currentIndex]); + currentIndex = (currentIndex + 1) % territory.Count; + + // 防止无限循环 + if (boundaryPath.Count > territory.Count) + break; + } + + return boundaryPath; + } + + /// + /// 移除重复点和共线点 + /// 优化多边形结构，提高计算效率 + /// + private List RemoveDuplicateAndCollinearPoints(List points) + { + if (points.Count < 3) return points; + + var optimized = new List(); + const float DUPLICATE_TOLERANCE = 1f; + const float COLLINEAR_TOLERANCE = 0.1f; + + for (int i = 0; i < points.Count; i++) + { + var current = points[i]; + var next = points[(i + 1) % points.Count]; + var prev = points[(i - 1 + points.Count) % points.Count]; + + // 跳过重复点 + if (optimized.Count > 0 && CalculateDistance(current, optimized[optimized.Count - 1]) < DUPLICATE_TOLERANCE) + continue; + + // 跳过共线点 + if (optimized.Count > 0) + { + var crossProduct = CalculateCrossProduct(prev, current, next); + if (Math.Abs(crossProduct) < COLLINEAR_TOLERANCE) + continue; + } + + optimized.Add(current); + } + + return optimized.Count >= 3 ? optimized : points; + } + + /// + /// 计算三点的叉积（用于检测共线性） + /// + private float CalculateCrossProduct(Position a, Position b, Position c) + { + return (b.X - a.X) * (c.Y - a.Y) - (b.Y - a.Y) * (c.X - a.X); + } + + /// + /// 检查是否是有效的闭合区域 + /// 使用复杂的几何验证确保多边形的有效性 + /// + private bool IsValidEnclosure(List enclosure) + { + if (enclosure.Count < 3) return false; + + // 1. 检查多边形是否自相交 + if (HasSelfIntersection(enclosure)) return false; + + // 2. 检查面积是否足够大（避免无意义的小区域） + var area = CalculatePolygonArea(enclosure); + const decimal MIN_AREA = 100m; // 最小100平方像素 + if (area < MIN_AREA) return false; + + // 3. 检查多边形的凸凹性和复杂度 + if (IsPolygonTooComplex(enclosure)) return false; + + // 4. 检查边长是否合理（避免过短或过长的边） + if (!AreEdgeLengthsReasonable(enclosure)) return false; + + return true; + } + + /// + /// 检查多边形是否存在自相交 + /// 使用改进的线段相交算法 + /// + private bool HasSelfIntersection(List polygon) + { + int n = polygon.Count; + + for (int i = 0; i < n; i++) + { + var segment1Start = polygon[i]; + var segment1End = polygon[(i + 1) % n]; + + // 检查与其他非相邻线段的交点 + for (int j = i + 2; j < n; j++) + { + // 避免检查最后一条边与第一条边的交点（这是合法的闭合） + if (i == 0 && j == n - 1) continue; + + var segment2Start = polygon[j]; + var segment2End = polygon[(j + 1) % n]; + + if (DoLineSegmentsIntersect(segment1Start, segment1End, segment2Start, segment2End)) + { + return true; + } + } + } + + return false; + } + + /// + /// 精确的线段相交检测 + /// 使用定向面积测试 + /// + private bool DoLineSegmentsIntersect(Position p1, Position p2, Position p3, Position p4) + { + var d1 = GetOrientation(p3, p4, p1); + var d2 = GetOrientation(p3, p4, p2); + var d3 = GetOrientation(p1, p2, p3); + var d4 = GetOrientation(p1, p2, p4); + + if (((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) && + ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0))) + { + return true; // 一般情况：线段相交 + } + + // 检查共线和重叠的特殊情况 + if (d1 == 0 && IsPointOnSegment(p1, p3, p4)) return true; + if (d2 == 0 && IsPointOnSegment(p2, p3, p4)) return true; + if (d3 == 0 && IsPointOnSegment(p3, p1, p2)) return true; + if (d4 == 0 && IsPointOnSegment(p4, p1, p2)) return true; + + return false; + } + + /// + /// 计算定向面积（叉积） + /// + private float GetOrientation(Position a, Position b, Position c) + { + return (b.X - a.X) * (c.Y - a.Y) - (b.Y - a.Y) * (c.X - a.X); + } + + /// + /// 检查点是否在线段上 + /// + private bool IsPointOnSegment(Position point, Position segmentStart, Position segmentEnd) + { + const float EPSILON = 1e-6f; + + // 检查点是否在线段的边界框内 + if (point.X < Math.Min(segmentStart.X, segmentEnd.X) - EPSILON || + point.X > Math.Max(segmentStart.X, segmentEnd.X) + EPSILON || + point.Y < Math.Min(segmentStart.Y, segmentEnd.Y) - EPSILON || + point.Y > Math.Max(segmentStart.Y, segmentEnd.Y) + EPSILON) + { + return false; + } + + // 检查点是否在直线上 + var crossProduct = GetOrientation(segmentStart, segmentEnd, point); + return Math.Abs(crossProduct) < EPSILON; + } + + /// + /// 检查多边形是否过于复杂 + /// + private bool IsPolygonTooComplex(List polygon) + { + // 限制顶点数量 + if (polygon.Count > 100) return true; + + // 检查尖锐角度的数量 + int sharpAngleCount = 0; + for (int i = 0; i < polygon.Count; i++) + { + var prev = polygon[(i - 1 + polygon.Count) % polygon.Count]; + var current = polygon[i]; + var next = polygon[(i + 1) % polygon.Count]; + + var angle = CalculateAngle(prev, current, next); + if (angle < 15 || angle > 165) // 过于尖锐或平直的角 + { + sharpAngleCount++; + } + } + + // 如果超过一半的角都是尖锐角，认为过于复杂 + return sharpAngleCount > polygon.Count / 2; + } + + /// + /// 计算三点形成的角度 + /// + private double CalculateAngle(Position a, Position b, Position c) + { + var ba = new Vector2(a.X - b.X, a.Y - b.Y); + var bc = new Vector2(c.X - b.X, c.Y - b.Y); + + var dot = Vector2.Dot(ba, bc); + var magnitudes = ba.Length() * bc.Length(); + + if (magnitudes == 0) return 0; + + var cosAngle = dot / magnitudes; + cosAngle = Math.Max(-1, Math.Min(1, cosAngle)); // 限制在[-1, 1]范围内 + + return Math.Acos(cosAngle) * 180.0 / Math.PI; + } + + /// + /// 检查边长是否合理 + /// + private bool AreEdgeLengthsReasonable(List polygon) + { + const float MIN_EDGE_LENGTH = 3f; + const float MAX_EDGE_LENGTH = 500f; + + for (int i = 0; i < polygon.Count; i++) + { + var current = polygon[i]; + var next = polygon[(i + 1) % polygon.Count]; + var edgeLength = CalculateDistance(current, next); + + if (edgeLength < MIN_EDGE_LENGTH || edgeLength > MAX_EDGE_LENGTH) + { + return false; + } + } + + return true; + } + + /// + /// 计算轨迹长度 + /// + private float CalculateTrailLength(List trail) + { + if (trail.Count < 2) return 0; + + float totalLength = 0; + for (int i = 0; i < trail.Count - 1; i++) + { + totalLength += CalculateDistance(trail[i], trail[i + 1]); + } + + return totalLength; + } + + /// + /// 获取最大允许轨迹长度 + /// + private async Task GetMaxTrailLengthAsync(Guid gameId) + { + try + { + var gameConfigKey = $"game:{gameId}:config"; + var gameConfig = await _redisService.GetHashAllAsync(gameConfigKey); + + var mapWidth = float.Parse(gameConfig.GetValueOrDefault("map_width", "1000")); + var mapHeight = float.Parse(gameConfig.GetValueOrDefault("map_height", "1000")); + + // 最大画线长度为地图对角线的1.5倍 + var diagonal = (float)Math.Sqrt(mapWidth * mapWidth + mapHeight * mapHeight); + return diagonal * 1.5f; + } + catch (Exception ex) + { + _logger.LogError(ex, "获取最大轨迹长度时发生错误"); + return 1500f; // 默认值 + } + } + + /// + /// 检查被包围的敌方玩家领地 + /// + private async Task> CheckEnclosedPlayerTerritories(Guid gameId, Guid currentPlayerId, List enclosure) + { + var enclosedTerritories = new List(); + + try + { + var playersKey = $"game:{gameId}:players"; + var allPlayers = await _redisService.GetSetMembersAsync(playersKey); + + foreach (var playerIdStr in allPlayers) + { + if (!Guid.TryParse(playerIdStr, out var playerId) || playerId == currentPlayerId) + continue; + + // 获取其他玩家的领地 + var territoryKey = $"game:{gameId}:player:{playerId}:territory"; + var territoryData = await _redisService.ListRangeAsync(territoryKey); + + if (!territoryData.Any()) continue; + + // 解析玩家领地 + var playerTerritory = new List(); + foreach (var pointData in territoryData) + { + var parts = pointData.Split(','); + if (parts.Length >= 2 && + float.TryParse(parts[0], out float x) && + float.TryParse(parts[1], out float y)) + { + playerTerritory.Add(new Position { X = x, Y = y }); + } + } + + // 检查该玩家的领地是否被完全包围 + if (IsTerritoryCompletelyEnclosed(playerTerritory, enclosure)) + { + enclosedTerritories.Add(playerId); + } + } + } + catch (Exception ex) + { + _logger.LogError(ex, "检查被包围领地时发生错误"); + } + + return enclosedTerritories; + } + + /// + /// 查找边界点的最近索引 + /// + private int FindNearestBoundaryPointIndex(Position point, List boundary) + { + int nearestIndex = -1; + float minDistance = float.MaxValue; + + for (int i = 0; i < boundary.Count; i++) + { + var distance = CalculateDistance(point, boundary[i]); + if (distance < minDistance) + { + minDistance = distance; + nearestIndex = i; + } + } + + return nearestIndex; + } + + /// + /// 检查领地是否被完全包围 + /// + private bool IsTerritoryCompletelyEnclosed(List territory, List enclosure) + { + if (territory.Count < 3 || enclosure.Count < 3) return false; + + // 检查领地的所有点是否都在包围区域内 + foreach (var point in territory) + { + if (!IsPointInPolygon(point, enclosure)) + { + return false; + } + } + + return true; + } + + /// + /// 检测地图缩圈影响 + /// 检测地图缩圈时哪些玩家的领地会受到影响，计算损失的领地面积 + /// + /// 游戏标识 + /// 新的地图半径 + /// 地图缩圈影响结果 + public async Task CheckMapShrinkCollisionAsync(Guid gameId, float newMapRadius) + { + try + { + _logger.LogDebug("检测地图缩圈影响，新半径: {Radius}", newMapRadius); + + var result = new MapShrinkCollisionResult(); + + // 获取地图配置 + var gameConfigKey = $"game:{gameId}:config"; + var gameConfig = await _redisService.GetHashAllAsync(gameConfigKey); + + if (!gameConfig.Any()) + { + _logger.LogWarning("游戏 {GameId} 配置不存在", gameId); + return result; + } + + // 获取地图中心点 + var mapWidth = float.Parse(gameConfig.GetValueOrDefault("map_width", "1000")); + var mapHeight = float.Parse(gameConfig.GetValueOrDefault("map_height", "1000")); + var mapCenter = new Position + { + X = mapWidth / 2f, + Y = mapHeight / 2f + }; + + result.NewMapRadius = newMapRadius; + result.MapCenter = mapCenter; + + // 获取所有玩家 + var playersKey = $"game:{gameId}:players"; + var allPlayers = await _redisService.GetSetMembersAsync(playersKey); + + var territoryLosses = new List(); + + foreach (var playerIdStr in allPlayers) + { + if (!Guid.TryParse(playerIdStr, out var playerId)) + continue; + + // 获取玩家当前领地 + var territoryKey = $"game:{gameId}:player:{playerId}:territory"; + var territoryData = await _redisService.ListRangeAsync(territoryKey); + + if (!territoryData.Any()) continue; + + // 解析玩家领地 + var playerTerritory = new List(); + foreach (var pointData in territoryData) + { + var parts = pointData.Split(','); + if (parts.Length >= 2 && + float.TryParse(parts[0], out float x) && + float.TryParse(parts[1], out float y)) + { + playerTerritory.Add(new Position { X = x, Y = y }); + } + } + + if (playerTerritory.Count < 3) continue; + + // 计算原始面积 + var originalArea = CalculatePolygonArea(playerTerritory); + + // 裁剪领地到新的地图范围内 + var clippedTerritory = ClipTerritoryToCircle(playerTerritory, mapCenter, newMapRadius); + var remainingArea = clippedTerritory.Any() ? CalculatePolygonArea(clippedTerritory) : 0m; + + var areaLost = originalArea - remainingArea; + + if (areaLost > 0) + { + // 获取玩家名称 + var playerName = await GetPlayerNameAsync(gameId, playerId) ?? playerId.ToString()[..8]; + + var territoryLoss = new PlayerTerritoryLoss + { + PlayerId = playerId, + PlayerName = playerName, + AreaLost = areaLost, + RemainingArea = remainingArea, + LostTerritoryBoundary = CalculateLostTerritoryBoundary(playerTerritory, clippedTerritory) + }; + + territoryLosses.Add(territoryLoss); + + _logger.LogDebug("玩家 {PlayerId} ({PlayerName}) 因地图缩圈损失面积: {AreaLost}，剩余面积: {RemainingArea}", + playerId, playerName, areaLost, remainingArea); + } + } + + result.HasAffectedTerritories = territoryLosses.Any(); + result.TerritoryLosses = territoryLosses; + result.TotalAffectedPlayers = territoryLosses.Count; + + _logger.LogDebug("地图缩圈影响检测完成，受影响玩家: {Count}，总损失面积: {TotalLoss}", + territoryLosses.Count, territoryLosses.Sum(t => t.AreaLost)); + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "检测地图缩圈影响时发生错误，GameId: {GameId}", gameId); + return new MapShrinkCollisionResult(); + } + } + + /// + /// 计算多边形面积 + /// 使用鞋带公式（Shoelace formula）计算多边形面积 + /// + private decimal CalculatePolygonArea(List polygon) + { + if (polygon.Count < 3) return 0; + + double area = 0; + int n = polygon.Count; + + for (int i = 0; i < n; i++) + { + int j = (i + 1) % n; + area += polygon[i].X * polygon[j].Y; + area -= polygon[j].X * polygon[i].Y; + } + + return (decimal)(Math.Abs(area) / 2.0); + } + + /// + /// 将领地裁剪到圆形区域内 + /// 使用改进的Sutherland-Hodgman多边形裁剪算法 + /// + private List ClipTerritoryToCircle(List territory, Position center, float radius) + { + if (territory.Count < 3) return new List(); + + var clipped = new List(territory); + var result = new List(); + + // 使用Sutherland-Hodgman算法的圆形版本 + for (int i = 0; i < clipped.Count; i++) + { + var current = clipped[i]; + var next = clipped[(i + 1) % clipped.Count]; + + var currentDistance = CalculateDistance(current, center); + var nextDistance = CalculateDistance(next, center); + + var currentInside = currentDistance <= radius; + var nextInside = nextDistance <= radius; + + if (currentInside && nextInside) + { + // 两点都在内部，添加next点 + if (!result.Contains(next)) + result.Add(next); + } + else if (currentInside && !nextInside) + { + // 从内部到外部，添加交点 + var intersection = CalculateCircleLineIntersection(current, next, center, radius); + if (intersection != null && !result.Contains(intersection)) + result.Add(intersection); + } + else if (!currentInside && nextInside) + { + // 从外部到内部，添加交点和next点 + var intersection = CalculateCircleLineIntersection(current, next, center, radius); + if (intersection != null && !result.Contains(intersection)) + result.Add(intersection); + if (!result.Contains(next)) + result.Add(next); + } + // 两点都在外部，不添加任何点 + } + + return result.Count >= 3 ? result : new List(); + } + + /// + /// 计算线段与圆的交点 + /// + private Position? CalculateCircleLineIntersection(Position p1, Position p2, Position center, float radius) + { + var dx = p2.X - p1.X; + var dy = p2.Y - p1.Y; + var fx = p1.X - center.X; + var fy = p1.Y - center.Y; + + var a = dx * dx + dy * dy; + var b = 2 * (fx * dx + fy * dy); + var c = (fx * fx + fy * fy) - radius * radius; + + var discriminant = b * b - 4 * a * c; + + if (discriminant < 0) return null; // 无交点 + + var sqrt_discriminant = Math.Sqrt(discriminant); + var t1 = (-b - sqrt_discriminant) / (2 * a); + var t2 = (-b + sqrt_discriminant) / (2 * a); + + // 选择在线段范围内的交点 + var t = (t1 >= 0 && t1 <= 1) ? t1 : + (t2 >= 0 && t2 <= 1) ? t2 : -1; + + if (t < 0) return null; + + return new Position + { + X = p1.X + (float)(t * dx), + Y = p1.Y + (float)(t * dy) + }; + } + + /// + /// 计算丢失的领地边界 + /// 计算原始领地与裁剪后领地的差集边界 + /// + private List CalculateLostTerritoryBoundary(List originalTerritory, List clippedTerritory) + { + // 简化实现：返回被裁剪掉的点 + var lostBoundary = new List(); + + foreach (var point in originalTerritory) + { + bool isInClipped = clippedTerritory.Any(cp => + Math.Abs(cp.X - point.X) < 1f && Math.Abs(cp.Y - point.Y) < 1f); + + if (!isInClipped) + { + lostBoundary.Add(point); + } + } + + return lostBoundary; + } + + /// + /// 批量碰撞检测优化 + /// 一次性检测多个玩家的移动碰撞，提高服务器性能，减少Redis查询次数 + /// + /// 游戏标识 + /// 玩家移动列表 + /// 批量碰撞检测结果 + public async Task CheckBatchPlayerMovementsAsync(Guid gameId, List playerMovements) + { + try + { + _logger.LogDebug("开始批量碰撞检测，玩家数量: {Count}", playerMovements.Count); + + var result = new BatchCollisionResult(); + var results = new List(); + var errors = new List(); + + // 预加载游戏数据以减少Redis查询 + var gameData = await PreloadGameDataForBatchProcessing(gameId); + + if (gameData == null) + { + errors.Add($"无法加载游戏 {gameId} 的数据"); + result.Errors = errors; + return result; + } + + // 并发处理所有玩家移动 + var tasks = playerMovements.Select(async movement => + { + try + { + var playerResult = new PlayerCollisionResult + { + PlayerId = movement.PlayerId, + ValidPosition = movement.ToPosition + }; + + var collisions = new List(); + + // 1. 检查边界碰撞 + var boundaryResult = await CheckMapBoundaryAsync(gameId, movement.ToPosition); + if (boundaryResult.IsOutOfBounds) + { + collisions.Add(new CollisionDetail + { + Category = CollisionCategory.BoundaryHit, + CollisionPoint = movement.ToPosition, + Description = "超出地图边界" + }); + playerResult.ValidPosition = boundaryResult.ValidPosition; + } + + // 2. 检查轨迹碰撞 + var trailResult = await CheckTrailCollisionAsync(gameId, movement.PlayerId, + movement.FromPosition, movement.ToPosition, movement.IsDrawing); + + if (trailResult.HasCollision) + { + collisions.Add(new CollisionDetail + { + Category = CollisionCategory.TrailCollision, + CollisionPoint = trailResult.CollisionPoint, + OtherPlayerId = trailResult.CollidedWithPlayerId, + Description = $"轨迹碰撞：{trailResult.CollisionType}" + }); + + if (trailResult.IsDeadly) + { + playerResult.ShouldDie = true; + playerResult.DeathReason = $"被{trailResult.CollisionType}截断"; + } + } + + // 3. 检查道具拾取 + var powerUpResult = await CheckPowerUpPickupAsync(gameId, movement.PlayerId, movement.ToPosition); + if (powerUpResult.CanPickup && powerUpResult.ClosestPowerUp != null) + { + collisions.Add(new CollisionDetail + { + Category = CollisionCategory.PowerUpPickup, + CollisionPoint = powerUpResult.ClosestPowerUp.Position, + Description = $"拾取道具：{powerUpResult.ClosestPowerUp.Type}", + Properties = new Dictionary + { + ["PowerUpId"] = powerUpResult.ClosestPowerUp.Id, + ["PowerUpType"] = powerUpResult.ClosestPowerUp.Type.ToString() + } + }); + } + + // 4. 检查领地转换 + var territoryResult = await CheckTerritoryTransitionAsync(gameId, movement.PlayerId, + movement.FromPosition, movement.ToPosition); + + if (territoryResult.TerritoryChanged) + { + collisions.Add(new CollisionDetail + { + Category = CollisionCategory.TerritoryTransition, + CollisionPoint = movement.ToPosition, + OtherPlayerId = territoryResult.CurrentOwnerId, + Description = $"领地转换：{territoryResult.TransitionType}", + Properties = new Dictionary + { + ["SpeedModifier"] = territoryResult.SpeedModifier, + ["TransitionType"] = territoryResult.TransitionType.ToString() + } + }); + } + + playerResult.HasCollision = collisions.Any(); + playerResult.Collisions = collisions; + + return playerResult; + } + catch (Exception ex) + { + _logger.LogError(ex, "处理玩家 {PlayerId} 移动时发生错误", movement.PlayerId); + return new PlayerCollisionResult + { + PlayerId = movement.PlayerId, + HasCollision = false, + ValidPosition = movement.FromPosition // 出错时保持原位置 + }; + } + }); + + // 等待所有任务完成 + results.AddRange(await Task.WhenAll(tasks)); + + result.Results = results; + result.ProcessedMovements = playerMovements.Count; + result.TotalCollisions = results.Count(r => r.HasCollision); + result.Errors = errors; + + _logger.LogDebug("批量碰撞检测完成，处理移动: {Processed}，检测到碰撞: {Collisions}", + result.ProcessedMovements, result.TotalCollisions); + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "批量碰撞检测时发生错误，GameId: {GameId}", gameId); + return new BatchCollisionResult + { + Errors = new List { "批量处理过程发生内部错误" } + }; + } + } + + /// + /// 预加载游戏数据用于批量处理 + /// 使用智能缓存策略，预加载所有必要的游戏数据，大幅减少Redis查询 + /// + private async Task PreloadGameDataForBatchProcessing(Guid gameId) + { + try + { + var gameData = new GameDataCache { GameId = gameId }; + + // 并发加载多个数据源 + var tasks = new List(); + + // 1. 加载游戏配置 + tasks.Add(Task.Run(async () => + { + var gameConfigKey = $"game:{gameId}:config"; + gameData.GameConfig = await _redisService.GetHashAllAsync(gameConfigKey); + })); + + // 2. 加载玩家列表 + tasks.Add(Task.Run(async () => + { + var playersKey = $"game:{gameId}:players"; + gameData.PlayerIds = await _redisService.GetSetMembersAsync(playersKey); + })); + + // 3. 加载所有玩家的轨迹数据 + tasks.Add(Task.Run(async () => + { + var playersKey = $"game:{gameId}:players"; + var playerIds = await _redisService.GetSetMembersAsync(playersKey); + + var trailTasks = playerIds.Select(async playerIdStr => + { + if (Guid.TryParse(playerIdStr, out var playerId)) + { + var trailKey = $"game:{gameId}:player:{playerId}:trail"; + var trailData = await _redisService.ListRangeAsync(trailKey); + return new KeyValuePair>(playerId, ParsePositionList(trailData)); + } + return new KeyValuePair>(Guid.Empty, new List()); + }); + + var trailResults = await Task.WhenAll(trailTasks); + gameData.PlayerTrails = trailResults + .Where(kvp => kvp.Key != Guid.Empty) + .ToDictionary(kvp => kvp.Key, kvp => kvp.Value); + })); + + // 4. 加载所有玩家的领地数据 + tasks.Add(Task.Run(async () => + { + var playersKey = $"game:{gameId}:players"; + var playerIds = await _redisService.GetSetMembersAsync(playersKey); + + var territoryTasks = playerIds.Select(async playerIdStr => + { + if (Guid.TryParse(playerIdStr, out var playerId)) + { + var territoryKey = $"game:{gameId}:player:{playerId}:territory"; + var territoryData = await _redisService.ListRangeAsync(territoryKey); + return new KeyValuePair>(playerId, ParsePositionList(territoryData)); + } + return new KeyValuePair>(Guid.Empty, new List()); + }); + + var territoryResults = await Task.WhenAll(territoryTasks); + gameData.PlayerTerritories = territoryResults + .Where(kvp => kvp.Key != Guid.Empty) + .ToDictionary(kvp => kvp.Key, kvp => kvp.Value); + })); + + // 5. 加载所有玩家状态 + tasks.Add(Task.Run(async () => + { + var playersKey = $"game:{gameId}:players"; + var playerIds = await _redisService.GetSetMembersAsync(playersKey); + + var stateTasks = playerIds.Select(async playerIdStr => + { + if (Guid.TryParse(playerIdStr, out var playerId)) + { + var stateKey = $"game:{gameId}:player:{playerId}"; + var stateData = await _redisService.GetHashAllAsync(stateKey); + return new KeyValuePair>(playerId, stateData); + } + return new KeyValuePair>(Guid.Empty, new Dictionary()); + }); + + var stateResults = await Task.WhenAll(stateTasks); + gameData.PlayerStates = stateResults + .Where(kvp => kvp.Key != Guid.Empty) + .ToDictionary(kvp => kvp.Key, kvp => kvp.Value); + })); + + // 6. 加载道具数据 + tasks.Add(Task.Run(async () => + { + var powerUpsKey = $"game:{gameId}:powerups"; + var powerUpIds = await _redisService.GetSetMembersAsync(powerUpsKey); + + var powerUpTasks = powerUpIds.Select(async powerUpIdStr => + { + if (Guid.TryParse(powerUpIdStr, out var powerUpId)) + { + var powerUpKey = $"game:{gameId}:powerup:{powerUpId}"; + var powerUpData = await _redisService.GetHashAllAsync(powerUpKey); + var powerUp = ParsePickupablePowerUp(powerUpId, powerUpData); + return powerUp; + } + return null; + }); + + var powerUpResults = await Task.WhenAll(powerUpTasks); + gameData.ActivePowerUps = powerUpResults.Where(p => p != null).ToList()!; + })); + + // 7. 加载障碍物数据 + tasks.Add(Task.Run(async () => + { + var obstaclesKey = $"game:{gameId}:obstacles"; + var obstacleIds = await _redisService.GetSetMembersAsync(obstaclesKey); + + var obstacleTasks = obstacleIds.Select(async obstacleIdStr => + { + if (Guid.TryParse(obstacleIdStr, out var obstacleId)) + { + var obstacleKey = $"game:{gameId}:obstacle:{obstacleId}"; + var obstacleData = await _redisService.GetHashAllAsync(obstacleKey); + return ParseMapObstacle(obstacleId, obstacleData); + } + return null; + }); + + var obstacleResults = await Task.WhenAll(obstacleTasks); + gameData.MapObstacles = obstacleResults.Where(o => o != null).ToList()!; + })); + + // 等待所有数据加载完成 + await Task.WhenAll(tasks); + + return gameData; + } + catch (Exception ex) + { + _logger.LogError(ex, "预加载游戏数据时发生错误，GameId: {GameId}", gameId); + return null; + } + } + + /// + /// 解析位置列表字符串 + /// + private List ParsePositionList(List positionData) + { + var positions = new List(); + + foreach (var pointData in positionData) + { + var parts = pointData.Split(','); + if (parts.Length >= 2 && + float.TryParse(parts[0], out float x) && + float.TryParse(parts[1], out float y)) + { + positions.Add(new Position { X = x, Y = y }); + } + } + + return positions; + } + + /// + /// 增强的游戏数据缓存类 + /// 预加载所有批量处理需要的数据，避免重复Redis查询 + /// + private class GameDataCache + { + public Guid GameId { get; set; } + public Dictionary GameConfig { get; set; } = new(); + public HashSet PlayerIds { get; set; } = new(); + public Dictionary> PlayerTrails { get; set; } = new(); + public Dictionary> PlayerTerritories { get; set; } = new(); + public Dictionary> PlayerStates { get; set; } = new(); + public List ActivePowerUps { get; set; } = new(); + public List MapObstacles { get; set; } = new(); + } +} diff --git a/backend/src/CollabApp.Application/Services/Game/GameBroadcastService.cs b/backend/src/CollabApp.Application/Services/Game/GameBroadcastService.cs new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/backend/src/CollabApp.Application/Services/Game/GamePlayService.cs b/backend/src/CollabApp.Application/Services/Game/GamePlayService.cs new file mode 100644 index 0000000000000000000000000000000000000000..b32ad8797451f76ed54760904528611961a2e193 --- /dev/null +++ b/backend/src/CollabApp.Application/Services/Game/GamePlayService.cs @@ -0,0 +1,1435 @@ +using CollabApp.Application.Interfaces; +using CollabApp.Domain.Entities.Game; +using CollabApp.Domain.Services.Game; +using Microsoft.Extensions.Logging; +using System.Collections.Concurrent; + +namespace CollabApp.Application.Services.Game; + +/// +/// 游戏玩法服务 +/// 负责处理游戏核心玩法逻辑，包括移动、攻击、收集、技能使用等游戏行为 +/// 提供企业级的游戏玩法处理和验证能力 +/// +public class GamePlayService : IGamePlayService +{ + private readonly IRedisService _redisService; + private readonly ILogger _logger; + private readonly IGameStateService _gameStateService; + private readonly IPlayerStateService _playerStateService; + private readonly ICollisionDetectionService _collisionDetectionService; + private readonly ITerritoryService _territoryService; + private readonly IPowerUpService _powerUpService; + + // 缓存和状态管理 + private readonly ConcurrentDictionary> _actionCache = new(); + private readonly ConcurrentDictionary _lastActionTime = new(); + private readonly ConcurrentDictionary _cooldownTracker = new(); + + // 游戏配置常量 + private const float MAX_MOVE_SPEED = 10.0f; + private const float MIN_ATTACK_DAMAGE = 10.0f; + private const float MAX_ATTACK_DAMAGE = 100.0f; + private const float TERRITORY_CLAIM_RADIUS = 50.0f; + private const int MAX_ACTIONS_PER_SECOND = 20; + private const double ACTION_COOLDOWN_MS = 50; // 50毫秒最小间隔 + + public GamePlayService( + IRedisService redisService, + ILogger logger, + IGameStateService gameStateService, + IPlayerStateService playerStateService, + ICollisionDetectionService collisionDetectionService, + ITerritoryService territoryService, + IPowerUpService powerUpService) + { + _redisService = redisService ?? throw new ArgumentNullException(nameof(redisService)); + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + _gameStateService = gameStateService ?? throw new ArgumentNullException(nameof(gameStateService)); + _playerStateService = playerStateService ?? throw new ArgumentNullException(nameof(playerStateService)); + _collisionDetectionService = collisionDetectionService ?? throw new ArgumentNullException(nameof(collisionDetectionService)); + _territoryService = territoryService ?? throw new ArgumentNullException(nameof(territoryService)); + _powerUpService = powerUpService ?? throw new ArgumentNullException(nameof(powerUpService)); + + _logger.LogInformation("GamePlayService 已初始化，准备提供游戏玩法处理服务"); + } + + #region 移动处理 + + /// + /// 处理玩家移动 + /// 验证移动的合法性，更新玩家位置，检测碰撞和边界 + /// + public async Task ProcessPlayerMoveAsync(Guid gameId, Guid playerId, MoveCommand moveCommand) + { + if (gameId == Guid.Empty || playerId == Guid.Empty || moveCommand == null) + { + _logger.LogWarning("处理玩家移动失败：无效的参数"); + return new MoveResult + { + Success = false, + Errors = new List { "无效的移动参数" } + }; + } + + try + { + // 防止操作过于频繁 + if (!await ValidateActionRateAsync(playerId)) + { + return new MoveResult + { + Success = false, + Errors = new List { "操作过于频繁，请稍后重试" } + }; + } + + // 获取当前玩家状态 + var playerState = await _playerStateService.GetPlayerStateAsync(gameId, playerId); + if (playerState == null || playerState.State == PlayerDrawingState.Dead) + { + return new MoveResult + { + Success = false, + Errors = new List { "玩家状态无效或已死亡" } + }; + } + + // 验证游戏状态 + var gameState = await _gameStateService.GetGameStateAsync(gameId); + if (gameState == null || gameState.Status != GameStatus.Playing) + { + return new MoveResult + { + Success = false, + Errors = new List { "游戏未在进行中" } + }; + } + + // 验证移动合法性 + var validationResult = await ValidateMoveAsync(gameId, playerId, moveCommand); + if (!validationResult.IsValid) + { + return new MoveResult + { + Success = false, + Errors = validationResult.Errors + }; + } + + var oldPosition = new Position + { + X = playerState.CurrentPosition.X, + Y = playerState.CurrentPosition.Y + }; + + // 更新玩家位置 + var updateResult = await _playerStateService.UpdatePlayerPositionAsync( + gameId, playerId, moveCommand.NewPosition, moveCommand.Timestamp); + + if (!updateResult.Success) + { + return new MoveResult + { + Success = false, + Errors = updateResult.Errors + }; + } + + // 检测碰撞和交互 + var events = new List(); + await CheckMoveCollisionsAsync(gameId, playerId, moveCommand.NewPosition, events); + + var result = new MoveResult + { + Success = true, + OldPosition = oldPosition, + NewPosition = moveCommand.NewPosition, + TriggeredEvents = events + }; + + _logger.LogDebug("玩家移动处理完成 - 游戏ID: {GameId}, 玩家ID: {PlayerId}, " + + "从 ({OldX},{OldY}) 移动到 ({NewX},{NewY})", + gameId, playerId, oldPosition.X, oldPosition.Y, + moveCommand.NewPosition.X, moveCommand.NewPosition.Y); + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "处理玩家移动时发生错误 - 游戏ID: {GameId}, 玩家ID: {PlayerId}", + gameId, playerId); + return new MoveResult + { + Success = false, + Errors = new List { "移动处理失败" } + }; + } + } + + #endregion + + #region 攻击处理 + + /// + /// 处理玩家攻击行为 + /// 验证攻击条件，计算伤害，更新游戏状态 + /// + public async Task ProcessPlayerAttackAsync(Guid gameId, Guid attackerId, AttackCommand attackCommand) + { + if (gameId == Guid.Empty || attackerId == Guid.Empty || attackCommand == null) + { + _logger.LogWarning("处理玩家攻击失败：无效的参数"); + return new AttackResult + { + Success = false, + Errors = new List { "无效的攻击参数" } + }; + } + + try + { + // 防止操作过于频繁 + if (!await ValidateActionRateAsync(attackerId)) + { + return new AttackResult + { + Success = false, + Errors = new List { "攻击过于频繁，请稍后重试" } + }; + } + + // 获取攻击者状态 + var attackerState = await _playerStateService.GetPlayerStateAsync(gameId, attackerId); + if (attackerState == null || attackerState.State == PlayerDrawingState.Dead) + { + return new AttackResult + { + Success = false, + Errors = new List { "攻击者状态无效或已死亡" } + }; + } + + // 验证攻击条件 + var validationResult = await ValidateAttackAsync(gameId, attackerId, attackCommand); + if (!validationResult.IsValid) + { + return new AttackResult + { + Success = false, + Errors = validationResult.Errors + }; + } + + var events = new List(); + var affectedPlayers = new List(); + + // 执行攻击逻辑 + float damageDealt = 0; + + if (attackCommand.TargetPlayerId.HasValue) + { + // 针对特定玩家的攻击 + damageDealt = await ProcessPlayerAttackAsync(gameId, attackerId, + attackCommand.TargetPlayerId.Value, attackCommand, events); + + if (damageDealt > 0) + { + affectedPlayers.Add(attackCommand.TargetPlayerId.Value); + } + } + else + { + // 区域攻击 + damageDealt = await ProcessAreaAttackAsync(gameId, attackerId, + attackCommand.TargetPosition, attackCommand, events, affectedPlayers); + } + + var result = new AttackResult + { + Success = damageDealt > 0, + DamageDealt = damageDealt, + AffectedPlayers = affectedPlayers, + TriggeredEvents = events + }; + + if (!result.Success && result.Errors.Count == 0) + { + result.Errors.Add("攻击未命中目标"); + } + + _logger.LogInformation("玩家攻击处理完成 - 游戏ID: {GameId}, 攻击者ID: {AttackerId}, " + + "伤害: {Damage}, 影响玩家数: {AffectedCount}", + gameId, attackerId, damageDealt, affectedPlayers.Count); + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "处理玩家攻击时发生错误 - 游戏ID: {GameId}, 攻击者ID: {AttackerId}", + gameId, attackerId); + return new AttackResult + { + Success = false, + Errors = new List { "攻击处理失败" } + }; + } + } + + #endregion + + #region 物品收集 + + /// + /// 处理物品收集 + /// 验证收集条件，更新玩家库存，移除地图物品 + /// + public async Task ProcessItemCollectionAsync(Guid gameId, Guid playerId, Guid itemId) + { + if (gameId == Guid.Empty || playerId == Guid.Empty || itemId == Guid.Empty) + { + _logger.LogWarning("处理物品收集失败：无效的参数"); + return new CollectResult + { + Success = false, + Errors = new List { "无效的收集参数" } + }; + } + + try + { + // 防止操作过于频繁 + if (!await ValidateActionRateAsync(playerId)) + { + return new CollectResult + { + Success = false, + Errors = new List { "操作过于频繁，请稍后重试" } + }; + } + + // 验证玩家状态 + var playerState = await _playerStateService.GetPlayerStateAsync(gameId, playerId); + if (playerState == null || playerState.State == PlayerDrawingState.Dead) + { + return new CollectResult + { + Success = false, + Errors = new List { "玩家状态无效或已死亡" } + }; + } + + // 使用道具服务处理收集 + var collectResult = await _powerUpService.PickupPowerUpAsync(gameId, playerId, itemId, playerState.CurrentPosition); + if (!collectResult.Success) + { + return new CollectResult + { + Success = false, + Errors = collectResult.Errors + }; + } + + var events = new List + { + new GameEvent + { + EventType = "item_collected", + PlayerId = playerId, + Description = "玩家收集了物品", + Timestamp = DateTime.UtcNow, + Data = new Dictionary { ["item_id"] = itemId } + } + }; + + var result = new CollectResult + { + Success = true, + ItemName = "游戏道具", // 简化实现 + Quantity = 1, + TriggeredEvents = events + }; + + _logger.LogInformation("物品收集完成 - 游戏ID: {GameId}, 玩家ID: {PlayerId}, 物品ID: {ItemId}", + gameId, playerId, itemId); + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "处理物品收集时发生错误 - 游戏ID: {GameId}, 玩家ID: {PlayerId}, 物品ID: {ItemId}", + gameId, playerId, itemId); + return new CollectResult + { + Success = false, + Errors = new List { "收集处理失败" } + }; + } + } + + #endregion + + #region 技能使用 + + /// + /// 使用道具/技能 + /// 验证使用条件，应用道具效果，更新冷却时间 + /// + public async Task UsePlayerSkillAsync(Guid gameId, Guid playerId, SkillUseCommand skillCommand) + { + if (gameId == Guid.Empty || playerId == Guid.Empty || skillCommand == null) + { + _logger.LogWarning("使用技能失败：无效的参数"); + return new SkillUseResult + { + Success = false, + Errors = new List { "无效的技能参数" } + }; + } + + try + { + // 检查技能冷却 + var cooldownKey = $"{playerId}_{skillCommand.SkillId}"; + if (_cooldownTracker.ContainsKey(cooldownKey)) + { + var remaining = _cooldownTracker[cooldownKey]; + if (remaining > TimeSpan.Zero) + { + return new SkillUseResult + { + Success = false, + SkillId = skillCommand.SkillId, + CooldownRemaining = remaining, + Errors = new List { $"技能冷却中，剩余时间: {remaining.TotalSeconds:F1}秒" } + }; + } + } + + // 验证玩家状态 + var playerState = await _playerStateService.GetPlayerStateAsync(gameId, playerId); + if (playerState == null || playerState.State == PlayerDrawingState.Dead) + { + return new SkillUseResult + { + Success = false, + Errors = new List { "玩家状态无效或已死亡" } + }; + } + + // 使用道具服务处理技能使用（简化实现） + bool useSuccess = false; + + switch (skillCommand.SkillId.ToLower()) + { + case "lightning": + case "speed_boost": + var lightningResult = await _powerUpService.UseLightningPowerUpAsync(gameId, playerId); + useSuccess = lightningResult.Success; + break; + case "shield": + var shieldResult = await _powerUpService.UseShieldPowerUpAsync(gameId, playerId); + useSuccess = shieldResult.Success; + break; + case "bomb": + var bombResult = await _powerUpService.UseBombPowerUpAsync(gameId, playerId, + skillCommand.TargetPosition ?? playerState.CurrentPosition); + useSuccess = bombResult.Success; + break; + case "ghost": + case "teleport": + var ghostResult = await _powerUpService.UseGhostPowerUpAsync(gameId, playerId); + useSuccess = ghostResult.Success; + break; + default: + useSuccess = false; + break; + } + + if (!useSuccess) + { + return new SkillUseResult + { + Success = false, + SkillId = skillCommand.SkillId, + Errors = new List { "技能使用失败或道具不可用" } + }; + } + + // 设置技能冷却 + var cooldownDuration = GetSkillCooldown(skillCommand.SkillId); + _cooldownTracker[cooldownKey] = cooldownDuration; + + var events = new List + { + new GameEvent + { + EventType = "skill_used", + PlayerId = playerId, + Description = $"玩家使用了技能: {skillCommand.SkillId}", + Timestamp = DateTime.UtcNow, + Data = new Dictionary + { + ["skill_id"] = skillCommand.SkillId, + ["cooldown_seconds"] = cooldownDuration.TotalSeconds + } + } + }; + + var result = new SkillUseResult + { + Success = true, + SkillId = skillCommand.SkillId, + CooldownRemaining = cooldownDuration, + AffectedPlayers = new List { playerId }, + TriggeredEvents = events + }; + + _logger.LogInformation("技能使用完成 - 游戏ID: {GameId}, 玩家ID: {PlayerId}, 技能: {SkillId}", + gameId, playerId, skillCommand.SkillId); + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "使用技能时发生错误 - 游戏ID: {GameId}, 玩家ID: {PlayerId}, 技能: {SkillId}", + gameId, playerId, skillCommand?.SkillId); + return new SkillUseResult + { + Success = false, + SkillId = skillCommand?.SkillId ?? "unknown", + Errors = new List { "技能使用处理失败" } + }; + } + } + + #endregion + + #region 领土占领 + + /// + /// 处理领土占领 + /// 验证占领条件，更新领土归属，计算影响范围 + /// + public async Task ProcessTerritoryClaimAsync(Guid gameId, Guid playerId, TerritoryClaimCommand territoryCommand) + { + if (gameId == Guid.Empty || playerId == Guid.Empty || territoryCommand == null) + { + _logger.LogWarning("处理领土占领失败：无效的参数"); + return new TerritoryClaimResult + { + Success = false, + Errors = new List { "无效的领土占领参数" } + }; + } + + try + { + // 防止操作过于频繁 + if (!await ValidateActionRateAsync(playerId)) + { + return new TerritoryClaimResult + { + Success = false, + Errors = new List { "操作过于频繁，请稍后重试" } + }; + } + + // 验证玩家状态 + var playerState = await _playerStateService.GetPlayerStateAsync(gameId, playerId); + if (playerState == null || playerState.State == PlayerDrawingState.Dead) + { + return new TerritoryClaimResult + { + Success = false, + Errors = new List { "玩家状态无效或已死亡" } + }; + } + + // 使用领土服务处理占领 + var claimResult = await _territoryService.CompleteTerritoryAsync(gameId, playerId, + territoryCommand.Position); + + if (!claimResult.Success) + { + return new TerritoryClaimResult + { + Success = false, + Errors = new List { claimResult.ErrorMessage ?? "领土占领失败" } + }; + } + + // 计算奖励积分 + var bonusScore = (int)(claimResult.AreaGained * 10); + // 简化实现：直接在玩家状态中更新（AddPlayerScoreAsync 方法不存在） + + var events = new List + { + new GameEvent + { + EventType = "territory_claimed", + PlayerId = playerId, + Description = $"玩家占领了面积为 {claimResult.AreaGained:F1} 的领土", + Timestamp = DateTime.UtcNow, + Data = new Dictionary + { + ["area_gained"] = claimResult.AreaGained, + ["bonus_score"] = bonusScore, + ["territory_count"] = claimResult.NewTerritory.Count + } + } + }; + + var result = new TerritoryClaimResult + { + Success = true, + TerritoryId = Guid.NewGuid(), // 简化实现，生成新ID + TerritoryGained = (float)claimResult.AreaGained, + TerritoryLost = 0, + NewTotalArea = (float)claimResult.NewTotalArea, + BonusScore = bonusScore, + AffectedPlayers = claimResult.ConqueredPlayers.Concat(new[] { playerId }).ToList(), + Messages = new List { $"成功占领 {claimResult.AreaGained:F1} 面积的领土" }, + TriggeredEvents = events + }; + + _logger.LogInformation("领土占领完成 - 游戏ID: {GameId}, 玩家ID: {PlayerId}, " + + "占领面积: {AreaGained}, 奖励积分: {BonusScore}", + gameId, playerId, claimResult.AreaGained, bonusScore); + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "处理领土占领时发生错误 - 游戏ID: {GameId}, 玩家ID: {PlayerId}", + gameId, playerId); + return new TerritoryClaimResult + { + Success = false, + Errors = new List { "领土占领处理失败" } + }; + } + } + + #endregion + + #region 规则检查 + + /// + /// 执行游戏规则检查 + /// 检查当前游戏状态是否符合规则要求 + /// + public async Task ExecuteRuleCheckAsync(Guid gameId) + { + if (gameId == Guid.Empty) + { + _logger.LogWarning("执行规则检查失败：无效的游戏ID"); + return new RuleCheckResult + { + IsValid = false, + Violations = new List { "无效的游戏ID" } + }; + } + + try + { + var violations = new List(); + var warnings = new List(); + var events = new List(); + + // 检查游戏状态 + var gameState = await _gameStateService.GetGameStateAsync(gameId); + if (gameState == null) + { + violations.Add("游戏状态不存在"); + } + else + { + // 检查游戏时间限制 + if (gameState.ElapsedTime > TimeSpan.FromHours(2)) + { + warnings.Add("游戏时间过长，建议结束"); + } + + // 检查游戏状态一致性 + if (gameState.Status == GameStatus.Playing && gameState.RemainingTime <= TimeSpan.Zero) + { + violations.Add("游戏状态与剩余时间不一致"); + + events.Add(new GameEvent + { + EventType = "game_time_expired", + Description = "游戏时间已到，需要结束游戏", + Timestamp = DateTime.UtcNow + }); + } + } + + // 检查玩家状态 + var playerStates = await _playerStateService.GetAllPlayerStatesAsync(gameId); + if (playerStates.Any()) + { + var alivePlayers = playerStates.Count(p => p.State != PlayerDrawingState.Dead); + + // 检查获胜条件 + if (alivePlayers <= 1 && gameState?.Status == GameStatus.Playing) + { + events.Add(new GameEvent + { + EventType = "game_should_end", + Description = "只剩一个或零个存活玩家，游戏应该结束", + Timestamp = DateTime.UtcNow, + Data = new Dictionary { ["alive_players"] = alivePlayers } + }); + } + + // 检查玩家位置合法性 + foreach (var player in playerStates) + { + if (player.CurrentPosition.X < 0 || player.CurrentPosition.Y < 0 || + player.CurrentPosition.X > 1000 || player.CurrentPosition.Y > 1000) // 假设地图大小为1000x1000 + { + violations.Add($"玩家 {player.PlayerId} 的位置超出地图边界"); + } + } + } + + var result = new RuleCheckResult + { + IsValid = violations.Count == 0, + Violations = violations, + Warnings = warnings, + TriggeredEvents = events + }; + + _logger.LogDebug("游戏规则检查完成 - 游戏ID: {GameId}, 是否合规: {IsValid}, " + + "违规数: {ViolationCount}, 警告数: {WarningCount}", + gameId, result.IsValid, violations.Count, warnings.Count); + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "执行游戏规则检查时发生错误 - 游戏ID: {GameId}", gameId); + return new RuleCheckResult + { + IsValid = false, + Violations = new List { "规则检查失败" } + }; + } + } + + #endregion + + #region 可用行为查询 + + /// + /// 获取玩家可执行的行为列表 + /// 基于当前游戏状态和玩家状态，返回合法的行为选项 + /// + public async Task> GetAvailableActionsAsync(Guid gameId, Guid playerId) + { + if (gameId == Guid.Empty || playerId == Guid.Empty) + { + _logger.LogWarning("获取可用行为失败：无效的参数"); + return new List(); + } + + try + { + // 检查缓存 + var cacheKey = gameId; + if (_actionCache.TryGetValue(cacheKey, out var cachedActions)) + { + // 缓存有效期5秒 + if (_lastActionTime.ContainsKey(cacheKey) && + DateTime.UtcNow - _lastActionTime[cacheKey] < TimeSpan.FromSeconds(5)) + { + return cachedActions; + } + } + + var actions = new List(); + + // 验证基本状态 + var playerState = await _playerStateService.GetPlayerStateAsync(gameId, playerId); + var gameState = await _gameStateService.GetGameStateAsync(gameId); + + if (playerState == null || gameState == null) + { + return actions; + } + + var isPlayerAlive = playerState.State != PlayerDrawingState.Dead; + var isGameInProgress = gameState.Status == GameStatus.Playing; + + // 移动行为 + actions.Add(new AvailableAction + { + ActionId = "move", + ActionName = "移动", + ActionType = ActionType.Move, + IsAvailable = isPlayerAlive && isGameInProgress, + DisabledReason = !isPlayerAlive ? "玩家已死亡" : !isGameInProgress ? "游戏未进行" : null, + Parameters = new Dictionary + { + ["max_speed"] = MAX_MOVE_SPEED, + ["can_move_outside_territory"] = true + } + }); + + // 攻击行为 + actions.Add(new AvailableAction + { + ActionId = "attack", + ActionName = "攻击", + ActionType = ActionType.Attack, + IsAvailable = isPlayerAlive && isGameInProgress, + DisabledReason = !isPlayerAlive ? "玩家已死亡" : !isGameInProgress ? "游戏未进行" : null, + Parameters = new Dictionary + { + ["min_damage"] = MIN_ATTACK_DAMAGE, + ["max_damage"] = MAX_ATTACK_DAMAGE, + ["attack_types"] = new[] { "melee", "ranged" } + } + }); + + // 物品收集行为 + var nearbyItems = await GetNearbyItemsAsync(gameId, playerState.CurrentPosition); + actions.Add(new AvailableAction + { + ActionId = "collect", + ActionName = "收集物品", + ActionType = ActionType.Collect, + IsAvailable = isPlayerAlive && isGameInProgress && nearbyItems.Any(), + DisabledReason = !isPlayerAlive ? "玩家已死亡" : + !isGameInProgress ? "游戏未进行" : + !nearbyItems.Any() ? "附近没有可收集的物品" : null, + Parameters = new Dictionary + { + ["nearby_items_count"] = nearbyItems.Count, + ["collect_range"] = 30.0f + } + }); + + // 技能使用行为 + var availableSkills = await GetAvailableSkillsAsync(gameId, playerId); + foreach (var skill in availableSkills) + { + var cooldownKey = $"{playerId}_{skill.SkillId}"; + var cooldownRemaining = _cooldownTracker.ContainsKey(cooldownKey) ? + _cooldownTracker[cooldownKey] : TimeSpan.Zero; + + actions.Add(new AvailableAction + { + ActionId = $"skill_{skill.SkillId}", + ActionName = $"使用技能: {skill.Name}", + ActionType = ActionType.UseSkill, + IsAvailable = isPlayerAlive && isGameInProgress && cooldownRemaining <= TimeSpan.Zero, + DisabledReason = !isPlayerAlive ? "玩家已死亡" : + !isGameInProgress ? "游戏未进行" : + cooldownRemaining > TimeSpan.Zero ? $"冷却中: {cooldownRemaining.TotalSeconds:F1}秒" : null, + CooldownRemaining = cooldownRemaining > TimeSpan.Zero ? cooldownRemaining : null, + Parameters = new Dictionary + { + ["skill_id"] = skill.SkillId, + ["skill_type"] = skill.Type, + ["cooldown_seconds"] = GetSkillCooldown(skill.SkillId).TotalSeconds + } + }); + } + + // 领土占领行为 + actions.Add(new AvailableAction + { + ActionId = "claim_territory", + ActionName = "占领领土", + ActionType = ActionType.ClaimTerritory, + IsAvailable = isPlayerAlive && isGameInProgress, + DisabledReason = !isPlayerAlive ? "玩家已死亡" : !isGameInProgress ? "游戏未进行" : null, + Parameters = new Dictionary + { + ["max_claim_radius"] = TERRITORY_CLAIM_RADIUS, + ["territory_types"] = Enum.GetNames() + } + }); + + // 更新缓存 + _actionCache.TryRemove(cacheKey, out _); + _actionCache.TryAdd(cacheKey, actions); + _lastActionTime[cacheKey] = DateTime.UtcNow; + + _logger.LogDebug("获取可用行为完成 - 游戏ID: {GameId}, 玩家ID: {PlayerId}, 行为数: {ActionCount}", + gameId, playerId, actions.Count); + + return actions; + } + catch (Exception ex) + { + _logger.LogError(ex, "获取可用行为时发生错误 - 游戏ID: {GameId}, 玩家ID: {PlayerId}", + gameId, playerId); + return new List(); + } + } + + #endregion + + #region 行为预测 + + /// + /// 计算行为执行的预期结果 + /// 在不实际执行的情况下，模拟行为的影响 + /// + public async Task PredictActionResultAsync(Guid gameId, Guid playerId, IGameActionCommand actionCommand) + { + if (gameId == Guid.Empty || playerId == Guid.Empty || actionCommand == null) + { + _logger.LogWarning("预测行为结果失败：无效的参数"); + return new ActionPredictionResult + { + CanExecute = false, + SuccessProbability = 0, + Risks = new List { "无效的预测参数" } + }; + } + + try + { + var prediction = new ActionPredictionResult(); + var predictedEffects = new List(); + var risks = new List(); + var predictedChanges = new Dictionary(); + + // 获取当前状态 + var playerState = await _playerStateService.GetPlayerStateAsync(gameId, playerId); + var gameState = await _gameStateService.GetGameStateAsync(gameId); + + if (playerState == null || gameState == null) + { + return new ActionPredictionResult + { + CanExecute = false, + SuccessProbability = 0, + Risks = new List { "无法获取游戏状态" } + }; + } + + // 基于行为类型进行预测 + switch (actionCommand) + { + case MoveCommand moveCmd: + await PredictMoveResult(gameId, playerState, moveCmd, prediction, + predictedEffects, risks, predictedChanges); + break; + + case AttackCommand attackCmd: + await PredictAttackResult(gameId, playerState, attackCmd, prediction, + predictedEffects, risks, predictedChanges); + break; + + case SkillUseCommand skillCmd: + await PredictSkillResult(gameId, playerState, skillCmd, prediction, + predictedEffects, risks, predictedChanges); + break; + + case TerritoryClaimCommand territoryCmd: + await PredictTerritoryResult(gameId, playerState, territoryCmd, prediction, + predictedEffects, risks, predictedChanges); + break; + + default: + prediction.CanExecute = false; + prediction.SuccessProbability = 0; + risks.Add("未知的行为类型"); + break; + } + + prediction.PredictedEffects = predictedEffects; + prediction.Risks = risks; + prediction.PredictedChanges = predictedChanges; + + _logger.LogDebug("行为预测完成 - 游戏ID: {GameId}, 玩家ID: {PlayerId}, " + + "可执行: {CanExecute}, 成功率: {SuccessProbability:P}", + gameId, playerId, prediction.CanExecute, prediction.SuccessProbability); + + return prediction; + } + catch (Exception ex) + { + _logger.LogError(ex, "预测行为结果时发生错误 - 游戏ID: {GameId}, 玩家ID: {PlayerId}", + gameId, playerId); + return new ActionPredictionResult + { + CanExecute = false, + SuccessProbability = 0, + Risks = new List { "预测处理失败" } + }; + } + } + + #endregion + + #region 辅助方法 + + /// + /// 验证操作频率限制 + /// + private Task ValidateActionRateAsync(Guid playerId) + { + var now = DateTime.UtcNow; + + if (_lastActionTime.TryGetValue(playerId, out var lastTime)) + { + var timeSinceLastAction = now - lastTime; + if (timeSinceLastAction.TotalMilliseconds < ACTION_COOLDOWN_MS) + { + return Task.FromResult(false); + } + } + + _lastActionTime[playerId] = now; + return Task.FromResult(true); + } + + /// + /// 验证移动合法性 + /// + private async Task ValidateMoveAsync(Guid gameId, Guid playerId, MoveCommand moveCommand) + { + var result = new ValidationResult(); + + // 验证速度 + if (moveCommand.Speed > MAX_MOVE_SPEED) + { + result.Errors.Add($"移动速度过快，最大允许速度: {MAX_MOVE_SPEED}"); + } + + // 验证位置边界 + if (moveCommand.NewPosition.X < 0 || moveCommand.NewPosition.Y < 0 || + moveCommand.NewPosition.X > 1000 || moveCommand.NewPosition.Y > 1000) + { + result.Errors.Add("目标位置超出地图边界"); + } + + result.IsValid = result.Errors.Count == 0; + return await Task.FromResult(result); + } + + /// + /// 验证攻击合法性 + /// + private async Task ValidateAttackAsync(Guid gameId, Guid attackerId, AttackCommand attackCommand) + { + var result = new ValidationResult(); + + // 验证伤害范围 + if (attackCommand.Damage < MIN_ATTACK_DAMAGE || attackCommand.Damage > MAX_ATTACK_DAMAGE) + { + result.Errors.Add($"攻击伤害超出允许范围: {MIN_ATTACK_DAMAGE}-{MAX_ATTACK_DAMAGE}"); + } + + // 验证目标存在性（如果指定了目标玩家） + if (attackCommand.TargetPlayerId.HasValue) + { + var targetState = await _playerStateService.GetPlayerStateAsync(gameId, attackCommand.TargetPlayerId.Value); + if (targetState == null || targetState.State == PlayerDrawingState.Dead) + { + result.Errors.Add("攻击目标不存在或已死亡"); + } + } + + result.IsValid = result.Errors.Count == 0; + return result; + } + + /// + /// 检查移动碰撞 + /// + private async Task CheckMoveCollisionsAsync(Guid gameId, Guid playerId, Position newPosition, List events) + { + // 简化实现：获取当前玩家状态来检查轨迹碰撞 + var playerState = await _playerStateService.GetPlayerStateAsync(gameId, playerId); + if (playerState == null) return; + + var fromPosition = playerState.CurrentPosition; + + // 检查与其他玩家的轨迹碰撞 + var collision = await _collisionDetectionService.CheckTrailCollisionAsync( + gameId, playerId, fromPosition, newPosition, playerState.State == PlayerDrawingState.Drawing); + + if (collision.HasCollision) + { + events.Add(new GameEvent + { + EventType = "trail_collision", + PlayerId = playerId, + Description = "玩家移动时发生轨迹碰撞", + Timestamp = DateTime.UtcNow, + Data = new Dictionary + { + ["collision_type"] = collision.CollisionType.ToString(), + ["collision_point"] = collision.CollisionPoint + } + }); + } + + // 检查道具收集 + var nearbyItems = await GetNearbyItemsAsync(gameId, newPosition); + if (nearbyItems.Any()) + { + events.Add(new GameEvent + { + EventType = "near_items", + PlayerId = playerId, + Description = "玩家移动到道具附近", + Timestamp = DateTime.UtcNow, + Data = new Dictionary { ["nearby_items"] = nearbyItems.Count } + }); + } + } + + /// + /// 处理对玩家的攻击 + /// + private async Task ProcessPlayerAttackAsync(Guid gameId, Guid attackerId, Guid targetId, AttackCommand attackCommand, List events) + { + var damage = Math.Max(MIN_ATTACK_DAMAGE, Math.Min(attackCommand.Damage, MAX_ATTACK_DAMAGE)); + + // 简化实现：直接处理玩家死亡（在实际游戏中可能需要生命值系统） + var deathResult = await _playerStateService.HandlePlayerDeathAsync(gameId, targetId, "攻击伤害", attackerId); + + if (deathResult.Success) + { + events.Add(new GameEvent + { + EventType = "player_attacked", + PlayerId = attackerId, + Description = $"对玩家 {targetId} 造成致命攻击", + Timestamp = DateTime.UtcNow, + Data = new Dictionary + { + ["target_id"] = targetId, + ["damage"] = damage, + ["attack_type"] = attackCommand.AttackType, + ["player_died"] = deathResult.Success + } + }); + + return damage; + } + + return 0; + } + + /// + /// 处理区域攻击 + /// + private async Task ProcessAreaAttackAsync(Guid gameId, Guid attackerId, Position targetPosition, AttackCommand attackCommand, List events, List affectedPlayers) + { + var totalDamage = 0f; + var attackRadius = 100f; // 区域攻击半径 + + var allPlayers = await _playerStateService.GetAllPlayerStatesAsync(gameId); + foreach (var player in allPlayers) + { + if (player.PlayerId == attackerId || player.State == PlayerDrawingState.Dead) + continue; + + var distance = CalculateDistance(player.CurrentPosition, targetPosition); + if (distance <= attackRadius) + { + var damage = Math.Max(MIN_ATTACK_DAMAGE, attackCommand.Damage * (1 - distance / attackRadius)); + var deathResult = await _playerStateService.HandlePlayerDeathAsync(gameId, player.PlayerId, "区域攻击", attackerId); + + if (deathResult.Success) + { + totalDamage += damage; + affectedPlayers.Add(player.PlayerId); + } + } + } + + if (totalDamage > 0) + { + events.Add(new GameEvent + { + EventType = "area_attack", + PlayerId = attackerId, + Description = $"区域攻击影响了 {affectedPlayers.Count} 个玩家", + Timestamp = DateTime.UtcNow, + Data = new Dictionary + { + ["total_damage"] = totalDamage, + ["affected_count"] = affectedPlayers.Count, + ["attack_radius"] = attackRadius + } + }); + } + + return totalDamage; + } + + /// + /// 获取附近的物品 + /// + private async Task> GetNearbyItemsAsync(Guid gameId, Position position) + { + var allItems = await _powerUpService.GetMapPowerUpsAsync(gameId); + var nearbyItems = new List(); + + foreach (var item in allItems) + { + var distance = CalculateDistance(position, item.Position); + if (distance <= 30f) // 30单位收集范围 + { + nearbyItems.Add(item); + } + } + + return nearbyItems; + } + + /// + /// 获取可用技能列表 + /// + private async Task> GetAvailableSkillsAsync(Guid gameId, Guid playerId) + { + // 简化实现，返回基本技能 + return await Task.FromResult(new List + { + new SkillInfo { SkillId = "speed_boost", Name = "速度提升", Type = "buff" }, + new SkillInfo { SkillId = "shield", Name = "护盾", Type = "defense" }, + new SkillInfo { SkillId = "teleport", Name = "传送", Type = "movement" } + }); + } + + /// + /// 获取技能冷却时间 + /// + private TimeSpan GetSkillCooldown(string skillId) + { + return skillId switch + { + "speed_boost" => TimeSpan.FromSeconds(30), + "shield" => TimeSpan.FromSeconds(45), + "teleport" => TimeSpan.FromSeconds(60), + _ => TimeSpan.FromSeconds(10) + }; + } + + /// + /// 计算两点间距离 + /// + private float CalculateDistance(Position pos1, Position pos2) + { + var dx = pos1.X - pos2.X; + var dy = pos1.Y - pos2.Y; + return (float)Math.Sqrt(dx * dx + dy * dy); + } + + #region 预测辅助方法 + + /// + /// 预测移动结果 + /// + private async Task PredictMoveResult(Guid gameId, PlayerGameState playerState, MoveCommand moveCommand, + ActionPredictionResult prediction, List effects, List risks, Dictionary changes) + { + prediction.CanExecute = playerState.State != PlayerDrawingState.Dead; + prediction.SuccessProbability = prediction.CanExecute ? 0.95f : 0; + + if (prediction.CanExecute) + { + effects.Add("玩家位置将更新"); + changes["new_position"] = new { moveCommand.NewPosition.X, moveCommand.NewPosition.Y }; + + // 检查移动风险 + var nearbyPlayers = await GetNearbyPlayersAsync(gameId, moveCommand.NewPosition); + if (nearbyPlayers.Any()) + { + risks.Add("移动到敌对玩家附近，可能遭受攻击"); + prediction.SuccessProbability *= 0.8f; + } + } + else + { + risks.Add("玩家已死亡，无法移动"); + } + } + + /// + /// 预测攻击结果 + /// + private async Task PredictAttackResult(Guid gameId, PlayerGameState playerState, AttackCommand attackCommand, + ActionPredictionResult prediction, List effects, List risks, Dictionary changes) + { + prediction.CanExecute = playerState.State != PlayerDrawingState.Dead; + prediction.SuccessProbability = prediction.CanExecute ? 0.7f : 0; + + if (prediction.CanExecute && attackCommand.TargetPlayerId.HasValue) + { + var target = await _playerStateService.GetPlayerStateAsync(gameId, attackCommand.TargetPlayerId.Value); + if (target != null && target.State != PlayerDrawingState.Dead) + { + effects.Add($"将对目标造成攻击"); + changes["damage_dealt"] = attackCommand.Damage; + // 简化实现：假设攻击会导致目标死亡 + changes["target_defeated"] = true; + + effects.Add("目标玩家将被击败"); + changes["target_defeated"] = true; + } + else + { + risks.Add("攻击目标不存在或已死亡"); + prediction.SuccessProbability = 0; + } + } + else if (!prediction.CanExecute) + { + risks.Add("玩家已死亡，无法攻击"); + } + } + + /// + /// 预测技能结果 + /// + private Task PredictSkillResult(Guid gameId, PlayerGameState playerState, SkillUseCommand skillCommand, + ActionPredictionResult prediction, List effects, List risks, Dictionary changes) + { + var cooldownKey = $"{playerState.PlayerId}_{skillCommand.SkillId}"; + var hasCD = _cooldownTracker.ContainsKey(cooldownKey) && _cooldownTracker[cooldownKey] > TimeSpan.Zero; + + prediction.CanExecute = playerState.State != PlayerDrawingState.Dead && !hasCD; + prediction.SuccessProbability = prediction.CanExecute ? 0.9f : 0; + + if (prediction.CanExecute) + { + effects.Add($"将使用技能: {skillCommand.SkillId}"); + changes["skill_used"] = skillCommand.SkillId; + changes["cooldown_applied"] = GetSkillCooldown(skillCommand.SkillId).TotalSeconds; + + // 基于技能类型添加特定效果 + switch (skillCommand.SkillId) + { + case "speed_boost": + effects.Add("移动速度将临时提升"); + break; + case "shield": + effects.Add("将获得临时护盾"); + break; + case "teleport": + effects.Add("将传送到指定位置"); + risks.Add("传送位置可能不安全"); + break; + } + } + else + { + if (playerState.State == PlayerDrawingState.Dead) + risks.Add("玩家已死亡，无法使用技能"); + if (hasCD) + risks.Add("技能正在冷却中"); + } + + return Task.CompletedTask; + } + + /// + /// 预测领土占领结果 + /// + private async Task PredictTerritoryResult(Guid gameId, PlayerGameState playerState, TerritoryClaimCommand territoryCommand, + ActionPredictionResult prediction, List effects, List risks, Dictionary changes) + { + prediction.CanExecute = playerState.State != PlayerDrawingState.Dead; + prediction.SuccessProbability = prediction.CanExecute ? 0.8f : 0; + + if (prediction.CanExecute) + { + var predictedArea = (float)Math.PI * territoryCommand.Radius * territoryCommand.Radius; + effects.Add($"将占领面积约为 {predictedArea:F1} 的领土"); + changes["territory_gained"] = predictedArea; + changes["bonus_score"] = (int)(predictedArea * 10); + + // 检查领土冲突风险 + var conflictRisk = await CheckTerritoryConflictRiskAsync(gameId, territoryCommand.Position, territoryCommand.Radius); + if (conflictRisk > 0) + { + risks.Add("占领区域与其他玩家领土重叠，可能引发冲突"); + prediction.SuccessProbability *= (1 - conflictRisk); + } + } + else + { + risks.Add("玩家已死亡，无法占领领土"); + } + } + + /// + /// 获取附近的玩家 + /// + private async Task> GetNearbyPlayersAsync(Guid gameId, Position position) + { + var allPlayers = await _playerStateService.GetAllPlayerStatesAsync(gameId); + return allPlayers.Where(p => p.State != PlayerDrawingState.Dead && + CalculateDistance(p.CurrentPosition, position) <= 50f).ToList(); + } + + /// + /// 检查领土冲突风险 + /// + private async Task CheckTerritoryConflictRiskAsync(Guid gameId, Position position, float radius) + { + // 简化实现：检查是否与现有领土重叠 + var allPlayers = await _playerStateService.GetAllPlayerStatesAsync(gameId); + var conflictCount = 0; + + foreach (var player in allPlayers) + { + foreach (var territory in player.OwnedTerritories) + { + // 简化实现：假设每个领土都有一个中心点和半径 + if (territory.Boundary.Any()) + { + var territoryCenter = new Position + { + X = territory.Boundary.Average(p => p.X), + Y = territory.Boundary.Average(p => p.Y) + }; + var territoryRadius = Math.Sqrt(territory.Area / Math.PI); // 假设为圆形领土 + + var distance = CalculateDistance(position, territoryCenter); + if (distance < radius + territoryRadius) + { + conflictCount++; + } + } + } + } + + return Math.Min(conflictCount * 0.2f, 0.8f); // 最多80%的冲突风险 + } + + #endregion + + #endregion +} + +/// +/// 验证结果类 +/// +public class ValidationResult +{ + public bool IsValid { get; set; } = true; + public List Errors { get; set; } = new(); +} + +/// +/// 技能信息类 +/// +public class SkillInfo +{ + public string SkillId { get; set; } = string.Empty; + public string Name { get; set; } = string.Empty; + public string Type { get; set; } = string.Empty; +} diff --git a/backend/src/CollabApp.Application/Services/Game/GameResultService.cs b/backend/src/CollabApp.Application/Services/Game/GameResultService.cs new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/backend/src/CollabApp.Application/Services/Game/GameStateService.cs b/backend/src/CollabApp.Application/Services/Game/GameStateService.cs new file mode 100644 index 0000000000000000000000000000000000000000..2894596b237b51fca7fa52bf9f378d7d5919da42 --- /dev/null +++ b/backend/src/CollabApp.Application/Services/Game/GameStateService.cs @@ -0,0 +1,694 @@ +using CollabApp.Application.Interfaces; +using CollabApp.Domain.Entities.Game; +using CollabApp.Domain.Services.Game; +using Microsoft.Extensions.Logging; +using System.Text.Json; + +namespace CollabApp.Application.Services.Game; + +/// +/// 游戏状态管理服务实现 +/// 负责管理游戏的整体状态，包括游戏生命周期、状态转换和状态验证 +/// +public class GameStateService : IGameStateService +{ + private readonly IRedisService _redisService; + private readonly ILogger _logger; + + /// + /// Redis键格式 + /// + private static class RedisKeys + { + public const string Game = "game:{0}"; + public const string GameState = "game_state:{0}"; + public const string GamePlayers = "game_players:{0}"; + public const string GameMetrics = "game_metrics:{0}"; + public const string GameTimers = "game_timers:{0}"; + public const string StateTransitionLog = "state_transition:{0}"; + } + + /// + /// 构造函数 + /// + /// Redis服务 + /// 日志记录器 + public GameStateService( + IRedisService redisService, + ILogger logger) + { + _redisService = redisService ?? throw new ArgumentNullException(nameof(redisService)); + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + /// + /// 初始化新游戏 + /// + public async Task InitializeGameAsync( + Guid gameId, + Guid roomId, + GameSettings gameSettings) + { + try + { + _logger.LogInformation("开始初始化游戏 - GameId: {GameId}, RoomId: {RoomId}", gameId, roomId); + + // 验证参数 + ValidateInitializationParameters(gameId, roomId, gameSettings); + + // 创建游戏实例 + var game = CollabApp.Domain.Entities.Game.Game.CreateGame( + roomId, + gameSettings.GameMode.ToString().ToLower(), + gameSettings.MapWidth, + gameSettings.MapHeight, + (int)gameSettings.Duration.TotalSeconds, + gameSettings.MapShape); + + // 设置游戏ID + var gameIdProperty = typeof(CollabApp.Domain.Entities.Game.Game) + .GetProperty("Id", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); + gameIdProperty?.SetValue(game, gameId); + + // 保存游戏基本信息到Redis + await SaveGameToRedisAsync(gameId, game, gameSettings); + + // 初始化游戏状态 + await InitializeGameStateAsync(gameId, gameSettings); + + // 初始化游戏指标 + await InitializeGameMetricsAsync(gameId); + + // 设置游戏定时器 + await SetupGameTimersAsync(gameId, gameSettings); + + _logger.LogInformation("游戏初始化完成 - GameId: {GameId}", gameId); + return game; + } + catch (Exception ex) + { + _logger.LogError(ex, "初始化游戏失败 - GameId: {GameId}", gameId); + throw; + } + } + + /// + /// 开始游戏 + /// + public async Task StartGameAsync(Guid gameId) + { + try + { + _logger.LogInformation("开始游戏 - GameId: {GameId}", gameId); + + // 获取当前游戏状态 + var currentState = await GetGameStateAsync(gameId); + if (currentState == null) + { + _logger.LogWarning("游戏不存在 - GameId: {GameId}", gameId); + return false; + } + + // 验证状态转换 + if (!await ValidateStateTransitionAsync(gameId, GameStatus.Playing)) + { + _logger.LogWarning("无法开始游戏，状态转换无效 - GameId: {GameId}, CurrentStatus: {Status}", + gameId, currentState.Status); + return false; + } + + // 检查玩家数量 + var playerCount = await GetConnectedPlayerCountAsync(gameId); + if (playerCount < 2) + { + _logger.LogWarning("玩家数量不足，无法开始游戏 - GameId: {GameId}, PlayerCount: {Count}", + gameId, playerCount); + return false; + } + + // 更新游戏状态 + var startTime = DateTime.UtcNow; + var metadata = new Dictionary + { + ["start_time"] = startTime, + ["player_count"] = playerCount, + ["started_by"] = "system" + }; + + var success = await UpdateGameStateAsync(gameId, GameStatus.Playing, metadata); + if (!success) + { + _logger.LogError("更新游戏状态失败 - GameId: {GameId}", gameId); + return false; + } + + // 启动游戏计时器 + await StartGameTimerAsync(gameId, startTime); + + // 记录游戏开始事件 + await LogStateTransitionAsync(gameId, GameStatus.Preparing, GameStatus.Playing, "Game started"); + + _logger.LogInformation("游戏开始成功 - GameId: {GameId}, PlayerCount: {Count}", gameId, playerCount); + return true; + } + catch (Exception ex) + { + _logger.LogError(ex, "开始游戏失败 - GameId: {GameId}", gameId); + return false; + } + } + + /// + /// 结束游戏 + /// + public async Task EndGameAsync(Guid gameId, GameEndReason reason) + { + try + { + _logger.LogInformation("结束游戏 - GameId: {GameId}, Reason: {Reason}", gameId, reason); + + // 获取当前游戏状态 + var currentState = await GetGameStateAsync(gameId); + if (currentState == null) + { + throw new InvalidOperationException($"游戏不存在 - GameId: {gameId}"); + } + + // 验证状态转换 + if (!await ValidateStateTransitionAsync(gameId, GameStatus.Finished)) + { + _logger.LogWarning("无法结束游戏，状态转换无效 - GameId: {GameId}, CurrentStatus: {Status}", + gameId, currentState.Status); + } + + // 停止游戏计时器 + await StopGameTimerAsync(gameId); + + // 收集游戏结果数据 + var endResult = await CollectGameEndDataAsync(gameId, reason); + + // 更新游戏状态为已结束 + var metadata = new Dictionary + { + ["end_time"] = endResult.EndTime, + ["end_reason"] = reason.ToString(), + ["total_players"] = endResult.PlayerResults.Count, + ["duration"] = endResult.Statistics.TotalDuration.TotalSeconds + }; + + await UpdateGameStateAsync(gameId, GameStatus.Finished, metadata); + + // 记录状态转换 + await LogStateTransitionAsync(gameId, currentState.Status, GameStatus.Finished, + $"Game ended: {reason}"); + + // 清理游戏资源 + await CleanupGameResourcesAsync(gameId); + + _logger.LogInformation("游戏结束完成 - GameId: {GameId}, Duration: {Duration}s", + gameId, endResult.Statistics.TotalDuration.TotalSeconds); + + return endResult; + } + catch (Exception ex) + { + _logger.LogError(ex, "结束游戏失败 - GameId: {GameId}", gameId); + throw; + } + } + + /// + /// 获取游戏当前状态 + /// + public async Task GetGameStateAsync(Guid gameId) + { + try + { + var stateKey = string.Format(RedisKeys.GameState, gameId); + var stateData = await _redisService.GetHashAllAsync(stateKey); + + if (!stateData.Any()) + { + _logger.LogWarning("游戏状态不存在 - GameId: {GameId}", gameId); + return null!; + } + + var gameStateInfo = new GameStateInfo + { + GameId = gameId, + Status = ParseGameStatus(stateData.GetValueOrDefault("status") ?? "Preparing"), + ConnectedPlayers = int.Parse(stateData.GetValueOrDefault("connected_players", "0")) + }; + + // 解析时间信息 + if (stateData.TryGetValue("start_time", out var startTimeStr) && + DateTime.TryParse(startTimeStr, out var startTime)) + { + gameStateInfo.StartTime = startTime; + gameStateInfo.ElapsedTime = DateTime.UtcNow - startTime; + + // 计算剩余时间 + if (stateData.TryGetValue("duration", out var durationStr) && + int.TryParse(durationStr, out var duration)) + { + var remaining = duration - gameStateInfo.ElapsedTime.TotalSeconds; + gameStateInfo.RemainingTime = remaining > 0 ? TimeSpan.FromSeconds(remaining) : TimeSpan.Zero; + } + } + + // 解析状态数据 + if (stateData.TryGetValue("state_data", out var stateDataStr) && !string.IsNullOrEmpty(stateDataStr)) + { + try + { + gameStateInfo.StateData = JsonSerializer.Deserialize>(stateDataStr) + ?? new Dictionary(); + } + catch (JsonException) + { + gameStateInfo.StateData = new Dictionary(); + } + } + + return gameStateInfo; + } + catch (Exception ex) + { + _logger.LogError(ex, "获取游戏状态失败 - GameId: {GameId}", gameId); + return null!; + } + } + + /// + /// 验证状态转换的合法性 + /// + public async Task ValidateStateTransitionAsync(Guid gameId, GameStatus targetState) + { + try + { + var currentState = await GetGameStateAsync(gameId); + if (currentState == null) + { + return false; + } + + // 定义合法的状态转换 + var validTransitions = new Dictionary + { + [GameStatus.Preparing] = new[] { GameStatus.Playing, GameStatus.Finished }, + [GameStatus.Playing] = new[] { GameStatus.Finished }, + [GameStatus.Finished] = new GameStatus[] { } // 结束状态不能转换到其他状态 + }; + + if (!validTransitions.TryGetValue(currentState.Status, out var allowedStates)) + { + return false; + } + + var isValid = allowedStates.Contains(targetState); + + if (!isValid) + { + _logger.LogWarning("非法的状态转换 - GameId: {GameId}, From: {From}, To: {To}", + gameId, currentState.Status, targetState); + } + + return isValid; + } + catch (Exception ex) + { + _logger.LogError(ex, "验证状态转换失败 - GameId: {GameId}", gameId); + return false; + } + } + + /// + /// 更新游戏状态 + /// + public async Task UpdateGameStateAsync(Guid gameId, GameStatus newState, + Dictionary? metadata = null) + { + try + { + var stateKey = string.Format(RedisKeys.GameState, gameId); + var updateData = new Dictionary + { + ["status"] = newState.ToString(), + ["last_update"] = DateTime.UtcNow.ToString("O") + }; + + // 添加元数据 + if (metadata != null) + { + foreach (var kvp in metadata) + { + updateData[kvp.Key] = kvp.Value?.ToString() ?? ""; + } + } + + // 状态特殊处理 + if (newState == GameStatus.Playing && metadata?.ContainsKey("start_time") == true) + { + updateData["start_time"] = metadata["start_time"]?.ToString() ?? ""; + } + else if (newState == GameStatus.Finished && metadata?.ContainsKey("end_time") == true) + { + updateData["end_time"] = metadata["end_time"]?.ToString() ?? ""; + } + + // 批量更新状态数据 + await _redisService.SetHashMultipleAsync(stateKey, updateData); + + // 设置状态过期时间（游戏结束后1小时） + if (newState == GameStatus.Finished) + { + await _redisService.SetExpireAsync(stateKey, TimeSpan.FromHours(1)); + } + + _logger.LogDebug("游戏状态已更新 - GameId: {GameId}, NewState: {State}", gameId, newState); + return true; + } + catch (Exception ex) + { + _logger.LogError(ex, "更新游戏状态失败 - GameId: {GameId}", gameId); + return false; + } + } + + #region 私有辅助方法 + + /// + /// 验证初始化参数 + /// + private static void ValidateInitializationParameters(Guid gameId, Guid roomId, GameSettings gameSettings) + { + if (gameId == Guid.Empty) + throw new ArgumentException("游戏ID不能为空", nameof(gameId)); + if (roomId == Guid.Empty) + throw new ArgumentException("房间ID不能为空", nameof(roomId)); + if (gameSettings == null) + throw new ArgumentNullException(nameof(gameSettings)); + if (gameSettings.Duration.TotalSeconds < 30 || gameSettings.Duration.TotalSeconds > 3600) + throw new ArgumentException("游戏时长必须在30秒到1小时之间"); + if (gameSettings.MaxPlayers < 2 || gameSettings.MaxPlayers > 10) + throw new ArgumentException("最大玩家数必须在2-10之间"); + if (gameSettings.MapWidth <= 0 || gameSettings.MapHeight <= 0) + throw new ArgumentException("地图尺寸必须大于0"); + } + + /// + /// 保存游戏信息到Redis + /// + private async Task SaveGameToRedisAsync(Guid gameId, CollabApp.Domain.Entities.Game.Game game, GameSettings settings) + { + var gameKey = string.Format(RedisKeys.Game, gameId); + var gameData = new Dictionary + { + ["id"] = gameId.ToString(), + ["room_id"] = game.RoomId.ToString(), + ["game_mode"] = game.GameMode, + ["map_width"] = game.MapWidth.ToString(), + ["map_height"] = game.MapHeight.ToString(), + ["duration"] = game.Duration.ToString(), + ["map_shape"] = game.MapShape, + ["powerup_spawn_interval"] = game.PowerUpSpawnInterval.ToString(), + ["max_powerups"] = game.MaxPowerUps.ToString(), + ["special_event_chance"] = game.SpecialEventChance.ToString(), + ["enable_dynamic_balance"] = game.EnableDynamicBalance.ToString(), + ["max_players"] = settings.MaxPlayers.ToString(), + ["min_players"] = settings.MinPlayers.ToString(), + ["created_at"] = DateTime.UtcNow.ToString("O") + }; + + await _redisService.SetHashMultipleAsync(gameKey, gameData); + await _redisService.SetExpireAsync(gameKey, TimeSpan.FromHours(2)); // 2小时过期 + } + + /// + /// 初始化游戏状态 + /// + private async Task InitializeGameStateAsync(Guid gameId, GameSettings settings) + { + var stateKey = string.Format(RedisKeys.GameState, gameId); + var stateData = new Dictionary + { + ["status"] = GameStatus.Preparing.ToString(), + ["connected_players"] = "0", + ["duration"] = ((int)settings.Duration.TotalSeconds).ToString(), + ["max_players"] = settings.MaxPlayers.ToString(), + ["created_at"] = DateTime.UtcNow.ToString("O"), + ["last_update"] = DateTime.UtcNow.ToString("O") + }; + + await _redisService.SetHashMultipleAsync(stateKey, stateData); + } + + /// + /// 初始化游戏指标 + /// + private async Task InitializeGameMetricsAsync(Guid gameId) + { + var metricsKey = string.Format(RedisKeys.GameMetrics, gameId); + var metricsData = new Dictionary + { + ["total_actions"] = "0", + ["total_collisions"] = "0", + ["total_powerups_collected"] = "0", + ["total_territory_captured"] = "0", + ["peak_player_count"] = "0", + ["start_time"] = "", + ["end_time"] = "" + }; + + await _redisService.SetHashMultipleAsync(metricsKey, metricsData); + } + + /// + /// 设置游戏定时器 + /// + private async Task SetupGameTimersAsync(Guid gameId, GameSettings settings) + { + var timersKey = string.Format(RedisKeys.GameTimers, gameId); + var timersData = new Dictionary + { + ["duration"] = ((int)settings.Duration.TotalSeconds).ToString(), + ["powerup_spawn_interval"] = settings.PowerUpSpawnInterval.ToString(), + ["next_powerup_spawn"] = "0", + ["shrinking_phase_start"] = "30", // 最后30秒开始缩圈 + ["created_at"] = DateTime.UtcNow.ToString("O") + }; + + await _redisService.SetHashMultipleAsync(timersKey, timersData); + } + + /// + /// 获取已连接玩家数量 + /// + private async Task GetConnectedPlayerCountAsync(Guid gameId) + { + var playersKey = string.Format(RedisKeys.GamePlayers, gameId); + var playerCount = await _redisService.GetSetCardinalityAsync(playersKey); + return (int)playerCount; + } + + /// + /// 启动游戏计时器 + /// + private async Task StartGameTimerAsync(Guid gameId, DateTime startTime) + { + var timersKey = string.Format(RedisKeys.GameTimers, gameId); + var timerUpdates = new Dictionary + { + ["game_start_time"] = startTime.ToString("O"), + ["next_powerup_spawn"] = DateTime.UtcNow.AddSeconds(25).ToString("O") // 25秒后第一个道具 + }; + + await _redisService.SetHashMultipleAsync(timersKey, timerUpdates); + } + + /// + /// 停止游戏计时器 + /// + private async Task StopGameTimerAsync(Guid gameId) + { + var timersKey = string.Format(RedisKeys.GameTimers, gameId); + await _redisService.SetHashAsync(timersKey, "game_end_time", DateTime.UtcNow.ToString("O")); + } + + /// + /// 收集游戏结束数据 + /// + private async Task CollectGameEndDataAsync(Guid gameId, GameEndReason reason) + { + var endTime = DateTime.UtcNow; + var result = new GameEndResult + { + GameId = gameId, + Reason = reason, + EndTime = endTime + }; + + // 获取游戏统计信息 + var statistics = await CollectGameStatisticsAsync(gameId, endTime); + result.Statistics = statistics; + + // 获取玩家结果 + var playerResults = await CollectPlayerResultsAsync(gameId); + result.PlayerResults = playerResults; + + return result; + } + + /// + /// 收集游戏统计信息 + /// + private async Task CollectGameStatisticsAsync(Guid gameId, DateTime endTime) + { + var statistics = new GameStatistics(); + + try + { + // 从游戏指标中获取统计数据 + var metricsKey = string.Format(RedisKeys.GameMetrics, gameId); + var metricsData = await _redisService.GetHashAllAsync(metricsKey); + + if (metricsData.Any()) + { + statistics.TotalActions = int.Parse(metricsData.GetValueOrDefault("total_actions", "0")); + + // 计算游戏总时长 + if (metricsData.TryGetValue("start_time", out var startTimeStr) && + DateTime.TryParse(startTimeStr, out var startTime)) + { + statistics.TotalDuration = endTime - startTime; + } + + // 设置动作计数 + statistics.ActionCounts = new Dictionary + { + ["collisions"] = int.Parse(metricsData.GetValueOrDefault("total_collisions", "0")), + ["powerups_collected"] = int.Parse(metricsData.GetValueOrDefault("total_powerups_collected", "0")), + ["territory_captured"] = int.Parse(metricsData.GetValueOrDefault("total_territory_captured", "0")) + }; + } + + // 获取玩家总数 + var playersKey = string.Format(RedisKeys.GamePlayers, gameId); + statistics.TotalPlayers = (int)await _redisService.GetSetCardinalityAsync(playersKey); + } + catch (Exception ex) + { + _logger.LogError(ex, "收集游戏统计信息失败 - GameId: {GameId}", gameId); + } + + return statistics; + } + + /// + /// 收集玩家结果 + /// + private async Task> CollectPlayerResultsAsync(Guid gameId) + { + var results = new List(); + + try + { + var playersKey = string.Format(RedisKeys.GamePlayers, gameId); + var playerIds = await _redisService.GetSetMembersAsync(playersKey); + + foreach (var playerIdStr in playerIds) + { + if (Guid.TryParse(playerIdStr, out var playerId)) + { + // 这里需要从其他服务获取玩家详细结果 + // 目前创建基础结果 + var result = new PlayerGameResult + { + PlayerId = playerId, + PlayerName = $"Player_{playerId.ToString()[..8]}", // 临时名称 + Score = 0, + Rank = 0, + PlayTime = TimeSpan.Zero, + Statistics = new Dictionary() + }; + + results.Add(result); + } + } + + // 简单排序（需要根据实际评分逻辑调整） + for (int i = 0; i < results.Count; i++) + { + results[i].Rank = i + 1; + } + } + catch (Exception ex) + { + _logger.LogError(ex, "收集玩家结果失败 - GameId: {GameId}", gameId); + } + + return results; + } + + /// + /// 清理游戏资源 + /// + private async Task CleanupGameResourcesAsync(Guid gameId) + { + try + { + // 设置所有游戏相关键的过期时间 + var keys = new[] + { + string.Format(RedisKeys.GamePlayers, gameId), + string.Format(RedisKeys.GameTimers, gameId), + string.Format(RedisKeys.GameMetrics, gameId) + }; + + var tasks = keys.Select(key => _redisService.SetExpireAsync(key, TimeSpan.FromHours(1))); + await Task.WhenAll(tasks); + + _logger.LogDebug("游戏资源清理完成 - GameId: {GameId}", gameId); + } + catch (Exception ex) + { + _logger.LogError(ex, "清理游戏资源失败 - GameId: {GameId}", gameId); + } + } + + /// + /// 记录状态转换日志 + /// + private async Task LogStateTransitionAsync(Guid gameId, GameStatus fromState, GameStatus toState, string reason) + { + try + { + var logKey = string.Format(RedisKeys.StateTransitionLog, gameId); + var logEntry = JsonSerializer.Serialize(new + { + from_state = fromState.ToString(), + to_state = toState.ToString(), + reason = reason, + timestamp = DateTime.UtcNow.ToString("O"), + game_id = gameId.ToString() + }); + + await _redisService.ListPushAsync(logKey, logEntry); + await _redisService.SetExpireAsync(logKey, TimeSpan.FromHours(2)); + } + catch (Exception ex) + { + _logger.LogError(ex, "记录状态转换日志失败 - GameId: {GameId}", gameId); + } + } + + /// + /// 解析游戏状态 + /// + private static GameStatus ParseGameStatus(string statusStr) + { + return Enum.TryParse(statusStr, true, out var status) ? status : GameStatus.Preparing; + } + + #endregion +} diff --git a/backend/src/CollabApp.Application/Services/Game/PlayerStateService.cs b/backend/src/CollabApp.Application/Services/Game/PlayerStateService.cs new file mode 100644 index 0000000000000000000000000000000000000000..1888e65db47c8995e9e0756f8e41e3922d3cdc53 --- /dev/null +++ b/backend/src/CollabApp.Application/Services/Game/PlayerStateService.cs @@ -0,0 +1,2035 @@ +using CollabApp.Application.Interfaces; +using CollabApp.Domain.Entities.Game; +using CollabApp.Domain.Services.Game; +using Microsoft.Extensions.Logging; +using System.Text.Json; + +namespace CollabApp.Application.Services.Game; + +/// +/// 画线圈地游戏 - 玩家状态管理服务实现 +/// 负责管理游戏中玩家的完整状态，包括位置、画线、领地、道具等 +/// +public class PlayerStateService : IPlayerStateService +{ + private readonly IRedisService _redisService; + private readonly ILogger _logger; + + /// + /// Redis键格式 + /// + private static class RedisKeys + { + public const string PlayerState = "player_state:{0}:{1}"; // gameId:playerId + public const string GamePlayers = "game_players:{0}"; // gameId + public const string PlayerTrail = "player_trail:{0}:{1}"; // gameId:playerId + public const string PlayerTerritories = "player_territories:{0}:{1}"; // gameId:playerId + public const string PlayerInventory = "player_inventory:{0}:{1}"; // gameId:playerId + public const string PlayerEffects = "player_effects:{0}:{1}"; // gameId:playerId + public const string GameRanking = "game_ranking:{0}"; // gameId + public const string PlayerStats = "player_stats:{0}:{1}"; // gameId:playerId + } + + /// + /// 游戏常量配置 + /// + private static class GameConstants + { + public const float BaseSpeed = 100f; // 基础速度：像素/秒 + public const float MaxSpeed = 200f; // 最大速度限制 + public const int InvulnerabilityDuration = 5; // 无敌时间：秒 + public const int RespawnDelay = 5; // 复活延迟：秒 + public const float PickupRange = 20f; // 道具拾取范围：像素 + public const int MaxInventorySize = 3; // 最大背包容量 + public const float InitialTerritorySize = 50f; // 初始领地大小 + public const float MinTerritoryArea = 100f; // 最小有效领地面积 + public static readonly string[] PlayerColors = { "red", "blue", "green", "yellow", "purple", "orange", "pink", "cyan" }; + } + + /// + /// 构造函数 + /// + public PlayerStateService(IRedisService redisService, ILogger logger) + { + _redisService = redisService ?? throw new ArgumentNullException(nameof(redisService)); + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + #region 玩家基础状态管理 + + /// + /// 获取玩家完整游戏状态 + /// + public async Task GetPlayerStateAsync(Guid gameId, Guid playerId) + { + try + { + _logger.LogDebug("获取玩家状态 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + var stateData = await _redisService.GetHashAllAsync(stateKey); + + if (!stateData.Any()) + { + _logger.LogWarning("玩家状态不存在 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return null; + } + + var playerState = new PlayerGameState + { + PlayerId = playerId, + PlayerName = stateData.GetValueOrDefault("player_name", "Unknown"), + PlayerColor = stateData.GetValueOrDefault("player_color", "red"), + State = ParsePlayerState(stateData.GetValueOrDefault("state", "Idle")), + TotalTerritoryArea = float.Parse(stateData.GetValueOrDefault("territory_area", "0")), + CurrentRank = int.Parse(stateData.GetValueOrDefault("current_rank", "0")), + IsInvulnerable = bool.Parse(stateData.GetValueOrDefault("is_invulnerable", "false")), + LastActivity = DateTime.Parse(stateData.GetValueOrDefault("last_activity", DateTime.UtcNow.ToString("O"))) + }; + + // 解析当前位置 + if (stateData.TryGetValue("current_position", out var positionStr)) + { + playerState.CurrentPosition = ParsePosition(positionStr); + } + + // 解析出生点 + if (stateData.TryGetValue("spawn_point", out var spawnStr)) + { + playerState.SpawnPoint = ParsePosition(spawnStr); + } + + // 解析无敌结束时间 + if (stateData.TryGetValue("invulnerability_end", out var invulEndStr) && + DateTime.TryParse(invulEndStr, out var invulEndTime)) + { + playerState.InvulnerabilityEndTime = invulEndTime; + } + + // 获取当前轨迹 + playerState.CurrentTrail = await GetPlayerTrailAsync(gameId, playerId); + + // 获取拥有的领地 + playerState.OwnedTerritories = await GetPlayerTerritoriesAsync(gameId, playerId); + + // 获取背包物品 + playerState.Inventory = await GetPlayerInventoryAsync(gameId, playerId); + + // 获取活跃效果 + playerState.ActiveEffects = await GetPlayerActiveEffectsAsync(gameId, playerId); + + // 获取统计信息 + playerState.Statistics = await GetPlayerStatisticsAsync(gameId, playerId); + + return playerState; + } + catch (Exception ex) + { + _logger.LogError(ex, "获取玩家状态失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return null; + } + } + + /// + /// 获取游戏中所有玩家状态 + /// + public async Task> GetAllPlayerStatesAsync(Guid gameId) + { + try + { + _logger.LogDebug("获取所有玩家状态 - GameId: {GameId}", gameId); + + var playersKey = string.Format(RedisKeys.GamePlayers, gameId); + var playerIds = await _redisService.GetSetMembersAsync(playersKey); + + var playerStates = new List(); + + // 并发获取所有玩家状态 + var tasks = playerIds.Select(async playerIdStr => + { + if (Guid.TryParse(playerIdStr, out var playerId)) + { + var state = await GetPlayerStateAsync(gameId, playerId); + return state; + } + return null; + }); + + var results = await Task.WhenAll(tasks); + playerStates.AddRange(results.Where(state => state != null)!); + + // 按排名排序 + playerStates.Sort((a, b) => a.CurrentRank.CompareTo(b.CurrentRank)); + + _logger.LogDebug("获取到 {Count} 个玩家状态 - GameId: {GameId}", playerStates.Count, gameId); + return playerStates; + } + catch (Exception ex) + { + _logger.LogError(ex, "获取所有玩家状态失败 - GameId: {GameId}", gameId); + return new List(); + } + } + + /// + /// 初始化玩家游戏状态 + /// + public async Task InitializePlayerStateAsync(Guid gameId, Guid playerId, string playerName) + { + try + { + _logger.LogInformation("初始化玩家状态 - GameId: {GameId}, PlayerId: {PlayerId}, Name: {Name}", + gameId, playerId, playerName); + + // 验证参数 + if (string.IsNullOrWhiteSpace(playerName)) + { + return new PlayerInitResult + { + Success = false, + Errors = { "玩家名称不能为空" } + }; + } + + // 检查玩家是否已存在 + var existingState = await GetPlayerStateAsync(gameId, playerId); + if (existingState != null) + { + return new PlayerInitResult + { + Success = false, + Errors = { "玩家已经存在于游戏中" } + }; + } + + // 分配玩家颜色和编号 + var playerNumber = await GetNextPlayerNumberAsync(gameId); + if (playerNumber > GameConstants.PlayerColors.Length) + { + return new PlayerInitResult + { + Success = false, + Errors = { "游戏人数已满" } + }; + } + + var assignedColor = GameConstants.PlayerColors[playerNumber - 1]; + + // 计算出生点 + var spawnPoint = CalculateSpawnPoint(gameId, playerNumber); + + // 创建初始领地 + var initialTerritory = CreateInitialTerritory(playerId, spawnPoint, assignedColor); + + // 保存玩家状态 + await SavePlayerStateAsync(gameId, playerId, new PlayerGameState + { + PlayerId = playerId, + PlayerName = playerName, + PlayerColor = assignedColor, + CurrentPosition = spawnPoint, + SpawnPoint = spawnPoint, + State = PlayerDrawingState.Idle, + TotalTerritoryArea = initialTerritory.Area, + CurrentRank = playerNumber, + OwnedTerritories = { initialTerritory }, + LastActivity = DateTime.UtcNow, + Statistics = new PlayerGameStatistics + { + GameStartTime = DateTime.UtcNow, + LastActivity = DateTime.UtcNow + } + }); + + // 将玩家添加到游戏玩家集合 + var playersKey = string.Format(RedisKeys.GamePlayers, gameId); + await _redisService.SetAddAsync(playersKey, playerId.ToString()); + + // 更新游戏排名 + await UpdateGameRankingAsync(gameId); + + _logger.LogInformation("玩家初始化成功 - GameId: {GameId}, PlayerId: {PlayerId}, Color: {Color}, Number: {Number}", + gameId, playerId, assignedColor, playerNumber); + + return new PlayerInitResult + { + Success = true, + AssignedColor = assignedColor, + SpawnPoint = spawnPoint, + InitialTerritory = initialTerritory, + PlayerNumber = playerNumber, + Messages = { $"玩家 {playerName} 成功加入游戏，分配颜色：{assignedColor}" } + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "初始化玩家状态失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new PlayerInitResult + { + Success = false, + Errors = { "初始化玩家状态时发生内部错误" } + }; + } + } + + #endregion + + #region 移动和画线系统 + + /// + /// 更新玩家位置并处理移动逻辑 + /// + public async Task UpdatePlayerPositionAsync( + Guid gameId, + Guid playerId, + Position newPosition, + DateTime timestamp, + bool isDrawing = false) + { + try + { + _logger.LogDebug("更新玩家位置 - GameId: {GameId}, PlayerId: {PlayerId}, Position: ({X},{Y}), Drawing: {Drawing}", + gameId, playerId, newPosition.X, newPosition.Y, isDrawing); + + // 获取玩家当前状态 + var playerState = await GetPlayerStateAsync(gameId, playerId); + if (playerState == null) + { + return new PositionUpdateResult + { + Success = false, + Errors = { "玩家不存在" } + }; + } + + // 检查玩家是否可以移动 + if (!CanPlayerMove(playerState)) + { + return new PositionUpdateResult + { + Success = false, + OldPosition = playerState.CurrentPosition, + NewPosition = playerState.CurrentPosition, + Errors = { $"玩家当前状态 {playerState.State} 不允许移动" } + }; + } + + var oldPosition = playerState.CurrentPosition; + var distanceMoved = CalculateDistance(oldPosition, newPosition); + var timeDelta = (timestamp - playerState.LastActivity).TotalSeconds; + var currentSpeed = timeDelta > 0 ? (float)(distanceMoved / timeDelta) : 0f; + + // 速度检查（防作弊） + var maxAllowedSpeed = CalculateMaxSpeed(playerState); + if (currentSpeed > maxAllowedSpeed * 1.2f) // 允许20%的网络延迟误差 + { + return new PositionUpdateResult + { + Success = false, + OldPosition = oldPosition, + NewPosition = oldPosition, + CurrentSpeed = currentSpeed, + Errors = { $"移动速度过快：{currentSpeed:F1} > {maxAllowedSpeed:F1}" } + }; + } + + // 边界检查 + if (!IsPositionInBounds(newPosition)) + { + return new PositionUpdateResult + { + Success = false, + OldPosition = oldPosition, + NewPosition = oldPosition, + CollisionDetected = true, + CollisionInfo = new PlayerCollisionInfo + { + Type = DrawingGameCollisionType.BoundaryHit, + CollisionPoint = newPosition, + Description = "撞到地图边界" + }, + Errors = { "移动超出地图边界" } + }; + } + + var result = new PositionUpdateResult + { + Success = true, + OldPosition = oldPosition, + NewPosition = newPosition, + DistanceMoved = distanceMoved, + CurrentSpeed = currentSpeed + }; + + // 如果正在画线，添加轨迹点 + if (isDrawing && playerState.State == PlayerDrawingState.Drawing) + { + await AddTrailPointAsync(gameId, playerId, newPosition, timestamp); + result.Events.Add("轨迹点已添加"); + } + + // 更新玩家位置和活动时间 + await UpdatePlayerPositionInRedisAsync(gameId, playerId, newPosition, timestamp, distanceMoved); + + // 更新统计信息 + await UpdatePlayerStatisticsAsync(gameId, playerId, stats => + { + stats.TotalDistanceMoved += distanceMoved; + stats.LastActivity = timestamp; + }); + + _logger.LogDebug("玩家位置更新成功 - GameId: {GameId}, PlayerId: {PlayerId}, Distance: {Distance:F2}", + gameId, playerId, distanceMoved); + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "更新玩家位置失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new PositionUpdateResult + { + Success = false, + Errors = { "更新位置时发生内部错误" } + }; + } + } + + /// + /// 玩家开始画线 + /// + public async Task StartDrawingAsync(Guid gameId, Guid playerId, Position startPosition) + { + try + { + _logger.LogInformation("玩家开始画线 - GameId: {GameId}, PlayerId: {PlayerId}, Position: ({X},{Y})", + gameId, playerId, startPosition.X, startPosition.Y); + + // 获取玩家状态 + var playerState = await GetPlayerStateAsync(gameId, playerId); + if (playerState == null) + { + return new DrawingStartResult + { + Success = false, + Errors = { "玩家不存在" } + }; + } + + // 检查玩家是否可以开始画线 + if (!CanPlayerStartDrawing(playerState)) + { + return new DrawingStartResult + { + Success = false, + Errors = { $"玩家当前状态 {playerState.State} 不允许开始画线" } + }; + } + + // 验证开始位置是否在玩家领地内 + if (!IsPositionInPlayerTerritory(startPosition, playerState.OwnedTerritories)) + { + return new DrawingStartResult + { + Success = false, + Errors = { "只能从自己的领地内开始画线" } + }; + } + + // 清空之前的轨迹 + await ClearPlayerTrailAsync(gameId, playerId); + + // 更新玩家状态为画线中 + await UpdatePlayerStateInRedisAsync(gameId, playerId, PlayerDrawingState.Drawing); + + // 添加起始点到轨迹 + var startTime = DateTime.UtcNow; + await AddTrailPointAsync(gameId, playerId, startPosition, startTime); + + // 更新统计信息 + await UpdatePlayerStatisticsAsync(gameId, playerId, stats => + { + stats.LastActivity = startTime; + }); + + _logger.LogInformation("玩家开始画线成功 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + + return new DrawingStartResult + { + Success = true, + StartPosition = startPosition, + StartTime = startTime, + Messages = { "开始画线" } + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "玩家开始画线失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new DrawingStartResult + { + Success = false, + Errors = { "开始画线时发生内部错误" } + }; + } + } + + /// + /// 玩家停止画线并尝试圈地 + /// + public async Task StopDrawingAsync(Guid gameId, Guid playerId, Position endPosition) + { + try + { + _logger.LogInformation("玩家停止画线 - GameId: {GameId}, PlayerId: {PlayerId}, Position: ({X},{Y})", + gameId, playerId, endPosition.X, endPosition.Y); + + // 获取玩家状态 + var playerState = await GetPlayerStateAsync(gameId, playerId); + if (playerState == null) + { + return new DrawingEndResult + { + Success = false, + Errors = { "玩家不存在" } + }; + } + + // 验证玩家确实在画线状态 + if (playerState.State != PlayerDrawingState.Drawing) + { + return new DrawingEndResult + { + Success = false, + Errors = { "玩家不在画线状态" } + }; + } + + // 获取当前轨迹 + var currentTrail = await GetPlayerTrailAsync(gameId, playerId); + if (currentTrail.Count < 3) // 至少需要3个点才能形成有效轨迹 + { + await StopDrawingWithoutCapture(gameId, playerId); + return new DrawingEndResult + { + Success = false, + CompletedTrail = currentTrail, + Errors = { "轨迹点数不足，无法圈地" } + }; + } + + // 添加结束点 + currentTrail.Add(endPosition); + + // 检查是否形成闭合回路 + var isClosedLoop = IsTrailClosedLoop(currentTrail, playerState.OwnedTerritories); + if (!isClosedLoop) + { + await StopDrawingWithoutCapture(gameId, playerId); + return new DrawingEndResult + { + Success = false, + CompletedTrail = currentTrail, + IsClosedLoop = false, + Errors = { "轨迹未形成闭合回路" } + }; + } + + // 计算新领地面积 + var newTerritory = CalculateNewTerritory(playerId, currentTrail, playerState.PlayerColor); + if (newTerritory.Area < GameConstants.MinTerritoryArea) + { + await StopDrawingWithoutCapture(gameId, playerId); + return new DrawingEndResult + { + Success = false, + CompletedTrail = currentTrail, + IsClosedLoop = true, + AreaGained = newTerritory.Area, + Errors = { $"圈地面积过小：{newTerritory.Area:F1} < {GameConstants.MinTerritoryArea}" } + }; + } + + // 保存新领地 + await AddPlayerTerritoryAsync(gameId, playerId, newTerritory); + + // 更新玩家总领地面积 + var newTotalArea = playerState.TotalTerritoryArea + newTerritory.Area; + await UpdatePlayerTerritoryAreaAsync(gameId, playerId, newTotalArea); + + // 清除轨迹并回到Idle状态 + await StopDrawingWithoutCapture(gameId, playerId); + + // 更新游戏排名 + await UpdateGameRankingAsync(gameId); + + // 更新统计信息 + await UpdatePlayerStatisticsAsync(gameId, playerId, stats => + { + stats.TerritoryCaptures++; + stats.MaxTerritoryArea = Math.Max(stats.MaxTerritoryArea, newTotalArea); + stats.LastActivity = DateTime.UtcNow; + }); + + _logger.LogInformation("玩家圈地成功 - GameId: {GameId}, PlayerId: {PlayerId}, Area: {Area:F1}", + gameId, playerId, newTerritory.Area); + + return new DrawingEndResult + { + Success = true, + EndPosition = endPosition, + CompletedTrail = currentTrail, + NewTerritory = newTerritory, + AreaGained = newTerritory.Area, + IsClosedLoop = true, + Messages = { $"圈地成功，获得面积：{newTerritory.Area:F1}" } + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "玩家停止画线失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new DrawingEndResult + { + Success = false, + Errors = { "停止画线时发生内部错误" } + }; + } + } + + #endregion + + #region 私有辅助方法 + + /// + /// 解析玩家状态枚举 + /// + private static PlayerDrawingState ParsePlayerState(string stateStr) + { + return Enum.TryParse(stateStr, true, out var state) ? state : PlayerDrawingState.Idle; + } + + /// + /// 解析位置信息 + /// + private static Position ParsePosition(string positionStr) + { + try + { + return JsonSerializer.Deserialize(positionStr) ?? new Position(); + } + catch + { + return new Position(); + } + } + + /// + /// 获取玩家轨迹 + /// + private async Task> GetPlayerTrailAsync(Guid gameId, Guid playerId) + { + try + { + var trailKey = string.Format(RedisKeys.PlayerTrail, gameId, playerId); + var trailData = await _redisService.ListRangeAsync(trailKey); + return trailData.Select(ParsePosition).ToList(); + } + catch + { + return new List(); + } + } + + /// + /// 获取玩家领地列表 + /// + private async Task> GetPlayerTerritoriesAsync(Guid gameId, Guid playerId) + { + try + { + var territoriesKey = string.Format(RedisKeys.PlayerTerritories, gameId, playerId); + var territoriesData = await _redisService.ListRangeAsync(territoriesKey); + return territoriesData.Select(data => + { + try + { + return JsonSerializer.Deserialize(data) ?? new Territory(); + } + catch + { + return new Territory(); + } + }).ToList(); + } + catch + { + return new List(); + } + } + + /// + /// 获取玩家背包 + /// + private async Task> GetPlayerInventoryAsync(Guid gameId, Guid playerId) + { + try + { + var inventoryKey = string.Format(RedisKeys.PlayerInventory, gameId, playerId); + var inventoryData = await _redisService.ListRangeAsync(inventoryKey); + return inventoryData.Select(itemStr => + { + return Enum.TryParse(itemStr, true, out var itemType) ? itemType : DrawingGameItemType.Lightning; + }).ToList(); + } + catch + { + return new List(); + } + } + + /// + /// 获取玩家活跃效果 + /// + private async Task> GetPlayerActiveEffectsAsync(Guid gameId, Guid playerId) + { + try + { + var effectsKey = string.Format(RedisKeys.PlayerEffects, gameId, playerId); + var effectsData = await _redisService.ListRangeAsync(effectsKey); + return effectsData.Select(data => + { + try + { + return JsonSerializer.Deserialize(data) ?? new ActiveEffect(); + } + catch + { + return new ActiveEffect(); + } + }).Where(effect => !effect.IsExpired).ToList(); + } + catch + { + return new List(); + } + } + + /// + /// 获取玩家统计信息 + /// + private async Task GetPlayerStatisticsAsync(Guid gameId, Guid playerId) + { + try + { + var statsKey = string.Format(RedisKeys.PlayerStats, gameId, playerId); + var statsData = await _redisService.GetHashAllAsync(statsKey); + + if (!statsData.Any()) + { + return new PlayerGameStatistics + { + GameStartTime = DateTime.UtcNow, + LastActivity = DateTime.UtcNow + }; + } + + return new PlayerGameStatistics + { + Deaths = int.Parse(statsData.GetValueOrDefault("deaths", "0")), + Kills = int.Parse(statsData.GetValueOrDefault("kills", "0")), + MaxTerritoryArea = float.Parse(statsData.GetValueOrDefault("max_territory_area", "0")), + TotalDistanceMoved = float.Parse(statsData.GetValueOrDefault("total_distance_moved", "0")), + ItemsUsed = int.Parse(statsData.GetValueOrDefault("items_used", "0")), + ItemsPickedUp = int.Parse(statsData.GetValueOrDefault("items_picked_up", "0")), + TerritoryCaptures = int.Parse(statsData.GetValueOrDefault("territory_captures", "0")), + GameStartTime = DateTime.Parse(statsData.GetValueOrDefault("game_start_time", DateTime.UtcNow.ToString("O"))), + LastActivity = DateTime.Parse(statsData.GetValueOrDefault("last_activity", DateTime.UtcNow.ToString("O"))) + }; + } + catch + { + return new PlayerGameStatistics + { + GameStartTime = DateTime.UtcNow, + LastActivity = DateTime.UtcNow + }; + } + } + + /// + /// 获取下一个玩家编号 + /// + private async Task GetNextPlayerNumberAsync(Guid gameId) + { + var playersKey = string.Format(RedisKeys.GamePlayers, gameId); + var playerCount = await _redisService.GetSetCardinalityAsync(playersKey); + return (int)playerCount + 1; + } + + /// + /// 计算出生点位置 + /// + private static Position CalculateSpawnPoint(Guid gameId, int playerNumber) + { + // 简化的出生点计算：围绕地图边缘均匀分布 + var angle = (playerNumber - 1) * (2 * Math.PI / 8); // 最多8个玩家，均匀分布 + var radius = 450f; // 距离中心450像素 + var centerX = 500f; // 地图中心X + var centerY = 500f; // 地图中心Y + + return new Position + { + X = centerX + (float)(Math.Cos(angle) * radius), + Y = centerY + (float)(Math.Sin(angle) * radius) + }; + } + + /// + /// 创建初始领地 + /// + private static Territory CreateInitialTerritory(Guid playerId, Position center, string color) + { + var size = GameConstants.InitialTerritorySize; + var halfSize = size / 2; + + return new Territory + { + Id = Guid.NewGuid(), + PlayerId = playerId, + Color = color, + Area = size * size, + CapturedTime = DateTime.UtcNow, + Boundary = new List + { + new() { X = center.X - halfSize, Y = center.Y - halfSize }, + new() { X = center.X + halfSize, Y = center.Y - halfSize }, + new() { X = center.X + halfSize, Y = center.Y + halfSize }, + new() { X = center.X - halfSize, Y = center.Y + halfSize } + } + }; + } + + /// + /// 保存玩家状态到Redis + /// + private async Task SavePlayerStateAsync(Guid gameId, Guid playerId, PlayerGameState state) + { + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + var stateData = new Dictionary + { + ["player_name"] = state.PlayerName, + ["player_color"] = state.PlayerColor, + ["current_position"] = JsonSerializer.Serialize(state.CurrentPosition), + ["spawn_point"] = JsonSerializer.Serialize(state.SpawnPoint), + ["state"] = state.State.ToString(), + ["territory_area"] = state.TotalTerritoryArea.ToString("F2"), + ["current_rank"] = state.CurrentRank.ToString(), + ["is_invulnerable"] = state.IsInvulnerable.ToString(), + ["last_activity"] = state.LastActivity.ToString("O") + }; + + if (state.InvulnerabilityEndTime.HasValue) + { + stateData["invulnerability_end"] = state.InvulnerabilityEndTime.Value.ToString("O"); + } + + await _redisService.SetHashMultipleAsync(stateKey, stateData); + + // 保存领地信息 + if (state.OwnedTerritories.Any()) + { + var territoriesKey = string.Format(RedisKeys.PlayerTerritories, gameId, playerId); + await _redisService.KeyDeleteAsync(territoriesKey); // 清空旧数据 + foreach (var territory in state.OwnedTerritories) + { + await _redisService.ListRightPushAsync(territoriesKey, JsonSerializer.Serialize(territory)); + } + } + + // 保存统计信息 + await SavePlayerStatisticsAsync(gameId, playerId, state.Statistics); + } + + /// + /// 保存玩家统计信息 + /// + private async Task SavePlayerStatisticsAsync(Guid gameId, Guid playerId, PlayerGameStatistics stats) + { + var statsKey = string.Format(RedisKeys.PlayerStats, gameId, playerId); + var statsData = new Dictionary + { + ["deaths"] = stats.Deaths.ToString(), + ["kills"] = stats.Kills.ToString(), + ["max_territory_area"] = stats.MaxTerritoryArea.ToString("F2"), + ["total_distance_moved"] = stats.TotalDistanceMoved.ToString("F2"), + ["items_used"] = stats.ItemsUsed.ToString(), + ["items_picked_up"] = stats.ItemsPickedUp.ToString(), + ["territory_captures"] = stats.TerritoryCaptures.ToString(), + ["game_start_time"] = stats.GameStartTime.ToString("O"), + ["last_activity"] = stats.LastActivity.ToString("O") + }; + + await _redisService.SetHashMultipleAsync(statsKey, statsData); + } + + /// + /// 检查玩家是否可以移动 + /// + private static bool CanPlayerMove(PlayerGameState playerState) + { + return playerState.State != PlayerDrawingState.Dead && + playerState.State != PlayerDrawingState.Respawning; + } + + /// + /// 计算两点间距离 + /// + private static float CalculateDistance(Position pos1, Position pos2) + { + var dx = pos2.X - pos1.X; + var dy = pos2.Y - pos1.Y; + return (float)Math.Sqrt(dx * dx + dy * dy); + } + + /// + /// 计算玩家最大允许速度 + /// + private static float CalculateMaxSpeed(PlayerGameState playerState) + { + var baseSpeed = GameConstants.BaseSpeed; + + // 检查闪电道具效果 + var lightningEffect = playerState.ActiveEffects.FirstOrDefault(e => + e.EffectType == DrawingGameItemType.Lightning && !e.IsExpired); + + if (lightningEffect != null) + { + baseSpeed *= 1.5f; // 速度提升50% + } + + return Math.Min(baseSpeed, GameConstants.MaxSpeed); + } + + /// + /// 检查位置是否在地图边界内 + /// + private static bool IsPositionInBounds(Position position) + { + // 假设地图大小为1000x1000 + return position.X >= 0 && position.X <= 1000 && position.Y >= 0 && position.Y <= 1000; + } + + /// + /// 更新玩家在Redis中的位置 + /// + private async Task UpdatePlayerPositionInRedisAsync(Guid gameId, Guid playerId, Position newPosition, DateTime timestamp, float distanceMoved) + { + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + var updates = new Dictionary + { + ["current_position"] = JsonSerializer.Serialize(newPosition), + ["last_activity"] = timestamp.ToString("O") + }; + + await _redisService.SetHashMultipleAsync(stateKey, updates); + } + + /// + /// 添加轨迹点 + /// + private async Task AddTrailPointAsync(Guid gameId, Guid playerId, Position position, DateTime timestamp) + { + var trailKey = string.Format(RedisKeys.PlayerTrail, gameId, playerId); + await _redisService.ListRightPushAsync(trailKey, JsonSerializer.Serialize(position)); + } + + /// + /// 更新玩家统计信息 + /// + private async Task UpdatePlayerStatisticsAsync(Guid gameId, Guid playerId, Action updateAction) + { + var stats = await GetPlayerStatisticsAsync(gameId, playerId); + updateAction(stats); + await SavePlayerStatisticsAsync(gameId, playerId, stats); + } + + /// + /// 检查玩家是否可以开始画线 + /// + private static bool CanPlayerStartDrawing(PlayerGameState playerState) + { + return playerState.State == PlayerDrawingState.Idle && !playerState.IsInvulnerable; + } + + /// + /// 检查位置是否在玩家领地内 + /// + private static bool IsPositionInPlayerTerritory(Position position, List territories) + { + return territories.Any(territory => IsPointInPolygon(position, territory.Boundary)); + } + + /// + /// 点在多边形内判断（射线法） + /// + private static bool IsPointInPolygon(Position point, List polygon) + { + if (polygon.Count < 3) return false; + + bool inside = false; + int j = polygon.Count - 1; + + for (int i = 0; i < polygon.Count; i++) + { + var pi = polygon[i]; + var pj = polygon[j]; + + if (((pi.Y > point.Y) != (pj.Y > point.Y)) && + (point.X < (pj.X - pi.X) * (point.Y - pi.Y) / (pj.Y - pi.Y) + pi.X)) + { + inside = !inside; + } + j = i; + } + + return inside; + } + + /// + /// 清除玩家轨迹 + /// + private async Task ClearPlayerTrailAsync(Guid gameId, Guid playerId) + { + var trailKey = string.Format(RedisKeys.PlayerTrail, gameId, playerId); + await _redisService.KeyDeleteAsync(trailKey); + } + + /// + /// 更新玩家状态 + /// + private async Task UpdatePlayerStateInRedisAsync(Guid gameId, Guid playerId, PlayerDrawingState newState) + { + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + await _redisService.SetHashAsync(stateKey, "state", newState.ToString()); + await _redisService.SetHashAsync(stateKey, "last_activity", DateTime.UtcNow.ToString("O")); + } + + /// + /// 检查轨迹是否形成闭合回路 + /// + private static bool IsTrailClosedLoop(List trail, List playerTerritories) + { + if (trail.Count < 3) return false; + + var startPoint = trail.First(); + var endPoint = trail.Last(); + + // 简化判断：终点是否靠近起点或者在玩家领地内 + var distanceToStart = CalculateDistance(startPoint, endPoint); + if (distanceToStart < 30f) return true; // 距离起点30像素内认为闭合 + + // 或者终点在玩家的任一领地内 + return playerTerritories.Any(territory => IsPointInPolygon(endPoint, territory.Boundary)); + } + + /// + /// 计算新领地 + /// + private static Territory CalculateNewTerritory(Guid playerId, List trail, string color) + { + // 使用多边形面积计算（Shoelace公式） + var area = CalculatePolygonArea(trail); + + return new Territory + { + Id = Guid.NewGuid(), + PlayerId = playerId, + Color = color, + Area = area, + CapturedTime = DateTime.UtcNow, + Boundary = new List(trail) + }; + } + + /// + /// 计算多边形面积（Shoelace公式） + /// + private static float CalculatePolygonArea(List polygon) + { + if (polygon.Count < 3) return 0f; + + float area = 0f; + int j = polygon.Count - 1; + + for (int i = 0; i < polygon.Count; i++) + { + area += (polygon[j].X + polygon[i].X) * (polygon[j].Y - polygon[i].Y); + j = i; + } + + return Math.Abs(area) / 2f; + } + + /// + /// 添加玩家领地 + /// + private async Task AddPlayerTerritoryAsync(Guid gameId, Guid playerId, Territory territory) + { + var territoriesKey = string.Format(RedisKeys.PlayerTerritories, gameId, playerId); + await _redisService.ListRightPushAsync(territoriesKey, JsonSerializer.Serialize(territory)); + } + + /// + /// 更新玩家总领地面积 + /// + private async Task UpdatePlayerTerritoryAreaAsync(Guid gameId, Guid playerId, float newTotalArea) + { + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + await _redisService.SetHashAsync(stateKey, "territory_area", newTotalArea.ToString("F2")); + } + + /// + /// 停止画线但不圈地 + /// + private async Task StopDrawingWithoutCapture(Guid gameId, Guid playerId) + { + await ClearPlayerTrailAsync(gameId, playerId); + await UpdatePlayerStateInRedisAsync(gameId, playerId, PlayerDrawingState.Idle); + } + + /// + /// 更新游戏排名 + /// + private async Task UpdateGameRankingAsync(Guid gameId) + { + try + { + var allPlayers = await GetAllPlayerStatesAsync(gameId); + + // 按领地面积排序 + allPlayers.Sort((a, b) => b.TotalTerritoryArea.CompareTo(a.TotalTerritoryArea)); + + // 更新排名 + for (int i = 0; i < allPlayers.Count; i++) + { + allPlayers[i].CurrentRank = i + 1; + var stateKey = string.Format(RedisKeys.PlayerState, gameId, allPlayers[i].PlayerId); + await _redisService.SetHashAsync(stateKey, "current_rank", (i + 1).ToString()); + } + + // 保存排名到Redis + var rankingKey = string.Format(RedisKeys.GameRanking, gameId); + await _redisService.KeyDeleteAsync(rankingKey); + + foreach (var player in allPlayers) + { + var ranking = new PlayerGameRanking + { + Rank = player.CurrentRank, + PlayerId = player.PlayerId, + PlayerName = player.PlayerName, + PlayerColor = player.PlayerColor, + TerritoryArea = player.TotalTerritoryArea, + TerritoryCount = player.OwnedTerritories.Count, + CurrentState = player.State, + LastUpdate = DateTime.UtcNow + }; + + await _redisService.ListRightPushAsync(rankingKey, JsonSerializer.Serialize(ranking)); + } + } + catch (Exception ex) + { + _logger.LogError(ex, "更新游戏排名失败 - GameId: {GameId}", gameId); + } + } + + #endregion + + #region 碰撞和战斗系统 + + /// + /// 处理玩家轨迹被其他玩家碰撞（截断死亡） + /// + public async Task HandleTrailCollisionAsync( + Guid gameId, + Guid victimPlayerId, + Position collisionPosition, + Guid? attackerPlayerId = null) + { + try + { + _logger.LogInformation("处理轨迹碰撞 - GameId: {GameId}, Victim: {VictimId}, Attacker: {AttackerId}, Position: ({X},{Y})", + gameId, victimPlayerId, attackerPlayerId, collisionPosition.X, collisionPosition.Y); + + // 获取被攻击者状态 + var victimState = await GetPlayerStateAsync(gameId, victimPlayerId); + if (victimState == null) + { + return new PlayerCollisionHandleResult + { + Success = false, + Messages = { "被攻击的玩家不存在" } + }; + } + + // 验证被攻击者正在画线 + if (victimState.State != PlayerDrawingState.Drawing) + { + return new PlayerCollisionHandleResult + { + Success = false, + Messages = { "被攻击的玩家不在画线状态" } + }; + } + + // 检查护盾效果 + var shieldEffect = victimState.ActiveEffects.FirstOrDefault(e => + e.EffectType == DrawingGameItemType.Shield && !e.IsExpired); + + if (shieldEffect != null) + { + // 护盾抵挡攻击 + await RemovePlayerEffectAsync(gameId, victimPlayerId, shieldEffect.Id); + + _logger.LogInformation("护盾抵挡攻击 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, victimPlayerId); + + return new PlayerCollisionHandleResult + { + Success = true, + PlayerDied = false, + ShieldBlocked = true, + Messages = { "护盾抵挡了攻击" } + }; + } + + // 获取攻击者信息（如果有） + string? killerName = null; + if (attackerPlayerId.HasValue) + { + var attackerState = await GetPlayerStateAsync(gameId, attackerPlayerId.Value); + killerName = attackerState?.PlayerName; + + // 更新攻击者击杀统计 + await UpdatePlayerStatisticsAsync(gameId, attackerPlayerId.Value, stats => + { + stats.Kills++; + stats.LastActivity = DateTime.UtcNow; + }); + } + + // 获取被攻击者当前轨迹 + var clearedTrail = await GetPlayerTrailAsync(gameId, victimPlayerId); + + // 处理死亡 + var deathReason = attackerPlayerId.HasValue + ? $"被玩家 {killerName} 截断" + : "撞到其他玩家轨迹"; + + await HandlePlayerDeathAsync(gameId, victimPlayerId, deathReason, attackerPlayerId, collisionPosition); + + _logger.LogInformation("轨迹碰撞处理完成 - 玩家死亡 - GameId: {GameId}, Victim: {VictimId}", gameId, victimPlayerId); + + return new PlayerCollisionHandleResult + { + Success = true, + PlayerDied = true, + KillerId = attackerPlayerId, + KillerName = killerName, + ClearedTrail = clearedTrail, + DeathReason = deathReason, + Messages = { deathReason } + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "处理轨迹碰撞失败 - GameId: {GameId}, VictimId: {VictimId}", gameId, victimPlayerId); + return new PlayerCollisionHandleResult + { + Success = false, + Messages = { "处理碰撞时发生内部错误" } + }; + } + } + + /// + /// 处理玩家死亡的完整流程 + /// + public async Task HandlePlayerDeathAsync( + Guid gameId, + Guid playerId, + string deathReason, + Guid? killerId = null, + Position? deathPosition = null) + { + try + { + _logger.LogInformation("处理玩家死亡 - GameId: {GameId}, PlayerId: {PlayerId}, Reason: {Reason}", + gameId, playerId, deathReason); + + // 获取玩家当前状态 + var playerState = await GetPlayerStateAsync(gameId, playerId); + if (playerState == null) + { + return new DeathResult + { + Success = false, + Messages = { "玩家不存在" } + }; + } + + // 如果玩家已经死亡，跳过处理 + if (playerState.State == PlayerDrawingState.Dead || playerState.State == PlayerDrawingState.Respawning) + { + return new DeathResult + { + Success = false, + Messages = { "玩家已经死亡" } + }; + } + + var actualDeathPosition = deathPosition ?? playerState.CurrentPosition; + var respawnTime = DateTime.UtcNow.AddSeconds(GameConstants.RespawnDelay); + + // 获取被清除的轨迹 + var clearedTrail = await GetPlayerTrailAsync(gameId, playerId); + + // 清除玩家轨迹 + await ClearPlayerTrailAsync(gameId, playerId); + + // 设置玩家状态为死亡 + await UpdatePlayerStateInRedisAsync(gameId, playerId, PlayerDrawingState.Dead); + + // 清除临时道具效果（但保留背包物品） + await ClearPlayerTemporaryEffectsAsync(gameId, playerId); + + // 清除无敌状态 + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + var deathUpdates = new Dictionary + { + ["is_invulnerable"] = "false", + ["death_position"] = JsonSerializer.Serialize(actualDeathPosition), + ["respawn_time"] = respawnTime.ToString("O"), + ["last_activity"] = DateTime.UtcNow.ToString("O") + }; + await _redisService.SetHashMultipleAsync(stateKey, deathUpdates); + + // 更新死亡统计 + await UpdatePlayerStatisticsAsync(gameId, playerId, stats => + { + stats.Deaths++; + stats.LastActivity = DateTime.UtcNow; + }); + + // 获取击杀者名称 + string? killerName = null; + if (killerId.HasValue) + { + var killerState = await GetPlayerStateAsync(gameId, killerId.Value); + killerName = killerState?.PlayerName; + } + + _logger.LogInformation("玩家死亡处理完成 - GameId: {GameId}, PlayerId: {PlayerId}, RespawnTime: {RespawnTime}", + gameId, playerId, respawnTime); + + return new DeathResult + { + Success = true, + DeathReason = deathReason, + KillerId = killerId, + KillerName = killerName, + DeathPosition = actualDeathPosition, + ClearedTrail = clearedTrail, + RespawnTime = respawnTime, + Messages = { $"玩家死亡：{deathReason}，{GameConstants.RespawnDelay}秒后复活" } + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "处理玩家死亡失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new DeathResult + { + Success = false, + Messages = { "处理死亡时发生内部错误" } + }; + } + } + + /// + /// 复活已死亡的玩家 + /// + public async Task RespawnPlayerAsync(Guid gameId, Guid playerId) + { + try + { + _logger.LogInformation("复活玩家 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + + // 获取玩家状态 + var playerState = await GetPlayerStateAsync(gameId, playerId); + if (playerState == null) + { + return new RespawnResult + { + Success = false, + Errors = { "玩家不存在" } + }; + } + + // 验证玩家是否处于死亡状态 + if (playerState.State != PlayerDrawingState.Dead) + { + return new RespawnResult + { + Success = false, + Errors = { "玩家不在死亡状态" } + }; + } + + // 检查复活时间是否已到 + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + var stateData = await _redisService.GetHashAllAsync(stateKey); + + if (stateData.TryGetValue("respawn_time", out var respawnTimeStr) && + DateTime.TryParse(respawnTimeStr, out var respawnTime)) + { + if (DateTime.UtcNow < respawnTime) + { + var remainingTime = respawnTime - DateTime.UtcNow; + return new RespawnResult + { + Success = false, + Errors = { $"复活冷却中，还需等待 {remainingTime.TotalSeconds:F1} 秒" } + }; + } + } + + // 设置复活位置（回到出生点） + var respawnPosition = playerState.SpawnPoint; + var invulnerabilityEndTime = DateTime.UtcNow.AddSeconds(GameConstants.InvulnerabilityDuration); + + // 更新玩家状态 + var respawnUpdates = new Dictionary + { + ["current_position"] = JsonSerializer.Serialize(respawnPosition), + ["state"] = PlayerDrawingState.Invulnerable.ToString(), + ["is_invulnerable"] = "true", + ["invulnerability_end"] = invulnerabilityEndTime.ToString("O"), + ["last_activity"] = DateTime.UtcNow.ToString("O") + }; + await _redisService.SetHashMultipleAsync(stateKey, respawnUpdates); + + // 清除死亡相关数据 + await _redisService.HashDeleteAsync(stateKey, "death_position"); + await _redisService.HashDeleteAsync(stateKey, "respawn_time"); + + // 安排无敌状态结束 + _ = Task.Delay(TimeSpan.FromSeconds(GameConstants.InvulnerabilityDuration)) + .ContinueWith(async _ => await EndInvulnerabilityAsync(gameId, playerId)); + + _logger.LogInformation("玩家复活成功 - GameId: {GameId}, PlayerId: {PlayerId}, InvulnerabilityEnd: {InvulEnd}", + gameId, playerId, invulnerabilityEndTime); + + return new RespawnResult + { + Success = true, + RespawnPosition = respawnPosition, + InvulnerabilityEndTime = invulnerabilityEndTime, + Messages = { $"复活成功，{GameConstants.InvulnerabilityDuration}秒无敌保护" } + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "复活玩家失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new RespawnResult + { + Success = false, + Errors = { "复活时发生内部错误" } + }; + } + } + + #endregion + + #region 领地和排名系统 + + /// + /// 计算玩家当前总领地面积 + /// + public async Task CalculatePlayerTerritoryAsync(Guid gameId, Guid playerId) + { + try + { + _logger.LogDebug("计算玩家领地面积 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + + // 获取玩家拥有的所有领地 + var territories = await GetPlayerTerritoriesAsync(gameId, playerId); + + if (!territories.Any()) + { + return new TerritoryResult + { + Success = true, + TotalArea = 0f, + TerritoryCount = 0, + AreaPercentage = 0f, + Messages = { "玩家没有领地" } + }; + } + + // 计算总面积（重新计算以确保准确性） + float totalArea = 0f; + var validTerritories = new List(); + + foreach (var territory in territories) + { + // 重新计算每块领地的面积 + var recalculatedArea = CalculatePolygonArea(territory.Boundary); + if (recalculatedArea >= GameConstants.MinTerritoryArea) + { + territory.Area = recalculatedArea; + totalArea += recalculatedArea; + validTerritories.Add(territory); + } + } + + // 计算面积百分比（假设地图总面积为1000x1000） + const float mapTotalArea = 1000f * 1000f; + var areaPercentage = (totalArea / mapTotalArea) * 100f; + + // 更新Redis中的领地面积 + await UpdatePlayerTerritoryAreaAsync(gameId, playerId, totalArea); + + return new TerritoryResult + { + Success = true, + TotalArea = totalArea, + Territories = validTerritories, + TerritoryCount = validTerritories.Count, + AreaPercentage = areaPercentage, + Messages = { $"总领地面积：{totalArea:F1}，占比：{areaPercentage:F2}%" } + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "计算玩家领地面积失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new TerritoryResult + { + Success = false, + Messages = { "计算领地面积时发生内部错误" } + }; + } + } + + /// + /// 获取游戏实时排名 + /// + public async Task> GetGameRankingAsync(Guid gameId) + { + try + { + _logger.LogDebug("获取游戏排名 - GameId: {GameId}", gameId); + + // 获取所有玩家状态 + var allPlayers = await GetAllPlayerStatesAsync(gameId); + + // 重新计算每个玩家的领地面积 + var rankings = new List(); + + foreach (var player in allPlayers) + { + var territoryResult = await CalculatePlayerTerritoryAsync(gameId, player.PlayerId); + + var ranking = new PlayerGameRanking + { + PlayerId = player.PlayerId, + PlayerName = player.PlayerName, + PlayerColor = player.PlayerColor, + TerritoryArea = territoryResult.TotalArea, + TerritoryCount = territoryResult.TerritoryCount, + AreaPercentage = territoryResult.AreaPercentage, + CurrentState = player.State, + LastUpdate = DateTime.UtcNow + }; + + rankings.Add(ranking); + } + + // 按领地面积排序 + rankings.Sort((a, b) => b.TerritoryArea.CompareTo(a.TerritoryArea)); + + // 分配排名 + for (int i = 0; i < rankings.Count; i++) + { + rankings[i].Rank = i + 1; + } + + // 保存排名到Redis + var rankingKey = string.Format(RedisKeys.GameRanking, gameId); + await _redisService.KeyDeleteAsync(rankingKey); + + foreach (var ranking in rankings) + { + await _redisService.ListRightPushAsync(rankingKey, JsonSerializer.Serialize(ranking)); + } + + _logger.LogDebug("游戏排名计算完成 - GameId: {GameId}, PlayerCount: {Count}", gameId, rankings.Count); + return rankings; + } + catch (Exception ex) + { + _logger.LogError(ex, "获取游戏排名失败 - GameId: {GameId}", gameId); + return new List(); + } + } + + #endregion + + #region 道具系统 + + /// + /// 玩家拾取地图上的道具 + /// + public async Task PickupItemAsync( + Guid gameId, + Guid playerId, + Guid itemId, + Position pickupPosition) + { + try + { + _logger.LogInformation("玩家拾取道具 - GameId: {GameId}, PlayerId: {PlayerId}, ItemId: {ItemId}", + gameId, playerId, itemId); + + // 获取玩家状态 + var playerState = await GetPlayerStateAsync(gameId, playerId); + if (playerState == null) + { + return new ItemPickupResult + { + Success = false, + Errors = { "玩家不存在" } + }; + } + + // 检查玩家是否存活且不在无敌状态 + if (playerState.State == PlayerDrawingState.Dead || playerState.State == PlayerDrawingState.Respawning) + { + return new ItemPickupResult + { + Success = false, + Errors = { "死亡状态下无法拾取道具" } + }; + } + + // 检查玩家位置是否接近道具 + var distance = CalculateDistance(playerState.CurrentPosition, pickupPosition); + if (distance > GameConstants.PickupRange) + { + return new ItemPickupResult + { + Success = false, + Errors = { $"距离道具太远：{distance:F1} > {GameConstants.PickupRange}" } + }; + } + + // 检查背包是否已满 + if (playerState.Inventory.Count >= GameConstants.MaxInventorySize) + { + return new ItemPickupResult + { + Success = false, + InventoryFull = true, + Errors = { "背包已满" } + }; + } + + // 模拟道具类型（实际应从道具服务获取） + var itemType = DetermineItemType(itemId); + + // 添加道具到背包 + var inventoryKey = string.Format(RedisKeys.PlayerInventory, gameId, playerId); + await _redisService.ListRightPushAsync(inventoryKey, itemType.ToString()); + + // 更新统计 + await UpdatePlayerStatisticsAsync(gameId, playerId, stats => + { + stats.ItemsPickedUp++; + stats.LastActivity = DateTime.UtcNow; + }); + + _logger.LogInformation("道具拾取成功 - GameId: {GameId}, PlayerId: {PlayerId}, ItemType: {ItemType}", + gameId, playerId, itemType); + + return new ItemPickupResult + { + Success = true, + ItemId = itemId, + ItemType = itemType, + PickupPosition = pickupPosition, + NewItemCount = playerState.Inventory.Count + 1, + Messages = { $"拾取了 {itemType} 道具" } + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "拾取道具失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new ItemPickupResult + { + Success = false, + Errors = { "拾取道具时发生内部错误" } + }; + } + } + + /// + /// 玩家使用背包中的道具 + /// + public async Task UseItemAsync( + Guid gameId, + Guid playerId, + DrawingGameItemType itemType, + Position? targetPosition = null) + { + try + { + _logger.LogInformation("玩家使用道具 - GameId: {GameId}, PlayerId: {PlayerId}, ItemType: {ItemType}", + gameId, playerId, itemType); + + // 获取玩家状态 + var playerState = await GetPlayerStateAsync(gameId, playerId); + if (playerState == null) + { + return new ItemUseResult + { + Success = false, + Errors = { "玩家不存在" } + }; + } + + // 检查玩家状态 + if (playerState.State == PlayerDrawingState.Dead || playerState.State == PlayerDrawingState.Respawning) + { + return new ItemUseResult + { + Success = false, + Errors = { "死亡状态下无法使用道具" } + }; + } + + // 检查背包中是否有该道具 + if (!playerState.Inventory.Contains(itemType)) + { + return new ItemUseResult + { + Success = false, + Errors = { "背包中没有该道具" } + }; + } + + var result = new ItemUseResult + { + Success = true, + ItemType = itemType + }; + + // 根据道具类型执行不同逻辑 + switch (itemType) + { + case DrawingGameItemType.Lightning: + result = await UseLightningItemAsync(gameId, playerId); + break; + + case DrawingGameItemType.Shield: + result = await UseShieldItemAsync(gameId, playerId); + break; + + case DrawingGameItemType.Bomb: + if (targetPosition == null) + { + result.Success = false; + result.Errors.Add("炸弹道具需要指定目标位置"); + break; + } + result = await UseBombItemAsync(gameId, playerId, targetPosition); + break; + + default: + result.Success = false; + result.Errors.Add("未知的道具类型"); + break; + } + + // 如果使用成功，从背包中移除道具 + if (result.Success) + { + await RemoveItemFromInventoryAsync(gameId, playerId, itemType); + + // 更新统计 + await UpdatePlayerStatisticsAsync(gameId, playerId, stats => + { + stats.ItemsUsed++; + stats.LastActivity = DateTime.UtcNow; + }); + } + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "使用道具失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new ItemUseResult + { + Success = false, + Errors = { "使用道具时发生内部错误" } + }; + } + } + + #endregion + + #region 道具使用私有方法 + + /// + /// 使用闪电道具 + /// + private async Task UseLightningItemAsync(Guid gameId, Guid playerId) + { + var effect = new ActiveEffect + { + Id = Guid.NewGuid(), + EffectType = DrawingGameItemType.Lightning, + StartTime = DateTime.UtcNow, + Duration = TimeSpan.FromSeconds(10), + Properties = { ["speed_multiplier"] = 1.5f } + }; + + await AddPlayerEffectAsync(gameId, playerId, effect); + + return new ItemUseResult + { + Success = true, + ItemType = DrawingGameItemType.Lightning, + AppliedEffect = effect, + Messages = { "闪电效果已激活，移动速度提升50%，持续10秒" } + }; + } + + /// + /// 使用护盾道具 + /// + private async Task UseShieldItemAsync(Guid gameId, Guid playerId) + { + var effect = new ActiveEffect + { + Id = Guid.NewGuid(), + EffectType = DrawingGameItemType.Shield, + StartTime = DateTime.UtcNow, + Duration = TimeSpan.FromSeconds(15), + Properties = { ["blocks_remaining"] = 1 } + }; + + await AddPlayerEffectAsync(gameId, playerId, effect); + + return new ItemUseResult + { + Success = true, + ItemType = DrawingGameItemType.Shield, + AppliedEffect = effect, + Messages = { "护盾效果已激活，可抵挡一次攻击，持续15秒" } + }; + } + + /// + /// 使用炸弹道具 + /// + private async Task UseBombItemAsync(Guid gameId, Guid playerId, Position targetPosition) + { + // 获取附近的玩家轨迹并清除 + var affectedPlayers = new List(); + var clearedTrails = new List(); + + // 获取所有玩家 + var allPlayers = await GetAllPlayerStatesAsync(gameId); + + // 检查爆炸范围内的轨迹 + foreach (var player in allPlayers) + { + if (player.PlayerId == playerId) continue; // 不影响自己 + + if (player.State == PlayerDrawingState.Drawing) + { + var trail = await GetPlayerTrailAsync(gameId, player.PlayerId); + bool hasNearbyTrail = trail.Any(pos => CalculateDistance(pos, targetPosition) <= 100f); + + if (hasNearbyTrail) + { + // 清除该玩家的轨迹 + await ClearPlayerTrailAsync(gameId, player.PlayerId); + await UpdatePlayerStateInRedisAsync(gameId, player.PlayerId, PlayerDrawingState.Idle); + + affectedPlayers.Add(player.PlayerId); + clearedTrails.AddRange(trail.Where(pos => CalculateDistance(pos, targetPosition) <= 100f)); + } + } + } + + _logger.LogInformation("炸弹在位置 ({X},{Y}) 爆炸，影响了 {Count} 个玩家", + targetPosition.X, targetPosition.Y, affectedPlayers.Count); + + return new ItemUseResult + { + Success = true, + ItemType = DrawingGameItemType.Bomb, + TargetPosition = targetPosition, + AffectedPlayers = affectedPlayers, + ClearedTrails = clearedTrails, + Messages = { $"炸弹在位置 ({targetPosition.X:F0},{targetPosition.Y:F0}) 爆炸，影响了 {affectedPlayers.Count} 个玩家" } + }; + } + + #endregion + + #region 更多私有辅助方法 + + /// + /// 移除玩家效果 + /// + private async Task RemovePlayerEffectAsync(Guid gameId, Guid playerId, Guid effectId) + { + try + { + var effectsKey = string.Format(RedisKeys.PlayerEffects, gameId, playerId); + var effectsData = await _redisService.ListRangeAsync(effectsKey); + + // 重建效果列表，移除指定效果 + await _redisService.KeyDeleteAsync(effectsKey); + + foreach (var effectData in effectsData) + { + try + { + var effect = JsonSerializer.Deserialize(effectData); + if (effect?.Id != effectId) + { + await _redisService.ListRightPushAsync(effectsKey, effectData); + } + } + catch + { + // 忽略无效的效果数据 + } + } + } + catch (Exception ex) + { + _logger.LogError(ex, "移除玩家效果失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + } + } + + /// + /// 清除玩家临时效果 + /// + private async Task ClearPlayerTemporaryEffectsAsync(Guid gameId, Guid playerId) + { + try + { + var effectsKey = string.Format(RedisKeys.PlayerEffects, gameId, playerId); + await _redisService.KeyDeleteAsync(effectsKey); + _logger.LogDebug("已清除玩家临时效果 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + } + catch (Exception ex) + { + _logger.LogError(ex, "清除玩家临时效果失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + } + } + + /// + /// 结束无敌状态 + /// + private async Task EndInvulnerabilityAsync(Guid gameId, Guid playerId) + { + try + { + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + var updates = new Dictionary + { + ["is_invulnerable"] = "false", + ["state"] = PlayerDrawingState.Idle.ToString(), + ["last_activity"] = DateTime.UtcNow.ToString("O") + }; + + await _redisService.SetHashMultipleAsync(stateKey, updates); + await _redisService.HashDeleteAsync(stateKey, "invulnerability_end"); + + _logger.LogDebug("无敌状态已结束 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + } + catch (Exception ex) + { + _logger.LogError(ex, "结束无敌状态失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + } + } + + /// + /// 确定道具类型（模拟方法） + /// + private static DrawingGameItemType DetermineItemType(Guid itemId) + { + // 简化实现：根据ID哈希值确定道具类型 + var hash = itemId.GetHashCode(); + var itemTypes = Enum.GetValues(); + return itemTypes[Math.Abs(hash) % itemTypes.Length]; + } + + /// + /// 从背包移除道具 + /// + private async Task RemoveItemFromInventoryAsync(Guid gameId, Guid playerId, DrawingGameItemType itemType) + { + try + { + var inventoryKey = string.Format(RedisKeys.PlayerInventory, gameId, playerId); + var inventoryData = await _redisService.ListRangeAsync(inventoryKey); + + // 重建背包，移除一个指定类型的道具 + await _redisService.KeyDeleteAsync(inventoryKey); + bool removed = false; + + foreach (var itemData in inventoryData) + { + if (!removed && Enum.TryParse(itemData, out var currentItemType) && currentItemType == itemType) + { + removed = true; // 跳过第一个匹配的道具 + continue; + } + await _redisService.ListRightPushAsync(inventoryKey, itemData); + } + + _logger.LogDebug("已从背包移除道具 - GameId: {GameId}, PlayerId: {PlayerId}, ItemType: {ItemType}", + gameId, playerId, itemType); + } + catch (Exception ex) + { + _logger.LogError(ex, "从背包移除道具失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + } + } + + /// + /// 添加玩家效果 + /// + private async Task AddPlayerEffectAsync(Guid gameId, Guid playerId, ActiveEffect effect) + { + try + { + var effectsKey = string.Format(RedisKeys.PlayerEffects, gameId, playerId); + var effectData = JsonSerializer.Serialize(effect); + await _redisService.ListRightPushAsync(effectsKey, effectData); + + _logger.LogDebug("已添加玩家效果 - GameId: {GameId}, PlayerId: {PlayerId}, EffectType: {EffectType}", + gameId, playerId, effect.EffectType); + } + catch (Exception ex) + { + _logger.LogError(ex, "添加玩家效果失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + } + } + + #endregion +} diff --git a/backend/src/CollabApp.Application/Services/Game/PowerUpService.cs b/backend/src/CollabApp.Application/Services/Game/PowerUpService.cs new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/backend/src/CollabApp.Application/Services/Game/TerritoryService.cs b/backend/src/CollabApp.Application/Services/Game/TerritoryService.cs new file mode 100644 index 0000000000000000000000000000000000000000..37c07dbe680a86d8d734cda16249c45e870eeede --- /dev/null +++ b/backend/src/CollabApp.Application/Services/Game/TerritoryService.cs @@ -0,0 +1,1098 @@ +using CollabApp.Application.Interfaces; +using CollabApp.Domain.Entities.Game; +using CollabApp.Domain.Services.Game; +using Microsoft.Extensions.Logging; +using System.Text.Json; + +namespace CollabApp.Application.Services.Game; + +/// +/// 领土管理服务实现 +/// 负责管理圈地游戏中的领土系统，包括画线轨迹、领地计算、圈地检测等 +/// +public class TerritoryService : ITerritoryService +{ + private readonly IRedisService _redisService; + private readonly ILogger _logger; + + /// + /// Redis键格式 + /// + private static class RedisKeys + { + public const string PlayerTrail = "player_trail:{0}:{1}"; // gameId:playerId + public const string PlayerTerritory = "player_territory:{0}:{1}"; // gameId:playerId + public const string PlayerState = "player_state:{0}:{1}"; // gameId:playerId + public const string GamePlayers = "game_players:{0}"; // gameId + public const string MapDistribution = "map_distribution:{0}"; // gameId + public const string TerritoryBounds = "territory_bounds:{0}:{1}"; // gameId:playerId + } + + /// + /// 游戏常量 + /// + private static class GameConstants + { + public const float MaxTrailLength = 500f; // 最大画线长度 + public const float MinTerritoryArea = 100f; // 最小有效领地面积 + public const float MapSize = 1000f; // 地图大小 + public const float MapTotalArea = MapSize * MapSize; // 地图总面积 + public const decimal DominantPlayerThreshold = 0.7m; // 优势玩家阈值70% + public const float NearLimitThreshold = 0.8f; // 接近限制的阈值80% + } + + /// + /// 构造函数 + /// + public TerritoryService(IRedisService redisService, ILogger logger) + { + _redisService = redisService ?? throw new ArgumentNullException(nameof(redisService)); + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + /// + /// 开始画线 + /// + public async Task StartDrawingAsync(Guid gameId, Guid playerId, Position startPosition) + { + try + { + _logger.LogInformation("开始画线 - GameId: {GameId}, PlayerId: {PlayerId}, Position: ({X},{Y})", + gameId, playerId, startPosition.X, startPosition.Y); + + // 验证起始位置是否合法（在玩家领地内或出生点） + var ownership = await CheckTerritoryOwnershipAsync(gameId, startPosition, playerId); + if (!ownership.IsOwned && !ownership.IsSpawnArea) + { + return new DrawingStartResult + { + Success = false, + Errors = { "只能从自己的领地或出生点开始画线" } + }; + } + + // 清空当前轨迹 + var trailKey = string.Format(RedisKeys.PlayerTrail, gameId, playerId); + await _redisService.KeyDeleteAsync(trailKey); + + // 添加起始点 + var trailPoint = JsonSerializer.Serialize(new TrailPoint + { + Position = startPosition, + Timestamp = DateTime.UtcNow, + SequenceNumber = 0 + }); + await _redisService.ListRightPushAsync(trailKey, trailPoint); + + // 更新玩家状态为画线中 + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + await _redisService.SetHashAsync(stateKey, "state", PlayerDrawingState.Drawing.ToString()); + await _redisService.SetHashAsync(stateKey, "drawing_start_time", DateTime.UtcNow.ToString("O")); + + _logger.LogInformation("画线开始成功 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + + return new DrawingStartResult + { + Success = true, + StartPosition = startPosition, + StartTime = DateTime.UtcNow, + Messages = { "开始画线" } + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "开始画线失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new DrawingStartResult + { + Success = false, + Errors = { "开始画线时发生内部错误" } + }; + } + } + + /// + /// 更新画线轨迹 + /// + public async Task UpdateTrailAsync(Guid gameId, Guid playerId, Position newPosition) + { + try + { + _logger.LogDebug("更新画线轨迹 - GameId: {GameId}, PlayerId: {PlayerId}, Position: ({X},{Y})", + gameId, playerId, newPosition.X, newPosition.Y); + + var trailKey = string.Format(RedisKeys.PlayerTrail, gameId, playerId); + + // 获取当前轨迹 + var currentTrailData = await _redisService.ListRangeAsync(trailKey); + var currentTrail = currentTrailData.Select(data => + { + try + { + var trailPoint = JsonSerializer.Deserialize(data); + return trailPoint?.Position ?? new Position(); + } + catch + { + return new Position(); + } + }).ToList(); + + // 计算当前轨迹长度 + var currentLength = CalculateTrailLength(currentTrail); + + // 检查是否会超过长度限制 + var distanceToAdd = currentTrail.Any() + ? CalculateDistance(currentTrail.Last(), newPosition) + : 0f; + + if (currentLength + distanceToAdd > GameConstants.MaxTrailLength) + { + return new TrailUpdateResult + { + Success = false, + CurrentTrail = currentTrail, + TrailLength = currentLength, + ErrorMessage = $"画线长度超过限制：{currentLength + distanceToAdd:F1} > {GameConstants.MaxTrailLength}" + }; + } + + // 添加新的轨迹点 + var newTrailPoint = JsonSerializer.Serialize(new TrailPoint + { + Position = newPosition, + Timestamp = DateTime.UtcNow, + SequenceNumber = currentTrail.Count + }); + await _redisService.ListRightPushAsync(trailKey, newTrailPoint); + + // 更新后的轨迹 + currentTrail.Add(newPosition); + var newLength = currentLength + distanceToAdd; + var isNearLimit = newLength / GameConstants.MaxTrailLength > GameConstants.NearLimitThreshold; + + _logger.LogDebug("轨迹更新成功 - GameId: {GameId}, PlayerId: {PlayerId}, Length: {Length:F1}", + gameId, playerId, newLength); + + return new TrailUpdateResult + { + Success = true, + TrailId = Guid.NewGuid(), // 模拟轨迹ID + CurrentTrail = currentTrail, + TrailLength = newLength, + IsNearLimit = isNearLimit + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "更新画线轨迹失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new TrailUpdateResult + { + Success = false, + ErrorMessage = "更新轨迹时发生内部错误" + }; + } + } + + /// + /// 完成圈地 + /// + public async Task CompleteTerritoryAsync(Guid gameId, Guid playerId, Position endPosition) + { + try + { + _logger.LogInformation("完成圈地 - GameId: {GameId}, PlayerId: {PlayerId}, EndPosition: ({X},{Y})", + gameId, playerId, endPosition.X, endPosition.Y); + + // 获取当前轨迹 + var trailKey = string.Format(RedisKeys.PlayerTrail, gameId, playerId); + var currentTrailData = await _redisService.ListRangeAsync(trailKey); + var currentTrail = currentTrailData.Select(data => + { + try + { + var trailPoint = JsonSerializer.Deserialize(data); + return trailPoint?.Position ?? new Position(); + } + catch + { + return new Position(); + } + }).ToList(); + + if (currentTrail.Count < 3) + { + return new TerritoryCompleteResult + { + Success = false, + ErrorMessage = "轨迹点数不足，无法圈地" + }; + } + + // 添加结束点形成闭合 + currentTrail.Add(endPosition); + + // 检查是否形成有效的闭合区域 + if (!IsValidClosedArea(currentTrail)) + { + return new TerritoryCompleteResult + { + Success = false, + ErrorMessage = "未形成有效的闭合区域" + }; + } + + // 计算新领地面积 + var newArea = CalculatePolygonArea(currentTrail); + if (newArea < GameConstants.MinTerritoryArea) + { + return new TerritoryCompleteResult + { + Success = false, + ErrorMessage = $"圈地面积过小：{newArea:F1} < {GameConstants.MinTerritoryArea}" + }; + } + + // 检查是否征服了其他玩家的领地 + var conquestResult = await CalculateTerritoryConquestAsync(gameId, playerId, currentTrail); + + // 获取玩家当前总面积 + var currentAreaInfo = await CalculatePlayerTerritoryAsync(gameId, playerId); + var newTotalArea = currentAreaInfo.CurrentArea + (decimal)newArea + conquestResult.TotalConqueredArea; + + // 保存新领地 + await SavePlayerTerritoryAsync(gameId, playerId, currentTrail, newArea); + + // 清除轨迹 + await _redisService.KeyDeleteAsync(trailKey); + + // 更新玩家状态为空闲 + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + await _redisService.SetHashAsync(stateKey, "state", PlayerDrawingState.Idle.ToString()); + await _redisService.SetHashAsync(stateKey, "territory_area", newTotalArea.ToString("F2")); + + _logger.LogInformation("圈地完成 - GameId: {GameId}, PlayerId: {PlayerId}, Area: {Area:F1}, NewTotal: {Total:F1}", + gameId, playerId, newArea, newTotalArea); + + return new TerritoryCompleteResult + { + Success = true, + AreaGained = (decimal)newArea, + NewTotalArea = newTotalArea, + NewTerritory = currentTrail, + ConqueredPlayers = conquestResult.ConqueredPlayers, + ConqueredArea = conquestResult.TotalConqueredArea + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "完成圈地失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new TerritoryCompleteResult + { + Success = false, + ErrorMessage = "完成圈地时发生内部错误" + }; + } + } + + /// + /// 计算玩家领地面积 + /// + public async Task CalculatePlayerTerritoryAsync(Guid gameId, Guid playerId) + { + try + { + _logger.LogDebug("计算玩家领地面积 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + + var territoryKey = string.Format(RedisKeys.PlayerTerritory, gameId, playerId); + var territoriesData = await _redisService.ListRangeAsync(territoryKey); + + var totalArea = 0m; + var allBoundaries = new List(); + + foreach (var territoryData in territoriesData) + { + try + { + var territory = JsonSerializer.Deserialize(territoryData); + if (territory != null) + { + totalArea += (decimal)territory.Area; + allBoundaries.AddRange(territory.Boundary); + } + } + catch (JsonException) + { + // 忽略无效的领地数据 + } + } + + // 计算面积百分比 + var areaPercentage = totalArea / (decimal)GameConstants.MapTotalArea * 100; + + // 计算领地中心 + var center = allBoundaries.Any() + ? new Position + { + X = allBoundaries.Average(p => p.X), + Y = allBoundaries.Average(p => p.Y) + } + : new Position(); + + // 获取排名（简化处理） + var rank = await GetPlayerRankAsync(gameId, playerId); + + return new TerritoryAreaInfo + { + PlayerId = playerId, + CurrentArea = totalArea, + AreaPercentage = areaPercentage, + Rank = rank, + TerritoryBoundary = allBoundaries, + Center = center + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "计算玩家领地面积失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new TerritoryAreaInfo + { + PlayerId = playerId, + CurrentArea = 0m + }; + } + } + + /// + /// 检查位置是否在玩家领地内 + /// + public async Task CheckTerritoryOwnershipAsync(Guid gameId, Position position, Guid? playerId = null) + { + try + { + _logger.LogDebug("检查领地归属 - GameId: {GameId}, Position: ({X},{Y}), PlayerId: {PlayerId}", + gameId, position.X, position.Y, playerId); + + // 如果指定了玩家ID，只检查该玩家的领地 + if (playerId.HasValue) + { + var isOwnedByPlayer = await IsPositionInPlayerTerritoryAsync(gameId, playerId.Value, position); + if (isOwnedByPlayer) + { + var playerColor = await GetPlayerColorAsync(gameId, playerId.Value); + return new TerritoryOwnership + { + IsOwned = true, + OwnerId = playerId.Value, + OwnerColor = playerColor + }; + } + } + + // 检查所有玩家的领地 + var playersKey = string.Format(RedisKeys.GamePlayers, gameId); + var playerIds = await _redisService.GetSetMembersAsync(playersKey); + + foreach (var playerIdStr in playerIds) + { + if (Guid.TryParse(playerIdStr, out var checkPlayerId)) + { + var isOwnedByPlayer = await IsPositionInPlayerTerritoryAsync(gameId, checkPlayerId, position); + if (isOwnedByPlayer) + { + var playerColor = await GetPlayerColorAsync(gameId, checkPlayerId); + return new TerritoryOwnership + { + IsOwned = true, + OwnerId = checkPlayerId, + OwnerColor = playerColor + }; + } + } + } + + // 检查是否为出生区域（简化处理） + var isSpawnArea = await IsSpawnAreaAsync(gameId, position); + + return new TerritoryOwnership + { + IsOwned = false, + IsNeutralZone = !isSpawnArea, + IsSpawnArea = isSpawnArea, + DistanceToNearestBoundary = await CalculateDistanceToNearestBoundaryAsync(gameId, position) + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "检查领地归属失败 - GameId: {GameId}, Position: ({X},{Y})", gameId, position.X, position.Y); + return new TerritoryOwnership + { + IsOwned = false, + IsNeutralZone = true + }; + } + } + + /// + /// 重置玩家领地 + /// + public async Task ResetPlayerTerritoryAsync(Guid gameId, Guid playerId, decimal keepPercentage = 0.2m) + { + try + { + _logger.LogInformation("重置玩家领地 - GameId: {GameId}, PlayerId: {PlayerId}, KeepPercentage: {Percentage}", + gameId, playerId, keepPercentage); + + // 获取当前领地面积 + var currentAreaInfo = await CalculatePlayerTerritoryAsync(gameId, playerId); + var lostArea = currentAreaInfo.CurrentArea * (1 - keepPercentage); + var remainingArea = currentAreaInfo.CurrentArea * keepPercentage; + + // 清除大部分领地，只保留出生点附近的小安全区 + var territoryKey = string.Format(RedisKeys.PlayerTerritory, gameId, playerId); + await _redisService.KeyDeleteAsync(territoryKey); + + // 获取出生点 + var spawnPoint = await GetPlayerSpawnPointAsync(gameId, playerId); + + // 创建小安全区 + var safeAreaSize = Math.Max(50f, (float)remainingArea * 0.1f); + var safeArea = CreateSafeArea(spawnPoint, safeAreaSize); + + await SavePlayerTerritoryAsync(gameId, playerId, safeArea, safeAreaSize * safeAreaSize); + + // 更新玩家领地面积 + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + await _redisService.SetHashAsync(stateKey, "territory_area", remainingArea.ToString("F2")); + + _logger.LogInformation("领地重置完成 - GameId: {GameId}, PlayerId: {PlayerId}, Lost: {Lost:F1}, Remaining: {Remaining:F1}", + gameId, playerId, lostArea, remainingArea); + + return new TerritoryResetResult + { + Success = true, + RemainingArea = remainingArea, + NewSpawnArea = spawnPoint, + LostArea = lostArea + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "重置玩家领地失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new TerritoryResetResult + { + Success = false + }; + } + } + + /// + /// 获取地图领土分布 + /// + public async Task GetMapTerritoryDistributionAsync(Guid gameId) + { + try + { + _logger.LogDebug("获取地图领土分布 - GameId: {GameId}", gameId); + + var distribution = new MapTerritoryDistribution + { + GameId = gameId, + Timestamp = DateTime.UtcNow, + TotalMapArea = GameConstants.MapTotalArea + }; + + // 获取所有玩家 + var playersKey = string.Format(RedisKeys.GamePlayers, gameId); + var playerIds = await _redisService.GetSetMembersAsync(playersKey); + + var playerTerritories = new List(); + decimal totalClaimedArea = 0m; + + foreach (var playerIdStr in playerIds) + { + if (Guid.TryParse(playerIdStr, out var playerId)) + { + var areaInfo = await CalculatePlayerTerritoryAsync(gameId, playerId); + var playerName = await GetPlayerNameAsync(gameId, playerId); + var playerColor = await GetPlayerColorAsync(gameId, playerId); + var isDrawing = await IsPlayerDrawingAsync(gameId, playerId); + + var playerInfo = new PlayerTerritoryInfo + { + PlayerId = playerId, + PlayerName = playerName, + PlayerColor = playerColor, + Area = areaInfo.CurrentArea, + Percentage = areaInfo.AreaPercentage, + Rank = areaInfo.Rank, + Territory = areaInfo.TerritoryBoundary, + SpawnPoint = await GetPlayerSpawnPointAsync(gameId, playerId), + IsDrawing = isDrawing + }; + + if (isDrawing) + { + playerInfo.CurrentTrail = await GetPlayerCurrentTrailAsync(gameId, playerId); + } + + playerTerritories.Add(playerInfo); + totalClaimedArea += areaInfo.CurrentArea; + } + } + + // 按面积排序并更新排名 + playerTerritories = playerTerritories.OrderByDescending(p => p.Area).ToList(); + for (int i = 0; i < playerTerritories.Count; i++) + { + playerTerritories[i].Rank = i + 1; + } + + distribution.PlayerTerritories = playerTerritories; + distribution.ClaimedArea = (float)totalClaimedArea; + distribution.NeutralArea = GameConstants.MapTotalArea - (float)totalClaimedArea; + + // 检查是否有主导玩家 + if (playerTerritories.Any()) + { + var topPlayer = playerTerritories.First(); + if (topPlayer.Percentage >= (decimal)(GameConstants.DominantPlayerThreshold * 100)) + { + distribution.HasDominantPlayer = true; + distribution.DominantPlayerId = topPlayer.PlayerId; + } + } + + return distribution; + } + catch (Exception ex) + { + _logger.LogError(ex, "获取地图领土分布失败 - GameId: {GameId}", gameId); + return new MapTerritoryDistribution + { + GameId = gameId, + Timestamp = DateTime.UtcNow, + TotalMapArea = GameConstants.MapTotalArea + }; + } + } + + /// + /// 计算领地征服 + /// + public async Task CalculateTerritoryConquestAsync(Guid gameId, Guid attackerId, List newTerritory) + { + try + { + _logger.LogDebug("计算领地征服 - GameId: {GameId}, AttackerId: {AttackerId}", gameId, attackerId); + + var result = new TerritoryConquestResult + { + Success = true + }; + + // 获取所有其他玩家 + var playersKey = string.Format(RedisKeys.GamePlayers, gameId); + var playerIds = await _redisService.GetSetMembersAsync(playersKey); + + foreach (var playerIdStr in playerIds) + { + if (Guid.TryParse(playerIdStr, out var defenderId) && defenderId != attackerId) + { + // 计算被征服的面积 + var conqueredArea = await CalculateConqueredAreaAsync(gameId, defenderId, newTerritory); + + if (conqueredArea > 0) + { + result.ConqueredPlayers.Add(defenderId); + result.TotalConqueredArea += (decimal)conqueredArea; + + result.Conquests.Add(new TerritoryConquest + { + ConqueredPlayerId = defenderId, + ConqueredArea = (decimal)conqueredArea, + ConqueredTerritory = await GetConqueredTerritoryBoundaryAsync(gameId, defenderId, newTerritory) + }); + + // 从被征服玩家的领地中移除被征服部分 + await RemoveConqueredTerritoryAsync(gameId, defenderId, newTerritory); + } + } + } + + // 计算攻击者的新总面积 + var attackerCurrentArea = await CalculatePlayerTerritoryAsync(gameId, attackerId); + var newTerritoryArea = CalculatePolygonArea(newTerritory); + result.NewTotalArea = attackerCurrentArea.CurrentArea + (decimal)newTerritoryArea + result.TotalConqueredArea; + + _logger.LogDebug("领地征服计算完成 - GameId: {GameId}, AttackerId: {AttackerId}, ConqueredPlayers: {Count}, ConqueredArea: {Area:F1}", + gameId, attackerId, result.ConqueredPlayers.Count, result.TotalConqueredArea); + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "计算领地征服失败 - GameId: {GameId}, AttackerId: {AttackerId}", gameId, attackerId); + return new TerritoryConquestResult + { + Success = false + }; + } + } + + /// + /// 检查画线长度限制 + /// + public async Task CheckTrailLengthLimitAsync(Guid gameId, Guid playerId) + { + try + { + var trailKey = string.Format(RedisKeys.PlayerTrail, gameId, playerId); + var trailData = await _redisService.ListRangeAsync(trailKey); + + var trail = trailData.Select(data => + { + try + { + var trailPoint = JsonSerializer.Deserialize(data); + return trailPoint?.Position ?? new Position(); + } + catch + { + return new Position(); + } + }).ToList(); + + var currentLength = CalculateTrailLength(trail); + var remainingLength = GameConstants.MaxTrailLength - currentLength; + var isNearLimit = currentLength / GameConstants.MaxTrailLength > GameConstants.NearLimitThreshold; + + return new TrailLengthCheckResult + { + IsWithinLimit = currentLength <= GameConstants.MaxTrailLength, + CurrentLength = currentLength, + MaxLength = GameConstants.MaxTrailLength, + RemainingLength = Math.Max(0, remainingLength), + IsNearLimit = isNearLimit + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "检查画线长度限制失败 - GameId: {GameId}, PlayerId: {PlayerId}", gameId, playerId); + return new TrailLengthCheckResult + { + IsWithinLimit = false, + MaxLength = GameConstants.MaxTrailLength + }; + } + } + + /// + /// 应用地图缩圈效果 + /// + public async Task ApplyMapShrinkAsync(Guid gameId, float shrinkRadius) + { + try + { + _logger.LogInformation("应用地图缩圈效果 - GameId: {GameId}, ShrinkRadius: {Radius}", gameId, shrinkRadius); + + var result = new MapShrinkResult + { + Success = true, + NewMapRadius = shrinkRadius + }; + + // 获取所有玩家 + var playersKey = string.Format(RedisKeys.GamePlayers, gameId); + var playerIds = await _redisService.GetSetMembersAsync(playersKey); + + foreach (var playerIdStr in playerIds) + { + if (Guid.TryParse(playerIdStr, out var playerId)) + { + var areaLoss = await CalculateAreaLossFromShrink(gameId, playerId, shrinkRadius); + if (areaLoss.AreaLost > 0) + { + result.AffectedPlayers.Add(playerId); + result.TotalAreaLost += areaLoss.AreaLost; + result.PlayerLosses.Add(areaLoss); + + // 更新玩家领地面积 + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + await _redisService.SetHashAsync(stateKey, "territory_area", areaLoss.RemainingArea.ToString("F2")); + } + } + } + + _logger.LogInformation("地图缩圈应用完成 - GameId: {GameId}, AffectedPlayers: {Count}, TotalAreaLost: {Area:F1}", + gameId, result.AffectedPlayers.Count, result.TotalAreaLost); + + return result; + } + catch (Exception ex) + { + _logger.LogError(ex, "应用地图缩圈效果失败 - GameId: {GameId}", gameId); + return new MapShrinkResult + { + Success = false + }; + } + } + + /// + /// 检查提前结束条件 + /// + public async Task CheckEarlyEndConditionAsync(Guid gameId) + { + try + { + _logger.LogDebug("检查提前结束条件 - GameId: {GameId}", gameId); + + var distribution = await GetMapTerritoryDistributionAsync(gameId); + + // 检查是否有主导玩家 + if (distribution.HasDominantPlayer) + { + var dominantPlayer = distribution.PlayerTerritories.First(); + return new EarlyEndCheckResult + { + CanEndEarly = true, + DominantPlayerId = dominantPlayer.PlayerId, + DominantPlayerPercentage = dominantPlayer.Percentage, + Reason = EarlyEndReason.DominantPlayer + }; + } + + // 检查是否只剩一个存活玩家 + var alivePlayers = await GetAlivePlayersCountAsync(gameId); + if (alivePlayers <= 1) + { + return new EarlyEndCheckResult + { + CanEndEarly = true, + Reason = EarlyEndReason.LastPlayerStanding + }; + } + + return new EarlyEndCheckResult + { + CanEndEarly = false, + Reason = EarlyEndReason.None + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "检查提前结束条件失败 - GameId: {GameId}", gameId); + return new EarlyEndCheckResult + { + CanEndEarly = false, + Reason = EarlyEndReason.None + }; + } + } + + #region 私有辅助方法 + + /// + /// 轨迹点数据结构 + /// + private class TrailPoint + { + public Position Position { get; set; } = new(); + public DateTime Timestamp { get; set; } + public int SequenceNumber { get; set; } + } + + /// + /// 领地多边形数据结构 + /// + private class TerritoryPolygon + { + public Guid Id { get; set; } + public List Boundary { get; set; } = new(); + public float Area { get; set; } + public DateTime CapturedTime { get; set; } + } + + /// + /// 计算轨迹长度 + /// + private static float CalculateTrailLength(List trail) + { + if (trail.Count < 2) return 0f; + + float totalLength = 0f; + for (int i = 1; i < trail.Count; i++) + { + totalLength += CalculateDistance(trail[i - 1], trail[i]); + } + return totalLength; + } + + /// + /// 计算两点间距离 + /// + private static float CalculateDistance(Position pos1, Position pos2) + { + var dx = pos2.X - pos1.X; + var dy = pos2.Y - pos1.Y; + return (float)Math.Sqrt(dx * dx + dy * dy); + } + + /// + /// 检查是否为有效闭合区域 + /// + private static bool IsValidClosedArea(List polygon) + { + if (polygon.Count < 3) return false; + + // 简化检查：起点和终点距离是否足够近，或者终点是否与某个中间点接近 + var startPoint = polygon.First(); + var endPoint = polygon.Last(); + + return CalculateDistance(startPoint, endPoint) < 50f; // 50像素内认为闭合 + } + + /// + /// 计算多边形面积（Shoelace公式） + /// + private static float CalculatePolygonArea(List polygon) + { + if (polygon.Count < 3) return 0f; + + float area = 0f; + int j = polygon.Count - 1; + + for (int i = 0; i < polygon.Count; i++) + { + area += (polygon[j].X + polygon[i].X) * (polygon[j].Y - polygon[i].Y); + j = i; + } + + return Math.Abs(area) / 2f; + } + + /// + /// 保存玩家领地 + /// + private async Task SavePlayerTerritoryAsync(Guid gameId, Guid playerId, List boundary, float area) + { + var territoryKey = string.Format(RedisKeys.PlayerTerritory, gameId, playerId); + var territory = new TerritoryPolygon + { + Id = Guid.NewGuid(), + Boundary = boundary, + Area = area, + CapturedTime = DateTime.UtcNow + }; + + await _redisService.ListRightPushAsync(territoryKey, JsonSerializer.Serialize(territory)); + } + + /// + /// 检查位置是否在玩家领地内 + /// + private async Task IsPositionInPlayerTerritoryAsync(Guid gameId, Guid playerId, Position position) + { + var territoryKey = string.Format(RedisKeys.PlayerTerritory, gameId, playerId); + var territoriesData = await _redisService.ListRangeAsync(territoryKey); + + foreach (var territoryData in territoriesData) + { + try + { + var territory = JsonSerializer.Deserialize(territoryData); + if (territory != null && IsPointInPolygon(position, territory.Boundary)) + { + return true; + } + } + catch + { + // 忽略无效数据 + } + } + + return false; + } + + /// + /// 点在多边形内判断（射线法） + /// + private static bool IsPointInPolygon(Position point, List polygon) + { + if (polygon.Count < 3) return false; + + bool inside = false; + int j = polygon.Count - 1; + + for (int i = 0; i < polygon.Count; i++) + { + var pi = polygon[i]; + var pj = polygon[j]; + + if (((pi.Y > point.Y) != (pj.Y > point.Y)) && + (point.X < (pj.X - pi.X) * (point.Y - pi.Y) / (pj.Y - pi.Y) + pi.X)) + { + inside = !inside; + } + j = i; + } + + return inside; + } + + // 其他辅助方法的简化实现... + private async Task GetPlayerColorAsync(Guid gameId, Guid playerId) + { + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + return await _redisService.HashGetAsync(stateKey, "player_color") ?? "red"; + } + + private async Task GetPlayerRankAsync(Guid gameId, Guid playerId) + { + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + var rankStr = await _redisService.HashGetAsync(stateKey, "current_rank"); + return int.TryParse(rankStr, out var rank) ? rank : 0; + } + + private Task IsSpawnAreaAsync(Guid gameId, Position position) + { + // 简化实现：检查是否在地图边缘附近 + var isSpawnArea = position.X < 50 || position.Y < 50 || + position.X > GameConstants.MapSize - 50 || + position.Y > GameConstants.MapSize - 50; + return Task.FromResult(isSpawnArea); + } + + private Task CalculateDistanceToNearestBoundaryAsync(Guid gameId, Position position) + { + // 简化实现：返回到地图边界的距离 + var distanceToEdges = new[] + { + position.X, // 左边界 + position.Y, // 上边界 + GameConstants.MapSize - position.X, // 右边界 + GameConstants.MapSize - position.Y // 下边界 + }; + return Task.FromResult(distanceToEdges.Min()); + } + + private async Task GetPlayerSpawnPointAsync(Guid gameId, Guid playerId) + { + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + var spawnPointStr = await _redisService.HashGetAsync(stateKey, "spawn_point"); + + if (!string.IsNullOrEmpty(spawnPointStr)) + { + try + { + return JsonSerializer.Deserialize(spawnPointStr) ?? new Position(); + } + catch + { + // 忽略解析错误 + } + } + + return new Position { X = 500, Y = 500 }; // 默认中心点 + } + + private static List CreateSafeArea(Position center, float size) + { + var halfSize = size / 2; + return new List + { + new() { X = center.X - halfSize, Y = center.Y - halfSize }, + new() { X = center.X + halfSize, Y = center.Y - halfSize }, + new() { X = center.X + halfSize, Y = center.Y + halfSize }, + new() { X = center.X - halfSize, Y = center.Y + halfSize } + }; + } + + private async Task GetPlayerNameAsync(Guid gameId, Guid playerId) + { + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + return await _redisService.HashGetAsync(stateKey, "player_name") ?? "Unknown"; + } + + private async Task IsPlayerDrawingAsync(Guid gameId, Guid playerId) + { + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + var state = await _redisService.HashGetAsync(stateKey, "state"); + return state == PlayerDrawingState.Drawing.ToString(); + } + + private async Task> GetPlayerCurrentTrailAsync(Guid gameId, Guid playerId) + { + var trailKey = string.Format(RedisKeys.PlayerTrail, gameId, playerId); + var trailData = await _redisService.ListRangeAsync(trailKey); + + return trailData.Select(data => + { + try + { + var trailPoint = JsonSerializer.Deserialize(data); + return trailPoint?.Position ?? new Position(); + } + catch + { + return new Position(); + } + }).ToList(); + } + + // 更多简化的辅助方法... + private Task CalculateConqueredAreaAsync(Guid gameId, Guid defenderId, List attackerTerritory) + { + // 简化实现：计算被包围的面积 + return Task.FromResult(0f); // 实际需要复杂的几何计算 + } + + private Task> GetConqueredTerritoryBoundaryAsync(Guid gameId, Guid defenderId, List attackerTerritory) + { + return Task.FromResult(new List()); // 简化实现 + } + + private Task RemoveConqueredTerritoryAsync(Guid gameId, Guid defenderId, List attackerTerritory) + { + // 简化实现：移除被征服的领地部分 + return Task.CompletedTask; + } + + private async Task CalculateAreaLossFromShrink(Guid gameId, Guid playerId, float shrinkRadius) + { + var currentArea = await CalculatePlayerTerritoryAsync(gameId, playerId); + var lostArea = currentArea.CurrentArea * 0.1m; // 简化：损失10% + + return new PlayerAreaLoss + { + PlayerId = playerId, + AreaLost = lostArea, + RemainingArea = currentArea.CurrentArea - lostArea + }; + } + + private async Task GetAlivePlayersCountAsync(Guid gameId) + { + var playersKey = string.Format(RedisKeys.GamePlayers, gameId); + var playerIds = await _redisService.GetSetMembersAsync(playersKey); + + int aliveCount = 0; + foreach (var playerIdStr in playerIds) + { + if (Guid.TryParse(playerIdStr, out var playerId)) + { + var stateKey = string.Format(RedisKeys.PlayerState, gameId, playerId); + var state = await _redisService.HashGetAsync(stateKey, "state"); + if (state != PlayerDrawingState.Dead.ToString()) + { + aliveCount++; + } + } + } + + return aliveCount; + } + + #endregion +} diff --git a/backend/src/CollabApp.Domain/CollabApp.Domain.csproj b/backend/src/CollabApp.Domain/CollabApp.Domain.csproj new file mode 100644 index 0000000000000000000000000000000000000000..4f7f13bb73eee5d29a168f13cdf2541f20da31ee --- /dev/null +++ b/backend/src/CollabApp.Domain/CollabApp.Domain.csproj @@ -0,0 +1,14 @@ + + + + net9.0 + enable + enable + + + + + + + + diff --git a/backend/src/CollabApp.Domain/Entities/Auth/User.cs b/backend/src/CollabApp.Domain/Entities/Auth/User.cs new file mode 100644 index 0000000000000000000000000000000000000000..3d3f695f10511d9593c7874a8d45afb074212f06 --- /dev/null +++ b/backend/src/CollabApp.Domain/Entities/Auth/User.cs @@ -0,0 +1,456 @@ +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; +using System.Security.Cryptography; +using System.Text; + +namespace CollabApp.Domain.Entities.Auth; + +/// +/// 用户实体 - 存储用户基本信息和账户状态 +/// 继承BaseEntity，支持软删除功能 +/// +[Table("users")] +public class User : BaseEntity +{ + // ============ 构造函数 ============ + + /// + /// 无参构造函数 - EF Core 要求 + /// + private User() { } + + /// + /// 私有构造函数，仅限工厂方法调用 + /// + /// 用户名 + /// 密码哈希值 + /// 密码盐值 + /// 游戏昵称 + private User(string username, string passwordHash, string passwordSalt, string nickname) + { + Username = username; + PasswordHash = passwordHash; + PasswordSalt = passwordSalt; + Nickname = nickname; + Status = UserStatus.Active; + TokenStatus = TokenStatus.None; + RememberMe = false; + } + + // ============ 基本信息字段 ============ + + /// + /// 用户名 - 登录用，唯一且不可重复 + /// + [Required] + [MaxLength(50)] + [Column("username")] + public string Username { get; private set; } = string.Empty; + + /// + /// 密码哈希值 - 存储经过哈希处理的密码，不存储明文 + /// + [Required] + [MaxLength(255)] + [Column("password_hash")] + public string PasswordHash { get; private set; } = string.Empty; + + /// + /// 密码盐值 - 用于增强密码安全性，防止彩虹表攻击 + /// + [Required] + [MaxLength(255)] + [Column("password_salt")] + public string PasswordSalt { get; private set; } = string.Empty; + + /// + /// 游戏昵称 - 在游戏中显示的名称 + /// + [Required] + [MaxLength(50)] + [Column("nickname")] + public string Nickname { get; private set; } = string.Empty; + + /// + /// 头像URL - 用户头像图片的存储地址 + /// + [MaxLength(255)] + [Column("avatar_url")] + public string? AvatarUrl { get; private set; } + + /// + /// 隐私设置 - JSON格式存储用户的隐私偏好配置 + /// + [Column("privacy_settings", TypeName = "json")] + public string? PrivacySettings { get; private set; } + + /// + /// 最后登录时间 - 记录用户最近一次登录的时间 + /// + [Column("last_login_at")] + public DateTime? LastLoginAt { get; private set; } + + /// + /// 账户状态 - 正常,封禁等状态 + /// + [Column("status")] + public UserStatus Status { get; private set; } = UserStatus.Active; + + // ============ 双Token认证字段 ============ + + /// + /// 访问令牌 - 短期有效的身份验证令牌 + /// 用于API请求的身份验证，通常有效期较短（如15-30分钟） + /// + [MaxLength(512)] + [Column("access_token")] + public string? AccessToken { get; private set; } + + /// + /// 刷新令牌 - 长期有效的令牌，用于刷新访问令牌 + /// 安全性更高，有效期较长（如7-30天），用于获取新的访问令牌 + /// + [MaxLength(512)] + [Column("refresh_token")] + public string? RefreshToken { get; private set; } + + /// + /// 访问令牌过期时间 - AccessToken的有效期 + /// + [Column("access_token_expires_at")] + public DateTime? AccessTokenExpiresAt { get; private set; } + + /// + /// 刷新令牌过期时间 - RefreshToken的有效期 + /// + [Column("refresh_token_expires_at")] + public DateTime? RefreshTokenExpiresAt { get; private set; } + + /// + /// 记住登录状态 - 是否启用长期登录功能 + /// 启用时RefreshToken有效期会延长 + /// + [Column("remember_me")] + public bool RememberMe { get; private set; } = false; + + /// + /// 令牌状态 - 活跃、已吊销、已过期等状态 + /// + [Column("token_status")] + public TokenStatus TokenStatus { get; private set; } = TokenStatus.None; + + /// + /// 最后活跃时间 - 用户最后一次使用令牌的时间 + /// + [Column("last_activity_at")] + public DateTime? LastActivityAt { get; private set; } + + /// + /// 登录设备信息 - JSON格式存储设备类型、IP地址等信息 + /// + [Column("device_info", TypeName = "json")] + public string? DeviceInfo { get; private set; } + + /// + /// 令牌吊销原因 - 令牌被吊销时的原因说明 + /// + [MaxLength(200)] + [Column("token_revoked_reason")] + public string? TokenRevokedReason { get; private set; } + + /// + /// 令牌吊销时间 - 令牌被手动吊销的时间 + /// + [Column("token_revoked_at")] + public DateTime? TokenRevokedAt { get; private set; } + + // ============ 导航属性 ============ + + /// + /// 用户统计信息 - 一对一关系 + /// + public virtual UserStatistics? Statistics { get; set; } + + /// + /// 用户创建的房间列表 - 一对多关系，用户作为房主的房间 + /// + public virtual ICollection OwnedRooms { get; set; } = new List(); + + /// + /// 用户参与的房间记录 - 一对多关系，用户加入过的所有房间 + /// + public virtual ICollection RoomPlayers { get; set; } = new List(); + + /// + /// 用户游戏记录 - 一对多关系，用户参与过的所有游戏 + /// + public virtual ICollection GamePlayers { get; set; } = new List(); + + /// + /// 用户通知列表 - 一对多关系，用户收到的所有通知 + /// + public virtual ICollection Notifications { get; set; } = new List(); + + // ============ 工厂方法 ============ + + /// + /// 创建新用户 - 工厂方法（使用明文密码） + /// + /// 用户名 + /// 明文密码 + /// 游戏昵称 + /// 新用户实例 + public static User Create(string username, string plainPassword, string nickname) + { + if (string.IsNullOrWhiteSpace(username)) + throw new ArgumentException("用户名不能为空", nameof(username)); + if (string.IsNullOrWhiteSpace(plainPassword)) + throw new ArgumentException("密码不能为空", nameof(plainPassword)); + if (string.IsNullOrWhiteSpace(nickname)) + throw new ArgumentException("昵称不能为空", nameof(nickname)); + + var (hash, salt) = CreatePasswordHash(plainPassword); + return new User(username, hash, salt, nickname); + } + + // ============ 业务方法 ============ + + /// + /// 更新用户信息 + /// + /// 新昵称 + /// 头像URL + public void UpdateProfile(string nickname, string? avatarUrl = null) + { + if (string.IsNullOrWhiteSpace(nickname)) + throw new ArgumentException("昵称不能为空", nameof(nickname)); + + Nickname = nickname; + AvatarUrl = avatarUrl; + } + + /// + /// 更新密码 - 使用明文密码，自动生成新的盐值和哈希 + /// + /// 新明文密码 + public void UpdatePassword(string newPassword) + { + if (string.IsNullOrWhiteSpace(newPassword)) + throw new ArgumentException("密码不能为空", nameof(newPassword)); + + var newSalt = GenerateSalt(); + var newHash = HashPassword(newPassword, newSalt); + + PasswordSalt = newSalt; + PasswordHash = newHash; + } + + /// + /// 设置访问令牌 + /// + /// 访问令牌 + /// 刷新令牌 + /// 访问令牌过期时间 + /// 刷新令牌过期时间 + /// 是否记住登录 + /// 设备信息 + public void SetTokens(string accessToken, string refreshToken, DateTime accessExpires, + DateTime refreshExpires, bool rememberMe = false, string? deviceInfo = null) + { + AccessToken = accessToken; + RefreshToken = refreshToken; + AccessTokenExpiresAt = accessExpires; + RefreshTokenExpiresAt = refreshExpires; + RememberMe = rememberMe; + TokenStatus = TokenStatus.Active; + LastActivityAt = DateTime.UtcNow; + LastLoginAt = DateTime.UtcNow; + DeviceInfo = deviceInfo; + } + + /// + /// 刷新访问令牌 + /// + /// 新访问令牌 + /// 新访问令牌过期时间 + public void RefreshAccessToken(string newAccessToken, DateTime newAccessExpires) + { + AccessToken = newAccessToken; + AccessTokenExpiresAt = newAccessExpires; + TokenStatus = TokenStatus.Active; + LastActivityAt = DateTime.UtcNow; + } + + /// + /// 吊销令牌 + /// + /// 吊销原因 + public void RevokeTokens(string? reason = null) + { + AccessToken = null; + RefreshToken = null; + AccessTokenExpiresAt = null; + RefreshTokenExpiresAt = null; + TokenStatus = TokenStatus.Revoked; + TokenRevokedReason = reason; + TokenRevokedAt = DateTime.UtcNow; + } + + /// + /// 更新活跃时间 + /// + public void UpdateActivity() + { + LastActivityAt = DateTime.UtcNow; + } + + /// + /// 封禁用户 + /// + public void Ban() + { + Status = UserStatus.Banned; + RevokeTokens("用户被封禁"); + } + + /// + /// 解封用户 + /// + public void Unban() + { + Status = UserStatus.Active; + } + + // ============ 密码安全方法 ============ + + /// + /// 生成一个随机的密码盐，返回 Base64 字符串 + /// + /// Base64 编码的盐字符串 + private static string GenerateSalt() + { + var bytes = new byte[16]; + using var rng = RandomNumberGenerator.Create(); + rng.GetBytes(bytes); + return Convert.ToBase64String(bytes); + } + + /// + /// 使用 PBKDF2 算法对密码和盐进行加密，返回哈希后的 Base64 字符串 + /// + /// 明文密码 + /// Base64 编码的盐 + /// Base64 编码的哈希密码 + private static string HashPassword(string password, string salt) + { + var saltBytes = Convert.FromBase64String(salt); + using var pbkdf2 = new Rfc2898DeriveBytes(password, saltBytes, 10000, HashAlgorithmName.SHA256); + var hash = pbkdf2.GetBytes(32); // 256位 + return Convert.ToBase64String(hash); + } + + /// + /// 验证密码是否正确 + /// + /// 要验证的密码 + /// 存储的哈希密码 + /// 存储的盐值 + /// 密码是否正确 + public static bool VerifyPassword(string password, string storedHash, string storedSalt) + { + if (string.IsNullOrWhiteSpace(password)) + return false; + if (string.IsNullOrWhiteSpace(storedHash)) + return false; + if (string.IsNullOrWhiteSpace(storedSalt)) + return false; + + try + { + var computedHash = HashPassword(password, storedSalt); + return computedHash.Equals(storedHash, StringComparison.Ordinal); + } + catch + { + // 如果发生任何异常（如盐值格式错误），返回false + return false; + } + } + + /// + /// 验证输入的明文密码是否与当前用户密码一致 + /// + /// 明文密码 + /// 密码是否正确 + public bool VerifyPassword(string plainPassword) + { + if (string.IsNullOrWhiteSpace(plainPassword)) + return false; + + var computedHash = HashPassword(plainPassword, PasswordSalt); + return computedHash.Equals(PasswordHash, StringComparison.Ordinal); + } + + /// + /// 创建用户时生成密码哈希和盐值 - 便捷方法 + /// + /// 原始密码 + /// 包含哈希值和盐值的元组 + public static (string Hash, string Salt) CreatePasswordHash(string password) + { + if (string.IsNullOrWhiteSpace(password)) + throw new ArgumentException("密码不能为空", nameof(password)); + + var salt = GenerateSalt(); + var hash = HashPassword(password, salt); + return (hash, salt); + } + +} + +/// +/// 令牌状态枚举 - 定义用户认证令牌的各种状态 +/// +public enum TokenStatus +{ + /// + /// 无令牌状态 - 用户未登录或令牌已清空 + /// + None, + + /// + /// 活跃状态 - 令牌正常有效 + /// + Active, + + /// + /// 已过期 - 令牌已超过有效期 + /// + Expired, + + /// + /// 已吊销 - 令牌被用户或系统主动撤销 + /// + Revoked, + + /// + /// 需要刷新 - AccessToken过期，需要使用RefreshToken刷新 + /// + NeedsRefresh +} + +/// +/// 用户状态枚举 +/// +public enum UserStatus +{ + /// + /// 正常状态 - 正常可用 + /// + Active, + + /// + /// 封禁状态 - 账户被管理员封禁 + /// + Banned +} diff --git a/backend/src/CollabApp.Domain/Entities/Auth/UserStatistics.cs b/backend/src/CollabApp.Domain/Entities/Auth/UserStatistics.cs new file mode 100644 index 0000000000000000000000000000000000000000..24e8eb098a4412f00752274e1d2e8c6c01eaba18 --- /dev/null +++ b/backend/src/CollabApp.Domain/Entities/Auth/UserStatistics.cs @@ -0,0 +1,184 @@ +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; +using Microsoft.EntityFrameworkCore; + +namespace CollabApp.Domain.Entities.Auth; + +/// +/// 用户统计实体 - 存储用户的游戏数据统计信息 +/// 继承BaseEntity，支持软删除和时间戳功能 +/// +[Table("user_statistics")] +public class UserStatistics : BaseEntity +{ + /// + /// 关联用户ID - 外键，指向Users表，一对一关系 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; private set; } + + /// + /// 总游戏场次 - 用户参与的游戏总数 + /// + [Column("total_games")] + public int TotalGames { get; private set; } = 0; + + /// + /// 胜利次数 - 用户获得第一名的次数 + /// + [Column("wins")] + public int Wins { get; private set; } = 0; + + /// + /// 失败次数 - 用户未获得第一名的次数 + /// + [Column("losses")] + public int Losses { get; private set; } = 0; + + /// + /// 胜率 - 胜利次数占总游戏场次的百分比 + /// + [Column("win_rate")] + [Precision(5, 2)] + public decimal WinRate { get; private set; } = 0; + + /// + /// 总积分 - 用户累计获得的积分（根据排名计算） + /// + [Column("total_score")] + public int TotalScore { get; private set; } = 0; + + /// + /// 最高占领面积 - 用户在单局游戏中的最佳成绩 + /// + [Column("max_area")] + [Precision(10, 2)] + public decimal MaxArea { get; private set; } = 0; + + /// + /// 总游戏时长 - 用户累计游戏时间（秒） + /// + [Column("total_play_time")] + public int TotalPlayTime { get; private set; } = 0; + + /// + /// 当前排名 - 用户在全服排行榜中的位置 + /// + [Column("current_rank")] + public int CurrentRank { get; private set; } = 0; + + /// + /// 历史最高排名 - 用户曾经达到的最高排名 + /// + [Column("highest_rank")] + public int HighestRank { get; private set; } = 0; + + // ============ 构造函数 ============ + + /// + /// 无参构造函数 - EF Core 必需 + /// + private UserStatistics() { } + + /// + /// 私有构造函数 - 仅限工厂方法调用 + /// + /// 关联用户ID + private UserStatistics(Guid userId) + { + UserId = userId; + TotalGames = 0; + Wins = 0; + Losses = 0; + WinRate = 0; + TotalScore = 0; + MaxArea = 0; + TotalPlayTime = 0; + CurrentRank = 0; + HighestRank = 0; + } + + // ============ 导航属性 ============ + + /// + /// 关联的用户实体 - 一对一关系 + /// + [ForeignKey("UserId")] + public virtual User User { get; set; } = null!; + + // ============ 工厂方法 ============ + + /// + /// 创建新的用户统计记录 - 工厂方法 + /// + /// 关联用户ID + /// 新的用户统计实例 + public static UserStatistics CreateForUser(Guid userId) + { + if (userId == Guid.Empty) + throw new ArgumentException("用户ID不能为空", nameof(userId)); + + return new UserStatistics(userId); + } + + // ============ 业务方法 ============ + + /// + /// 更新游戏结果统计 + /// + /// 是否胜利 + /// 本局积分 + /// 本局占领面积 + /// 本局游戏时长（秒） + public void UpdateGameResult(bool isWin, int gameScore, decimal area, int playTimeSeconds) + { + TotalGames++; + if (isWin) + Wins++; + else + Losses++; + + // 重新计算胜率 + WinRate = TotalGames > 0 ? (decimal)Wins / TotalGames * 100 : 0; + + TotalScore += Math.Max(0, gameScore); + TotalPlayTime += Math.Max(0, playTimeSeconds); + + // 更新最高占领面积 + if (area > MaxArea) + MaxArea = area; + } + + /// + /// 更新排名信息 + /// + /// 新排名 + public void UpdateRank(int newRank) + { + if (newRank <= 0) + throw new ArgumentException("排名必须大于0", nameof(newRank)); + + CurrentRank = newRank; + + // 更新历史最高排名（排名数字越小越好） + if (HighestRank == 0 || newRank < HighestRank) + HighestRank = newRank; + } + + /// + /// 重置统计数据 + /// + public void ResetStatistics() + { + TotalGames = 0; + Wins = 0; + Losses = 0; + WinRate = 0; + TotalScore = 0; + MaxArea = 0; + TotalPlayTime = 0; + CurrentRank = 0; + HighestRank = 0; + } +} diff --git a/backend/src/CollabApp.Domain/Entities/BaseEntity.cs b/backend/src/CollabApp.Domain/Entities/BaseEntity.cs new file mode 100644 index 0000000000000000000000000000000000000000..99413c6055846e18ea111a947ffd57e69f4f2464 --- /dev/null +++ b/backend/src/CollabApp.Domain/Entities/BaseEntity.cs @@ -0,0 +1,36 @@ +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; + +namespace CollabApp.Domain.Entities; + +/// +/// 基础实体类 - 包含所有实体的共有属性 +/// 提供统一的主键、时间戳和软删除功能 +/// +public abstract class BaseEntity +{ + /// + /// 实体唯一标识符 - 主键，所有实体的统一标识 + /// + [Key] + public Guid Id { get; set; } = Guid.NewGuid(); + + /// + /// 创建时间 - 实体首次创建的UTC时间 + /// + [Column("created_at")] + public DateTime CreatedAt { get; set; } = DateTime.UtcNow; + + /// + /// 更新时间 - 实体最后一次修改的UTC时间 + /// + [Column("updated_at")] + public DateTime UpdatedAt { get; set; } = DateTime.UtcNow; + + /// + /// 软删除标志 - 标记实体是否被逻辑删除 + /// false: 正常状态, true: 已删除状态 + /// + [Column("is_deleted")] + public bool IsDeleted { get; set; } = false; +} diff --git a/backend/src/CollabApp.Domain/Entities/Game/Game.cs b/backend/src/CollabApp.Domain/Entities/Game/Game.cs new file mode 100644 index 0000000000000000000000000000000000000000..39119a2268ab2b94d5b8dd85a8987aa3f88f30d9 --- /dev/null +++ b/backend/src/CollabApp.Domain/Entities/Game/Game.cs @@ -0,0 +1,378 @@ +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; + +namespace CollabApp.Domain.Entities.Game; + +/// +/// 游戏实体 - 存储单局游戏的基本信息和状态 +/// 继承BaseEntity，支持软删除和时间戳功能 +/// +[Table("games")] +public class Game : BaseEntity +{ + /// + /// 关联房间ID - 外键，指向游戏所在的房间 + /// + [Column("room_id")] + public Guid RoomId { get; private set; } + + /// + /// 游戏模式 - 经典模式、极速模式、道具狂欢、生存模式、团队模式 + /// + [Column("game_mode")] + public string GameMode { get; private set; } = "classic"; + + /// + /// 地图宽度 - 游戏区域的像素宽度（圆形地图的直径） + /// + [Column("map_width")] + public int MapWidth { get; private set; } = 1000; + + /// + /// 地图高度 - 游戏区域的像素高度（圆形地图的直径） + /// + [Column("map_height")] + public int MapHeight { get; private set; } = 1000; + + /// + /// 游戏时长 - 单局游戏的持续时间（秒） + /// + [Column("duration")] + public int Duration { get; private set; } = 180; + + /// + /// 地图类型 - 圆形、方形等地图形状 + /// + [Column("map_shape")] + public string MapShape { get; private set; } = "circle"; + + /// + /// 道具刷新间隔（秒） + /// + [Column("powerup_spawn_interval")] + public int PowerUpSpawnInterval { get; private set; } = 25; + + /// + /// 最大同时存在道具数量 + /// + [Column("max_powerups")] + public int MaxPowerUps { get; private set; } = 3; + + /// + /// 特殊事件概率（百分比） + /// + [Column("special_event_chance")] + public int SpecialEventChance { get; private set; } = 0; + + /// + /// 是否启用动态平衡机制 + /// + [Column("enable_dynamic_balance")] + public bool EnableDynamicBalance { get; private set; } = true; + + /// + /// 游戏状态 - 准备中、进行中、暂停、已结束 + /// + [Column("status")] + public GameStatus Status { get; private set; } = GameStatus.Preparing; + + /// + /// 获胜者用户ID - 外键，指向获胜的用户，可为空 + /// + [Column("winner_id")] + public Guid? WinnerId { get; private set; } + + /// + /// 游戏开始时间 - 实际游戏开始的时间戳 + /// + [Column("started_at")] + public DateTime? StartedAt { get; private set; } + + /// + /// 游戏结束时间 - 游戏完成或终止的时间戳 + /// + [Column("finished_at")] + public DateTime? FinishedAt { get; private set; } + + /// + /// 游戏数据快照 - JSON格式存储游戏结束时的状态数据 + /// + [Column("game_data", TypeName = "json")] + public string? GameData { get; private set; } + + // ============ 构造函数 ============ + + /// + /// 无参构造函数 - EF Core 必需 + /// + private Game() { } + + /// + /// 私有构造函数 - 仅限工厂方法调用 + /// + /// 房间ID + /// 游戏模式 + /// 地图宽度 + /// 地图高度 + /// 游戏时长 + /// 地图形状 + private Game(Guid roomId, string gameMode = "classic", int mapWidth = 1000, + int mapHeight = 1000, int duration = 180, string mapShape = "circle") + { + RoomId = roomId; + GameMode = gameMode; + MapWidth = mapWidth; + MapHeight = mapHeight; + Duration = duration; + MapShape = mapShape; + Status = GameStatus.Preparing; + PowerUpSpawnInterval = gameMode == "powerup_carnival" ? 8 : 25; + MaxPowerUps = gameMode == "powerup_carnival" ? 9 : 3; + SpecialEventChance = gameMode == "powerup_carnival" ? 10 : 0; + EnableDynamicBalance = true; + } + + // ============ 导航属性 ============ + + /// + /// 关联的房间实体 - 多对一关系 + /// + [ForeignKey("RoomId")] + public virtual Room.Room Room { get; set; } = null!; + + /// + /// 获胜用户实体 - 多对一关系，可为空 + /// + [ForeignKey("WinnerId")] + public virtual Auth.User? Winner { get; set; } + + /// + /// 游戏参与玩家列表 - 一对多关系 + /// + public virtual ICollection Players { get; set; } = new List(); + + /// + /// 游戏操作记录列表 - 一对多关系，用于游戏回放 + /// + public virtual ICollection Actions { get; set; } = new List(); + + // ============ 工厂方法 ============ + + /// + /// 创建新游戏 - 工厂方法 + /// + /// 房间ID + /// 游戏模式 + /// 地图宽度 + /// 地图高度 + /// 游戏时长 + /// 地图形状 + /// 新游戏实例 + public static Game CreateGame(Guid roomId, string gameMode = "classic", + int mapWidth = 1000, int mapHeight = 1000, int duration = 180, string mapShape = "circle") + { + if (roomId == Guid.Empty) + throw new ArgumentException("房间ID不能为空", nameof(roomId)); + if (string.IsNullOrWhiteSpace(gameMode)) + throw new ArgumentException("游戏模式不能为空", nameof(gameMode)); + if (mapWidth <= 0 || mapWidth > 5000) + throw new ArgumentException("地图宽度必须在1-5000之间", nameof(mapWidth)); + if (mapHeight <= 0 || mapHeight > 5000) + throw new ArgumentException("地图高度必须在1-5000之间", nameof(mapHeight)); + if (duration <= 0 || duration > 3600) + throw new ArgumentException("游戏时长必须在1-3600秒之间", nameof(duration)); + + return new Game(roomId, gameMode, mapWidth, mapHeight, duration, mapShape); + } + + // ============ 业务方法 ============ + + /// + /// 开始游戏 + /// + public void StartGame() + { + if (Status != GameStatus.Preparing) + throw new InvalidOperationException("只能在准备状态下开始游戏"); + + Status = GameStatus.Playing; + StartedAt = DateTime.UtcNow; + } + + /// + /// 结束游戏 + /// + /// 获胜者ID + /// 游戏数据快照 + public void FinishGame(Guid? winnerId = null, string? gameData = null) + { + if (Status != GameStatus.Playing) + throw new InvalidOperationException("只能在游戏进行状态下结束游戏"); + + Status = GameStatus.Finished; + FinishedAt = DateTime.UtcNow; + WinnerId = winnerId; + GameData = gameData; + } + + /// + /// 更新游戏数据 + /// + /// 游戏数据JSON + public void UpdateGameData(string gameData) + { + GameData = gameData; + } + + /// + /// 获取游戏总时长 + /// + /// 实际游戏时长（秒） + public int? GetActualDuration() + { + if (StartedAt == null) return null; + if (FinishedAt == null && Status == GameStatus.Playing) + return (int)(DateTime.UtcNow - StartedAt.Value).TotalSeconds; + if (FinishedAt != null) + return (int)(FinishedAt.Value - StartedAt.Value).TotalSeconds; + return null; + } + + /// + /// 检查游戏是否超时 + /// + /// 是否超时 + public bool IsTimedOut() + { + if (Status != GameStatus.Playing || StartedAt == null) + return false; + + return (DateTime.UtcNow - StartedAt.Value).TotalSeconds > Duration; + } + + /// + /// 获取剩余时间（秒） + /// + /// 剩余时间，如果游戏未开始返回null + public int? GetRemainingTime() + { + if (Status != GameStatus.Playing || StartedAt == null) + return null; + + var elapsed = (DateTime.UtcNow - StartedAt.Value).TotalSeconds; + var remaining = Duration - elapsed; + return remaining > 0 ? (int)remaining : 0; + } + + /// + /// 检查是否为大逃杀缩圈阶段（最后30秒） + /// + /// 是否为缩圈阶段 + public bool IsInShrinkingPhase() + { + var remaining = GetRemainingTime(); + return remaining.HasValue && remaining.Value <= 30; + } + + /// + /// 根据玩家数量调整地图大小 + /// + /// 玩家数量 + public void AdjustMapSizeForPlayers(int playerCount) + { + if (playerCount <= 0) return; + + if (playerCount <= 4) + { + MapWidth = MapHeight = 800; + } + else if (playerCount <= 6) + { + MapWidth = MapHeight = 1000; + } + else + { + MapWidth = MapHeight = 1200; + } + } + + /// + /// 检查是否允许提前结束（单一玩家占领70%地图） + /// + /// 最大玩家占地百分比 + /// 是否允许提前结束 + public bool CanEndEarly(decimal maxPlayerAreaPercentage) + { + return Status == GameStatus.Playing && maxPlayerAreaPercentage >= 70m; + } + + /// + /// 获取适合当前模式的配置 + /// + /// 游戏配置信息 + public GameModeConfig GetGameModeConfig() + { + return GameMode.ToLower() switch + { + "speed" => new GameModeConfig + { + SpeedMultiplier = 1.5m, + Description = "极速模式：移动速度+50%，90秒快速对战" + }, + "powerup_carnival" => new GameModeConfig + { + PowerUpSpawnRate = 3, + PowerUpEffectMultiplier = 1.5m, + Description = "道具狂欢：道具刷新频率×3，效果时间×1.5" + }, + "survival" => new GameModeConfig + { + MaxLives = 1, + Description = "生存模式：只有一条命，死亡即出局" + }, + "team" => new GameModeConfig + { + AllowTeamTerritory = true, + Description = "团队模式：队友领地可以连通" + }, + _ => new GameModeConfig + { + Description = "经典模式：标准规则，适合所有玩家" + } + }; + } +} + +/// +/// 游戏模式配置 +/// +public class GameModeConfig +{ + public decimal SpeedMultiplier { get; set; } = 1.0m; + public int PowerUpSpawnRate { get; set; } = 1; + public decimal PowerUpEffectMultiplier { get; set; } = 1.0m; + public int MaxLives { get; set; } = int.MaxValue; + public bool AllowTeamTerritory { get; set; } = false; + public string Description { get; set; } = string.Empty; +} + +/// +/// 游戏状态枚举 +/// +public enum GameStatus +{ + /// + /// 准备中 - 游戏已创建但尚未开始 + /// + Preparing, + + /// + /// 进行中 - 游戏正在进行 + /// + Playing, + + /// + /// 已结束 - 游戏已完成 + /// + Finished +} diff --git a/backend/src/CollabApp.Domain/Entities/Game/GameAction.cs b/backend/src/CollabApp.Domain/Entities/Game/GameAction.cs new file mode 100644 index 0000000000000000000000000000000000000000..8129f73f280f1b2a4405ee8fbf050a267d7033ce --- /dev/null +++ b/backend/src/CollabApp.Domain/Entities/Game/GameAction.cs @@ -0,0 +1,161 @@ +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; + +namespace CollabApp.Domain.Entities.Game; + +/// +/// 游戏操作记录实体类 - 记录游戏过程中的所有玩家操作 +/// 用于游戏回放、作弊检测、数据分析等功能 +/// +[Table("game_actions")] +public class GameAction : BaseEntity +{ + /// + /// 游戏ID - 关联到具体的游戏实例 + /// + [Required] + [Column("game_id")] + public Guid GameId { get; private set; } + + /// + /// 用户ID - 执行操作的用户标识 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; private set; } + + /// + /// 操作类型 - 玩家执行的操作种类 + /// 例如：Move(移动)、Attack(攻击)、Defend(防御)、Special(特殊技能)等 + /// + [Required] + [MaxLength(50)] + [Column("action_type")] + public string ActionType { get; private set; } = string.Empty; + + /// + /// 操作数据 - 操作的详细参数和状态信息 + /// JSON格式存储，包含坐标、方向、力度等具体操作参数 + /// + [Required] + [Column("action_data", TypeName = "json")] + public string ActionData { get; private set; } = string.Empty; + + /// + /// 时间戳 - 操作发生的精确时间（毫秒级） + /// 用于游戏回放时的精确时序控制 + /// + [Column("timestamp")] + public long Timestamp { get; private set; } + + // ============ 构造函数 ============ + + /// + /// 无参构造函数 - EF Core 必需 + /// + private GameAction() { } + + /// + /// 私有构造函数 - 仅限工厂方法调用 + /// + /// 游戏ID + /// 用户ID + /// 操作类型 + /// 操作数据 + /// 时间戳 + private GameAction(Guid gameId, Guid userId, string actionType, string actionData, long timestamp) + { + GameId = gameId; + UserId = userId; + ActionType = actionType; + ActionData = actionData; + Timestamp = timestamp; + } + + // ============ 导航属性 ============ + + /// + /// 导航属性 - 关联的游戏实例 + /// + [ForeignKey("GameId")] + public virtual Game Game { get; set; } = null!; + + /// + /// 导航属性 - 执行操作的用户 + /// + [ForeignKey("UserId")] + public virtual Auth.User User { get; set; } = null!; + + // ============ 工厂方法 ============ + + /// + /// 创建游戏操作记录 - 工厂方法 + /// + /// 游戏ID + /// 用户ID + /// 操作类型 + /// 操作数据 + /// 时间戳（可选，默认为当前时间） + /// 新的游戏操作记录实例 + public static GameAction CreateGameAction(Guid gameId, Guid userId, string actionType, + string actionData, long? timestamp = null) + { + if (gameId == Guid.Empty) + throw new ArgumentException("游戏ID不能为空", nameof(gameId)); + if (userId == Guid.Empty) + throw new ArgumentException("用户ID不能为空", nameof(userId)); + if (string.IsNullOrWhiteSpace(actionType)) + throw new ArgumentException("操作类型不能为空", nameof(actionType)); + if (string.IsNullOrWhiteSpace(actionData)) + throw new ArgumentException("操作数据不能为空", nameof(actionData)); + + var actionTimestamp = timestamp ?? DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(); + return new GameAction(gameId, userId, actionType, actionData, actionTimestamp); + } + + // ============ 业务方法 ============ + + /// + /// 获取操作发生的DateTime时间 + /// + /// 操作时间 + public DateTime GetActionDateTime() + { + return DateTimeOffset.FromUnixTimeMilliseconds(Timestamp).DateTime; + } + + /// + /// 验证操作类型是否有效 + /// + /// 是否为有效的操作类型 + public bool IsValidActionType() + { + var validTypes = new[] + { + "Move", "StartDraw", "Draw", "EndDraw", "PickupPowerUp", "UsePowerUp", + "Die", "Respawn", "TerritoryCapture", "CollisionDetected", "SpecialEvent" + }; + return validTypes.Contains(ActionType, StringComparer.OrdinalIgnoreCase); + } + + /// + /// 获取操作相对于游戏开始的时间偏移（毫秒） + /// + /// 游戏开始时间戳 + /// 时间偏移量 + public long GetRelativeTimestamp(long gameStartTimestamp) + { + return Timestamp - gameStartTimestamp; + } + + /// + /// 检查操作是否在指定时间范围内 + /// + /// 开始时间戳 + /// 结束时间戳 + /// 是否在范围内 + public bool IsWithinTimeRange(long startTimestamp, long endTimestamp) + { + return Timestamp >= startTimestamp && Timestamp <= endTimestamp; + } +} diff --git a/backend/src/CollabApp.Domain/Entities/Game/GamePlayer.cs b/backend/src/CollabApp.Domain/Entities/Game/GamePlayer.cs new file mode 100644 index 0000000000000000000000000000000000000000..cf0b34efb80d7649a48fefc94884bcb9524f82f6 --- /dev/null +++ b/backend/src/CollabApp.Domain/Entities/Game/GamePlayer.cs @@ -0,0 +1,426 @@ +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; +using Microsoft.EntityFrameworkCore; + +namespace CollabApp.Domain.Entities.Game; + +/// +/// 游戏玩家实体类 - 记录单个玩家在特定游戏中的表现和统计数据 +/// 用于存储玩家的游戏过程数据、最终成绩、排名等信息 +/// +[Table("game_players")] +public class GamePlayer : BaseEntity +{ + /// + /// 游戏ID - 关联到具体的游戏实例 + /// + [Required] + [Column("game_id")] + public Guid GameId { get; private set; } + + /// + /// 用户ID - 关联到参与游戏的用户 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; private set; } + + /// + /// 玩家颜色 - 在游戏中代表该玩家的颜色标识 + /// 格式：十六进制颜色值，例如 "#FF0000" + /// + [Required] + [MaxLength(7)] + [Column("player_color")] + public string PlayerColor { get; private set; } = string.Empty; + + /// + /// 最终占地面积 - 游戏结束时玩家占据的总面积 + /// 用于计算排名和积分，精确到小数点后2位 + /// + [Column("final_area")] + [Precision(10, 2)] + public decimal FinalArea { get; private set; } = 0; + + /// + /// 最终排名 - 玩家在该局游戏中的最终名次 + /// 数值越小排名越高，null表示未完成游戏 + /// + [Column("final_rank")] + public int? FinalRank { get; private set; } + + /// + /// 积分变化 - 本局游戏对玩家总积分的影响 + /// 正数表示积分增加，负数表示积分减少 + /// + [Column("score_change")] + public int ScoreChange { get; private set; } = 0; + + /// + /// 操作次数 - 玩家在游戏过程中执行的操作总数 + /// 用于统计玩家活跃度和游戏参与度 + /// + [Column("actions_count")] + public int ActionsCount { get; private set; } = 0; + + /// + /// 游戏时长 - 玩家在该局游戏中的实际参与时间（秒） + /// 用于统计玩家的游戏投入度和活跃时间 + /// + [Column("play_time")] + public int PlayTime { get; private set; } = 0; + + /// + /// 玩家出生点X坐标 + /// + [Column("spawn_x")] + public float SpawnX { get; private set; } = 0f; + + /// + /// 玩家出生点Y坐标 + /// + [Column("spawn_y")] + public float SpawnY { get; private set; } = 0f; + + /// + /// 当前位置X坐标 + /// + [Column("position_x")] + public float PositionX { get; private set; } = 0f; + + /// + /// 当前位置Y坐标 + /// + [Column("position_y")] + public float PositionY { get; private set; } = 0f; + + /// + /// 玩家状态 - Alive(存活)、Dead(死亡)、Respawning(复活中) + /// + [Column("status")] + public PlayerStatus Status { get; private set; } = PlayerStatus.Alive; + + /// + /// 死亡次数 + /// + [Column("death_count")] + public int DeathCount { get; private set; } = 0; + + /// + /// 击杀数量（截断其他玩家次数） + /// + [Column("kill_count")] + public int KillCount { get; private set; } = 0; + + /// + /// 最大历史领地面积 + /// + [Column("max_territory_area")] + [Precision(10, 2)] + public decimal MaxTerritoryArea { get; private set; } = 0; + + /// + /// 当前持有的道具类型 + /// + [Column("current_powerup")] + public string? CurrentPowerUp { get; private set; } + + /// + /// 道具使用次数 + /// + [Column("powerup_usage_count")] + public int PowerUpUsageCount { get; private set; } = 0; + + /// + /// 复活时间戳（用于计算无敌时间） + /// + [Column("respawn_timestamp")] + public long? RespawnTimestamp { get; private set; } + + /// + /// 团队ID（团队模式使用） + /// + [Column("team_id")] + public int? TeamId { get; private set; } + + // ============ 构造函数 ============ + + /// + /// 无参构造函数 - EF Core 必需 + /// + private GamePlayer() { } + + /// + /// 私有构造函数 - 仅限工厂方法调用 + /// + /// 游戏ID + /// 用户ID + /// 玩家颜色 + private GamePlayer(Guid gameId, Guid userId, string playerColor) + { + GameId = gameId; + UserId = userId; + PlayerColor = playerColor; + FinalArea = 0; + FinalRank = null; + ScoreChange = 0; + ActionsCount = 0; + PlayTime = 0; + } + + // ============ 导航属性 ============ + + /// + /// 导航属性 - 关联的游戏实例 + /// + [ForeignKey("GameId")] + public virtual Game Game { get; set; } = null!; + + /// + /// 导航属性 - 关联的用户信息 + /// + [ForeignKey("UserId")] + public virtual Auth.User User { get; set; } = null!; + + // ============ 工厂方法 ============ + + /// + /// 创建游戏玩家记录 - 工厂方法 + /// + /// 游戏ID + /// 用户ID + /// 玩家颜色 + /// 出生点X坐标 + /// 出生点Y坐标 + /// 团队ID（可选） + /// 新的游戏玩家实例 + public static GamePlayer CreateGamePlayer(Guid gameId, Guid userId, string playerColor, + float spawnX = 0f, float spawnY = 0f, int? teamId = null) + { + if (gameId == Guid.Empty) + throw new ArgumentException("游戏ID不能为空", nameof(gameId)); + if (userId == Guid.Empty) + throw new ArgumentException("用户ID不能为空", nameof(userId)); + if (string.IsNullOrWhiteSpace(playerColor)) + throw new ArgumentException("玩家颜色不能为空", nameof(playerColor)); + + var player = new GamePlayer(gameId, userId, playerColor); + player.SetSpawnPoint(spawnX, spawnY); + player.TeamId = teamId; + return player; + } + + // ============ 业务方法 ============ + + /// + /// 更新游戏结果 + /// + /// 最终占地面积 + /// 最终排名 + /// 积分变化 + /// 游戏时长 + public void UpdateGameResult(decimal finalArea, int finalRank, int scoreChange, int playTime) + { + if (finalArea < 0) + throw new ArgumentException("占地面积不能为负数", nameof(finalArea)); + if (finalRank <= 0) + throw new ArgumentException("排名必须大于0", nameof(finalRank)); + + FinalArea = finalArea; + FinalRank = finalRank; + ScoreChange = scoreChange; + PlayTime = Math.Max(0, playTime); + } + + /// + /// 增加操作次数 + /// + /// 增加的次数 + public void IncrementActions(int count = 1) + { + ActionsCount += Math.Max(0, count); + } + + /// + /// 检查是否为获胜者 + /// + /// 是否为第一名 + public bool IsWinner() => FinalRank == 1; + + /// + /// 获取积分变化类型 + /// + /// 积分变化描述 + public string GetScoreChangeType() + { + return ScoreChange switch + { + > 0 => "积分增加", + < 0 => "积分减少", + _ => "积分无变化" + }; + } + + /// + /// 设置出生点 + /// + /// X坐标 + /// Y坐标 + public void SetSpawnPoint(float x, float y) + { + SpawnX = x; + SpawnY = y; + PositionX = x; + PositionY = y; + } + + /// + /// 更新玩家位置 + /// + /// 新X坐标 + /// 新Y坐标 + public void UpdatePosition(float x, float y) + { + if (Status != PlayerStatus.Alive) return; + PositionX = x; + PositionY = y; + } + + /// + /// 玩家死亡 + /// + /// 死亡时间戳 + public void Die(long? timestamp = null) + { + Status = PlayerStatus.Dead; + DeathCount++; + CurrentPowerUp = null; + + // 保留20%的最大历史领地面积作为"领地记忆"积分 + if (FinalArea > MaxTerritoryArea) + { + MaxTerritoryArea = FinalArea; + } + FinalArea = MaxTerritoryArea * 0.2m; + } + + /// + /// 开始复活 + /// + /// 复活开始时间戳 + public void StartRespawn(long? timestamp = null) + { + Status = PlayerStatus.Respawning; + RespawnTimestamp = timestamp ?? DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(); + PositionX = SpawnX; + PositionY = SpawnY; + } + + /// + /// 复活完成 + /// + public void CompleteRespawn() + { + Status = PlayerStatus.Alive; + RespawnTimestamp = null; + } + + /// + /// 击杀其他玩家 + /// + public void RecordKill() + { + KillCount++; + } + + /// + /// 拾取道具 + /// + /// 道具类型 + public void PickUpPowerUp(string powerUpType) + { + if (string.IsNullOrWhiteSpace(powerUpType)) return; + CurrentPowerUp = powerUpType; + } + + /// + /// 使用道具 + /// + public void UsePowerUp() + { + if (CurrentPowerUp != null) + { + PowerUpUsageCount++; + CurrentPowerUp = null; + } + } + + /// + /// 检查是否处于无敌状态 + /// + /// 是否无敌 + public bool IsInvincible() + { + if (Status != PlayerStatus.Alive || RespawnTimestamp == null) + return false; + + var elapsed = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() - RespawnTimestamp.Value; + return elapsed < 5000; // 5秒无敌时间 + } + + /// + /// 检查是否完全无敌（前3秒） + /// + /// 是否完全无敌 + public bool IsFullyInvincible() + { + if (Status != PlayerStatus.Alive || RespawnTimestamp == null) + return false; + + var elapsed = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() - RespawnTimestamp.Value; + return elapsed < 3000; // 前3秒完全无敌 + } + + /// + /// 获取KD比率 + /// + /// 击杀死亡比 + public decimal GetKDRatio() + { + return DeathCount == 0 ? KillCount : (decimal)KillCount / DeathCount; + } + + /// + /// 更新领地面积 + /// + /// 新的领地面积 + public void UpdateTerritoryArea(decimal area) + { + FinalArea = Math.Max(0, area); + if (FinalArea > MaxTerritoryArea) + { + MaxTerritoryArea = FinalArea; + } + } +} + +/// +/// 玩家状态枚举 +/// +public enum PlayerStatus +{ + /// + /// 存活状态 + /// + Alive, + + /// + /// 死亡状态 + /// + Dead, + + /// + /// 复活中状态 + /// + Respawning +} diff --git a/backend/src/CollabApp.Domain/Entities/Notification.cs b/backend/src/CollabApp.Domain/Entities/Notification.cs new file mode 100644 index 0000000000000000000000000000000000000000..0373e2078cca6106eea67f3cfc7960ad5ab84198 --- /dev/null +++ b/backend/src/CollabApp.Domain/Entities/Notification.cs @@ -0,0 +1,196 @@ +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; + +namespace CollabApp.Domain.Entities; + +/// +/// 通知实体类 - 存储发送给用户的各种系统通知和消息 +/// 支持多种通知类型和状态管理 +/// +[Table("notifications")] +public class Notification : BaseEntity +{ + /// + /// 用户ID - 接收通知的用户 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; private set; } + + /// + /// 通知类型 - 通知的分类和用途 + /// + [Required] + [Column("notification_type")] + public NotificationType NotificationType { get; private set; } + + /// + /// 通知标题 - 通知的主题或标题 + /// + [Required] + [MaxLength(100)] + [Column("title")] + public string Title { get; private set; } = string.Empty; + + /// + /// 通知内容 - 通知的详细内容或描述 + /// + [Required] + [MaxLength(500)] + [Column("content")] + public string Content { get; private set; } = string.Empty; + + /// + /// 是否已读 - 标记用户是否已经查看该通知 + /// + [Column("is_read")] + public bool IsRead { get; private set; } = false; + + /// + /// 相关数据 - 通知相关的额外数据，JSON格式存储 + /// 例如：游戏ID、房间ID、用户ID等相关联的信息 + /// + [Column("data", TypeName = "json")] + public string? Data { get; private set; } + + /// + /// 阅读时间 - 用户查看通知的时间 + /// + [Column("read_at")] + public DateTime? ReadAt { get; private set; } + + // ============ 构造函数 ============ + + /// + /// 无参构造函数 - EF Core 必需 + /// + private Notification() { } + + /// + /// 私有构造函数 - 仅限工厂方法调用 + /// + /// 用户ID + /// 通知类型 + /// 通知标题 + /// 通知内容 + /// 相关数据 + private Notification(Guid userId, NotificationType notificationType, string title, string content, string? data = null) + { + UserId = userId; + NotificationType = notificationType; + Title = title; + Content = content; + IsRead = false; + Data = data; + ReadAt = null; + } + + // ============ 导航属性 ============ + + /// + /// 导航属性 - 接收通知的用户 + /// + [ForeignKey("UserId")] + public virtual Auth.User User { get; set; } = null!; + + // ============ 工厂方法 ============ + + /// + /// 创建新通知 - 工厂方法 + /// + /// 用户ID + /// 通知类型 + /// 通知标题 + /// 通知内容 + /// 相关数据 + /// 新通知实例 + public static Notification CreateNotification(Guid userId, NotificationType notificationType, + string title, string content, string? data = null) + { + if (userId == Guid.Empty) + throw new ArgumentException("用户ID不能为空", nameof(userId)); + if (string.IsNullOrWhiteSpace(title)) + throw new ArgumentException("通知标题不能为空", nameof(title)); + if (string.IsNullOrWhiteSpace(content)) + throw new ArgumentException("通知内容不能为空", nameof(content)); + + return new Notification(userId, notificationType, title, content, data); + } + + // ============ 业务方法 ============ + + /// + /// 标记为已读 + /// + public void MarkAsRead() + { + if (!IsRead) + { + IsRead = true; + ReadAt = DateTime.UtcNow; + } + } + + /// + /// 标记为未读 + /// + public void MarkAsUnread() + { + if (IsRead) + { + IsRead = false; + ReadAt = null; + } + } + + /// + /// 检查通知是否过期（创建超过30天） + /// + /// 是否过期 + public bool IsExpired() + { + return (DateTime.UtcNow - CreatedAt).TotalDays > 30; + } + + /// + /// 获取通知类型的显示名称 + /// + /// 类型名称 + public string GetNotificationTypeName() + { + return NotificationType switch + { + NotificationType.System => "系统通知", + NotificationType.RankingChange => "排名变化", + NotificationType.Achievement => "成就解锁", + NotificationType.GameResult => "游戏结果", + _ => "未知类型" + }; + } +} + +/// +/// 通知类型枚举 - 定义不同种类的系统通知 +/// +public enum NotificationType +{ + /// + /// 系统通知 - 来自系统的重要消息 + /// + System, + + /// + /// 排名变化 - 用户排名发生变化的通知 + /// + RankingChange, + + /// + /// 成就解锁 - 获得新成就的通知 + /// + Achievement, + + /// + /// 游戏结果 - 游戏结束后的结果通知 + /// + GameResult +} diff --git a/backend/src/CollabApp.Domain/Entities/Ranking.cs b/backend/src/CollabApp.Domain/Entities/Ranking.cs new file mode 100644 index 0000000000000000000000000000000000000000..32961033a388fb6ac1e022be030fc3a3e0ae5c91 --- /dev/null +++ b/backend/src/CollabApp.Domain/Entities/Ranking.cs @@ -0,0 +1,252 @@ +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; + +namespace CollabApp.Domain.Entities; + +/// +/// 排行榜实体类 - 存储各种类型的玩家排名数据 +/// 支持不同时间周期和排名类型的排行榜统计 +/// +[Table("rankings")] +public class Ranking : BaseEntity +{ + /// + /// 用户ID - 排行榜中的用户标识 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; private set; } + + /// + /// 排行榜类型 - 排名的计算依据 + /// 例如：总积分、周积分、月积分、胜率等 + /// + [Required] + [Column("ranking_type")] + public RankingType RankingType { get; private set; } + + /// + /// 当前排名 - 用户在该排行榜中的位次 + /// 数值越小排名越高，1为第一名 + /// + [Column("current_rank")] + public int CurrentRank { get; private set; } + + /// + /// 分数 - 用于排名计算的分数值 + /// 具体含义根据排行榜类型而定 + /// + [Column("score")] + public int Score { get; private set; } + + /// + /// 统计周期开始时间 - 该排行榜统计的起始时间 + /// + [Column("period_start")] + public DateTime PeriodStart { get; private set; } + + /// + /// 统计周期结束时间 - 该排行榜统计的结束时间 + /// + [Column("period_end")] + public DateTime PeriodEnd { get; private set; } + + // ============ 构造函数 ============ + + /// + /// 无参构造函数 - EF Core 必需 + /// + private Ranking() { } + + /// + /// 私有构造函数 - 仅限工厂方法调用 + /// + /// 用户ID + /// 排行榜类型 + /// 当前排名 + /// 分数 + /// 统计周期开始时间 + /// 统计周期结束时间 + private Ranking(Guid userId, RankingType rankingType, int currentRank, int score, + DateTime periodStart, DateTime periodEnd) + { + UserId = userId; + RankingType = rankingType; + CurrentRank = currentRank; + Score = score; + PeriodStart = periodStart; + PeriodEnd = periodEnd; + } + + // ============ 导航属性 ============ + + /// + /// 导航属性 - 关联的用户信息 + /// + [ForeignKey("UserId")] + public virtual Auth.User User { get; set; } = null!; + + // ============ 工厂方法 ============ + + /// + /// 创建排行榜记录 - 工厂方法 + /// + /// 用户ID + /// 排行榜类型 + /// 当前排名 + /// 分数 + /// 统计周期开始时间 + /// 统计周期结束时间 + /// 新的排行榜记录实例 + public static Ranking CreateRanking(Guid userId, RankingType rankingType, int currentRank, + int score, DateTime periodStart, DateTime periodEnd) + { + if (userId == Guid.Empty) + throw new ArgumentException("用户ID不能为空", nameof(userId)); + if (currentRank <= 0) + throw new ArgumentException("排名必须大于0", nameof(currentRank)); + if (score < 0) + throw new ArgumentException("分数不能为负数", nameof(score)); + if (periodStart >= periodEnd) + throw new ArgumentException("统计周期开始时间必须早于结束时间"); + + return new Ranking(userId, rankingType, currentRank, score, periodStart, periodEnd); + } + + /// + /// 创建当前周期排行榜记录 - 工厂方法 + /// + /// 用户ID + /// 排行榜类型 + /// 当前排名 + /// 分数 + /// 新的排行榜记录实例 + public static Ranking CreateCurrentPeriodRanking(Guid userId, RankingType rankingType, + int currentRank, int score) + { + var (periodStart, periodEnd) = GetCurrentPeriod(rankingType); + return CreateRanking(userId, rankingType, currentRank, score, periodStart, periodEnd); + } + + // ============ 业务方法 ============ + + /// + /// 更新排名和分数 + /// + /// 新排名 + /// 新分数 + public void UpdateRanking(int newRank, int newScore) + { + if (newRank <= 0) + throw new ArgumentException("排名必须大于0", nameof(newRank)); + if (newScore < 0) + throw new ArgumentException("分数不能为负数", nameof(newScore)); + + CurrentRank = newRank; + Score = newScore; + } + + /// + /// 检查排行榜是否在当前统计周期内 + /// + /// 是否为当前周期 + public bool IsCurrentPeriod() + { + var now = DateTime.UtcNow; + return now >= PeriodStart && now <= PeriodEnd; + } + + /// + /// 获取排行榜类型显示名称 + /// + /// 类型名称 + public string GetRankingTypeName() + { + return RankingType switch + { + RankingType.TotalScore => "总积分排行榜", + RankingType.WeeklyScore => "周积分排行榜", + RankingType.MonthlyScore => "月积分排行榜", + RankingType.WinRate => "胜率排行榜", + RankingType.Activity => "活跃度排行榜", + _ => "未知排行榜" + }; + } + + /// + /// 获取指定排行榜类型的当前统计周期 + /// + /// 排行榜类型 + /// 统计周期的开始和结束时间 + private static (DateTime Start, DateTime End) GetCurrentPeriod(RankingType rankingType) + { + var now = DateTime.UtcNow; + + return rankingType switch + { + RankingType.WeeklyScore => GetWeeklyPeriod(now), + RankingType.MonthlyScore => GetMonthlyPeriod(now), + RankingType.TotalScore or RankingType.WinRate or RankingType.Activity => + (DateTime.MinValue, DateTime.MaxValue), + _ => throw new ArgumentException($"不支持的排行榜类型: {rankingType}") + }; + } + + /// + /// 获取周排行榜的统计周期（周一到周日） + /// + /// 基准日期 + /// 周期开始和结束时间 + private static (DateTime Start, DateTime End) GetWeeklyPeriod(DateTime date) + { + var dayOfWeek = (int)date.DayOfWeek; + var monday = date.AddDays(-(dayOfWeek == 0 ? 6 : dayOfWeek - 1)).Date; + var sunday = monday.AddDays(6).Date.AddDays(1).AddTicks(-1); + + return (monday, sunday); + } + + /// + /// 获取月排行榜的统计周期 + /// + /// 基准日期 + /// 周期开始和结束时间 + private static (DateTime Start, DateTime End) GetMonthlyPeriod(DateTime date) + { + var firstDay = new DateTime(date.Year, date.Month, 1); + var lastDay = firstDay.AddMonths(1).AddTicks(-1); + + return (firstDay, lastDay); + } +} + +/// +/// 排行榜类型枚举 - 定义不同的排名计算方式 +/// +public enum RankingType +{ + /// + /// 总积分排行榜 - 基于用户历史总积分 + /// + TotalScore, + + /// + /// 周积分排行榜 - 基于当周获得的积分 + /// + WeeklyScore, + + /// + /// 月积分排行榜 - 基于当月获得的积分 + /// + MonthlyScore, + + /// + /// 胜率排行榜 - 基于游戏胜率统计 + /// + WinRate, + + /// + /// 活跃度排行榜 - 基于游戏参与度 + /// + Activity +} diff --git a/backend/src/CollabApp.Domain/Entities/RankingHistory.cs b/backend/src/CollabApp.Domain/Entities/RankingHistory.cs new file mode 100644 index 0000000000000000000000000000000000000000..5ffd059c881a18bc7c997077123db72ecb222a06 --- /dev/null +++ b/backend/src/CollabApp.Domain/Entities/RankingHistory.cs @@ -0,0 +1,195 @@ +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; + +namespace CollabApp.Domain.Entities; + +/// +/// 排名历史实体类 - 记录用户排名的历史变化轨迹 +/// 用于分析排名趋势和历史回顾 +/// +[Table("ranking_histories")] +public class RankingHistory : BaseEntity +{ + /// + /// 用户ID - 排名变化的用户标识 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; private set; } + + /// + /// 排行榜类型 - 历史记录对应的排行榜类型 + /// + [Required] + [Column("ranking_type")] + public RankingType RankingType { get; private set; } + + /// + /// 排名 - 该时间点的用户排名 + /// + [Column("rank")] + public int Rank { get; private set; } + + /// + /// 分数 - 该时间点的用户分数 + /// + [Column("score")] + public int Score { get; private set; } + + /// + /// 记录时间 - 该排名记录的时间点 + /// + [Column("recorded_at")] + public DateTime RecordedAt { get; private set; } = DateTime.UtcNow; + + // ============ 构造函数 ============ + + /// + /// 无参构造函数 - EF Core 必需 + /// + private RankingHistory() { } + + /// + /// 私有构造函数 - 仅限工厂方法调用 + /// + /// 用户ID + /// 排行榜类型 + /// 排名 + /// 分数 + /// 记录时间 + private RankingHistory(Guid userId, RankingType rankingType, int rank, int score, DateTime? recordedAt = null) + { + UserId = userId; + RankingType = rankingType; + Rank = rank; + Score = score; + RecordedAt = recordedAt ?? DateTime.UtcNow; + } + + // ============ 导航属性 ============ + + /// + /// 导航属性 - 关联的用户信息 + /// + [ForeignKey("UserId")] + public virtual Auth.User User { get; set; } = null!; + + // ============ 工厂方法 ============ + + /// + /// 创建排名历史记录 - 工厂方法 + /// + /// 用户ID + /// 排行榜类型 + /// 排名 + /// 分数 + /// 记录时间（可选，默认为当前时间） + /// 新的排名历史记录实例 + public static RankingHistory CreateRankingHistory(Guid userId, RankingType rankingType, + int rank, int score, DateTime? recordedAt = null) + { + if (userId == Guid.Empty) + throw new ArgumentException("用户ID不能为空", nameof(userId)); + if (rank <= 0) + throw new ArgumentException("排名必须大于0", nameof(rank)); + if (score < 0) + throw new ArgumentException("分数不能为负数", nameof(score)); + + return new RankingHistory(userId, rankingType, rank, score, recordedAt); + } + + /// + /// 从排行榜记录创建历史记录 - 工厂方法 + /// + /// 排行榜记录 + /// 记录时间（可选，默认为当前时间） + /// 新的排名历史记录实例 + public static RankingHistory CreateFromRanking(Ranking ranking, DateTime? recordedAt = null) + { + if (ranking == null) + throw new ArgumentNullException(nameof(ranking), "排行榜记录不能为空"); + + return CreateRankingHistory(ranking.UserId, ranking.RankingType, ranking.CurrentRank, + ranking.Score, recordedAt); + } + + // ============ 业务方法 ============ + + /// + /// 检查记录是否在指定时间范围内 + /// + /// 开始时间 + /// 结束时间 + /// 是否在范围内 + public bool IsWithinTimeRange(DateTime startTime, DateTime endTime) + { + return RecordedAt >= startTime && RecordedAt <= endTime; + } + + /// + /// 获取记录距今的天数 + /// + /// 天数 + public int GetDaysFromNow() + { + return (DateTime.UtcNow - RecordedAt).Days; + } + + /// + /// 检查记录是否过期（超过指定天数） + /// + /// 天数阈值 + /// 是否过期 + public bool IsExpired(int days = 90) + { + return GetDaysFromNow() > days; + } + + /// + /// 比较两个历史记录的排名变化 + /// + /// 另一个历史记录 + /// 排名变化（正数表示排名上升，负数表示下降） + public int CompareRankingChange(RankingHistory other) + { + if (other == null) + throw new ArgumentNullException(nameof(other)); + if (other.UserId != UserId || other.RankingType != RankingType) + throw new ArgumentException("只能比较同一用户同一类型的排名记录"); + + // 排名数字越小排名越高，所以这里是反向计算 + return other.Rank - Rank; + } + + /// + /// 比较两个历史记录的分数变化 + /// + /// 另一个历史记录 + /// 分数变化 + public int CompareScoreChange(RankingHistory other) + { + if (other == null) + throw new ArgumentNullException(nameof(other)); + if (other.UserId != UserId || other.RankingType != RankingType) + throw new ArgumentException("只能比较同一用户同一类型的排名记录"); + + return Score - other.Score; + } + + /// + /// 获取排行榜类型显示名称 + /// + /// 类型名称 + public string GetRankingTypeName() + { + return RankingType switch + { + RankingType.TotalScore => "总积分排行榜", + RankingType.WeeklyScore => "周积分排行榜", + RankingType.MonthlyScore => "月积分排行榜", + RankingType.WinRate => "胜率排行榜", + RankingType.Activity => "活跃度排行榜", + _ => "未知排行榜" + }; + } +} diff --git a/backend/src/CollabApp.Domain/Entities/Room/Room.cs b/backend/src/CollabApp.Domain/Entities/Room/Room.cs new file mode 100644 index 0000000000000000000000000000000000000000..d64bd116205e6ae0bdb212b22df45bc21e2bd294 --- /dev/null +++ b/backend/src/CollabApp.Domain/Entities/Room/Room.cs @@ -0,0 +1,285 @@ +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; + +namespace CollabApp.Domain.Entities.Room; + +/// +/// 房间实体 - 游戏房间的基本信息和配置 +/// 继承BaseEntity，支持软删除和时间戳功能 +/// +[Table("rooms")] +public class Room : BaseEntity +{ + /// + /// 房间名称 - 显示给玩家的房间标题 + /// + [Required] + [MaxLength(100)] + [Column("name")] + public string Name { get; private set; } = string.Empty; + + /// + /// 房主用户ID - 外键，指向创建房间的用户 + /// + [Required] + [Column("owner_id")] + public Guid OwnerId { get; private set; } + + /// + /// 最大玩家数 - 房间可容纳的最大玩家数量 + /// + [Column("max_players")] + public int MaxPlayers { get; private set; } = 4; + + /// + /// 当前玩家数 - 房间内当前的玩家数量，通过触发器自动更新 + /// + [Column("current_players")] + public int CurrentPlayers { get; private set; } = 0; + + /// + /// 房间密码 - 私有房间的进入密码，为空则表示公开房间 + /// + [MaxLength(255)] + [Column("password")] + public string? Password { get; private set; } + + /// + /// 是否私有房间 - 私有房间不会在房间列表中显示 + /// + [Column("is_private")] + public bool IsPrivate { get; private set; } = false; + + /// + /// 房间状态 - 等待中、游戏中、已结束 + /// + [Column("status")] + public RoomStatus Status { get; private set; } = RoomStatus.Waiting; + + /// + /// 房间设置 - JSON格式存储房间的自定义配置 + /// + [Column("settings", TypeName = "json")] + public string? Settings { get; private set; } + + // ============ 构造函数 ============ + + /// + /// 无参构造函数 - EF Core 必需 + /// + private Room() { } + + /// + /// 私有构造函数 - 仅限工厂方法调用 + /// + /// 房间名称 + /// 房主用户ID + /// 最大玩家数 + /// 房间密码 + /// 是否私有房间 + /// 房间设置 + private Room(string name, Guid ownerId, int maxPlayers = 4, string? password = null, + bool isPrivate = false, string? settings = null) + { + Name = name; + OwnerId = ownerId; + MaxPlayers = maxPlayers; + CurrentPlayers = 0; + Password = password; + IsPrivate = isPrivate; + Status = RoomStatus.Waiting; + Settings = settings; + } + + // ============ 导航属性 ============ + + /// + /// 房主用户实体 - 多对一关系 + /// + [ForeignKey("OwnerId")] + public virtual Auth.User Owner { get; set; } = null!; + + /// + /// 房间内的玩家列表 - 一对多关系 + /// + public virtual ICollection Players { get; set; } = new List(); + + /// + /// 房间聊天消息列表 - 一对多关系 + /// + public virtual ICollection Messages { get; set; } = new List(); + + /// + /// 房间内进行的游戏列表 - 一对多关系 + /// + public virtual ICollection Games { get; set; } = new List(); + + // ============ 工厂方法 ============ + + /// + /// 创建新房间 - 工厂方法 + /// + /// 房间名称 + /// 房主用户ID + /// 最大玩家数 + /// 房间密码 + /// 是否私有房间 + /// 房间设置 + /// 新房间实例 + public static Room CreateRoom(string name, Guid ownerId, int maxPlayers = 4, + string? password = null, bool isPrivate = false, string? settings = null) + { + if (string.IsNullOrWhiteSpace(name)) + throw new ArgumentException("房间名称不能为空", nameof(name)); + if (ownerId == Guid.Empty) + throw new ArgumentException("房主ID不能为空", nameof(ownerId)); + if (maxPlayers < 2 || maxPlayers > 8) + throw new ArgumentException("最大玩家数必须在2-8之间", nameof(maxPlayers)); + + return new Room(name, ownerId, maxPlayers, password, isPrivate, settings); + } + + // ============ 业务方法 ============ + + /// + /// 更新房间信息 + /// + /// 新房间名称 + /// 新最大玩家数 + /// 新密码 + /// 是否私有 + /// 新设置 + public void UpdateRoomInfo(string? name = null, int? maxPlayers = null, + string? password = null, bool? isPrivate = null, string? settings = null) + { + if (Status != RoomStatus.Waiting) + throw new InvalidOperationException("只能在等待状态下修改房间信息"); + + if (!string.IsNullOrWhiteSpace(name)) + Name = name; + + if (maxPlayers.HasValue) + { + if (maxPlayers.Value < 2 || maxPlayers.Value > 8) + throw new ArgumentException("最大玩家数必须在2-8之间"); + if (maxPlayers.Value < CurrentPlayers) + throw new ArgumentException("最大玩家数不能小于当前玩家数"); + MaxPlayers = maxPlayers.Value; + } + + if (password != null) + Password = string.IsNullOrWhiteSpace(password) ? null : password; + + if (isPrivate.HasValue) + IsPrivate = isPrivate.Value; + + if (settings != null) + Settings = settings; + } + + /// + /// 增加当前玩家数 + /// + public void IncrementPlayerCount() + { + if (CurrentPlayers >= MaxPlayers) + throw new InvalidOperationException("房间已满"); + + CurrentPlayers++; + } + + /// + /// 减少当前玩家数 + /// + public void DecrementPlayerCount() + { + if (CurrentPlayers <= 0) + throw new InvalidOperationException("房间内没有玩家"); + + CurrentPlayers--; + } + + /// + /// 开始游戏 + /// + public void StartGame() + { + if (Status != RoomStatus.Waiting) + throw new InvalidOperationException("只能在等待状态下开始游戏"); + if (CurrentPlayers < 2) + throw new InvalidOperationException("至少需要2名玩家才能开始游戏"); + + Status = RoomStatus.Playing; + } + + /// + /// 结束游戏 + /// + public void FinishGame() + { + if (Status != RoomStatus.Playing) + throw new InvalidOperationException("只能在游戏状态下结束游戏"); + + Status = RoomStatus.Finished; + } + + /// + /// 重置房间状态 + /// + public void ResetToWaiting() + { + Status = RoomStatus.Waiting; + } + + /// + /// 检查密码 + /// + /// 要验证的密码 + /// 密码是否正确 + public bool CheckPassword(string? password) + { + // 如果房间没有密码，任何输入都视为正确 + if (string.IsNullOrEmpty(Password)) + return true; + + // 如果房间有密码，必须完全匹配 + return Password.Equals(password, StringComparison.Ordinal); + } + + /// + /// 检查房间是否已满 + /// + /// 房间是否已满 + public bool IsFull() => CurrentPlayers >= MaxPlayers; + + /// + /// 检查是否可以加入房间 + /// + /// 密码 + /// 是否可以加入 + public bool CanJoin(string? password = null) + { + return Status == RoomStatus.Waiting && !IsFull() && CheckPassword(password); + } +} + +/// +/// 房间状态枚举 +/// +public enum RoomStatus +{ + /// + /// 等待中 - 房间已创建，等待玩家加入和准备 + /// + Waiting, + + /// + /// 游戏中 - 房间内正在进行游戏 + /// + Playing, + + /// + /// 已结束 - 游戏已结束，房间即将关闭 + /// + Finished +} diff --git a/backend/src/CollabApp.Domain/Entities/Room/RoomMessage.cs b/backend/src/CollabApp.Domain/Entities/Room/RoomMessage.cs new file mode 100644 index 0000000000000000000000000000000000000000..ca91341b7cd6164b80a5d0f9e2c3853053a40345 --- /dev/null +++ b/backend/src/CollabApp.Domain/Entities/Room/RoomMessage.cs @@ -0,0 +1,177 @@ +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; + +namespace CollabApp.Domain.Entities.Room; + +/// +/// 房间聊天消息实体 - 存储房间内的聊天记录 +/// +[Table("room_messages")] +public class RoomMessage : BaseEntity +{ + /// + /// 关联房间ID - 外键，指向Rooms表 + /// + [Required] + [Column("room_id")] + public Guid RoomId { get; private set; } + + /// + /// 发送用户ID - 外键，指向Users表 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; private set; } + + /// + /// 消息内容 - 聊天消息的具体文本内容 + /// + [Required] + [Column("message")] + public string Message { get; private set; } = string.Empty; + + /// + /// 消息类型 - 普通文本消息或系统消息 + /// + [Column("message_type")] + public MessageType MessageType { get; private set; } = MessageType.Text; + + // ============ 构造函数 ============ + + /// + /// 无参构造函数 - EF Core 必需 + /// + private RoomMessage() { } + + /// + /// 私有构造函数 - 仅限工厂方法调用 + /// + /// 房间ID + /// 用户ID + /// 消息内容 + /// 消息类型 + private RoomMessage(Guid roomId, Guid userId, string message, MessageType messageType = MessageType.Text) + { + RoomId = roomId; + UserId = userId; + Message = message; + MessageType = messageType; + } + + // ============ 导航属性 ============ + + /// + /// 关联的房间实体 - 多对一关系 + /// + [ForeignKey("RoomId")] + public virtual Room Room { get; set; } = null!; + + /// + /// 发送消息的用户实体 - 多对一关系 + /// + [ForeignKey("UserId")] + public virtual Auth.User User { get; set; } = null!; + + // ============ 工厂方法 ============ + + /// + /// 创建用户消息 - 工厂方法 + /// + /// 房间ID + /// 用户ID + /// 消息内容 + /// 新的用户消息实例 + public static RoomMessage CreateUserMessage(Guid roomId, Guid userId, string message) + { + if (roomId == Guid.Empty) + throw new ArgumentException("房间ID不能为空", nameof(roomId)); + if (userId == Guid.Empty) + throw new ArgumentException("用户ID不能为空", nameof(userId)); + if (string.IsNullOrWhiteSpace(message)) + throw new ArgumentException("消息内容不能为空", nameof(message)); + + return new RoomMessage(roomId, userId, message, MessageType.Text); + } + + /// + /// 创建系统消息 - 工厂方法 + /// + /// 房间ID + /// 系统消息内容 + /// 新的系统消息实例 + public static RoomMessage CreateSystemMessage(Guid roomId, string message) + { + if (roomId == Guid.Empty) + throw new ArgumentException("房间ID不能为空", nameof(roomId)); + if (string.IsNullOrWhiteSpace(message)) + throw new ArgumentException("消息内容不能为空", nameof(message)); + + // 系统消息使用空GUID作为用户ID + return new RoomMessage(roomId, Guid.Empty, message, MessageType.System); + } + + // ============ 业务方法 ============ + + /// + /// 检查是否为系统消息 + /// + /// 是否为系统消息 + public bool IsSystemMessage() => MessageType == MessageType.System; + + /// + /// 检查是否为用户消息 + /// + /// 是否为用户消息 + public bool IsUserMessage() => MessageType == MessageType.Text; + + /// + /// 获取消息长度 + /// + /// 消息字符数 + public int GetMessageLength() => Message?.Length ?? 0; + + /// + /// 检查消息是否包含特定关键词 + /// + /// 关键词 + /// 是否忽略大小写 + /// 是否包含关键词 + public bool ContainsKeyword(string keyword, bool ignoreCase = true) + { + if (string.IsNullOrWhiteSpace(keyword) || string.IsNullOrWhiteSpace(Message)) + return false; + + var comparison = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal; + return Message.Contains(keyword, comparison); + } + + /// + /// 获取消息类型显示名称 + /// + /// 类型名称 + public string GetMessageTypeName() + { + return MessageType switch + { + MessageType.Text => "用户消息", + MessageType.System => "系统消息", + _ => "未知类型" + }; + } +} + +/// +/// 消息类型枚举 +/// +public enum MessageType +{ + /// + /// 普通文本消息 - 用户发送的聊天内容 + /// + Text, + + /// + /// 系统消息 - 由系统自动生成的通知消息 + /// + System +} diff --git a/backend/src/CollabApp.Domain/Entities/Room/RoomPlayer.cs b/backend/src/CollabApp.Domain/Entities/Room/RoomPlayer.cs new file mode 100644 index 0000000000000000000000000000000000000000..4ce93a2b04fc44e2cef69edbaccba653400885f0 --- /dev/null +++ b/backend/src/CollabApp.Domain/Entities/Room/RoomPlayer.cs @@ -0,0 +1,168 @@ +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; + +namespace CollabApp.Domain.Entities.Room; + +/// +/// 房间玩家实体 - 记录玩家在房间中的状态和信息 +/// +[Table("room_players")] +public class RoomPlayer : BaseEntity +{ + /// + /// 关联房间ID - 外键，指向Rooms表 + /// + [Required] + [Column("room_id")] + public Guid RoomId { get; private set; } + + /// + /// 关联用户ID - 外键，指向Users表 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; private set; } + + /// + /// 是否准备就绪 - 玩家是否已准备开始游戏 + /// + [Column("is_ready")] + public bool IsReady { get; private set; } = false; + + /// + /// 加入顺序 - 玩家加入房间的先后顺序，可用于分配颜色等 + /// + [Column("join_order")] + public int? JoinOrder { get; private set; } + + /// + /// 玩家颜色 - 十六进制颜色代码，用于游戏中区分不同玩家 + /// + [MaxLength(7)] + [Column("player_color")] + public string? PlayerColor { get; private set; } + + // ============ 构造函数 ============ + + /// + /// 无参构造函数 - EF Core 必需 + /// + private RoomPlayer() { } + + /// + /// 私有构造函数 - 仅限工厂方法调用 + /// + /// 房间ID + /// 用户ID + /// 加入顺序 + /// 玩家颜色 + private RoomPlayer(Guid roomId, Guid userId, int? joinOrder = null, string? playerColor = null) + { + RoomId = roomId; + UserId = userId; + IsReady = false; + JoinOrder = joinOrder; + PlayerColor = playerColor; + } + + // ============ 导航属性 ============ + + /// + /// 关联的房间实体 - 多对一关系 + /// + [ForeignKey("RoomId")] + public virtual Room Room { get; set; } = null!; + + /// + /// 关联的用户实体 - 多对一关系 + /// + [ForeignKey("UserId")] + public virtual Auth.User User { get; set; } = null!; + + // ============ 工厂方法 ============ + + /// + /// 创建新的房间玩家记录 - 工厂方法 + /// + /// 房间ID + /// 用户ID + /// 加入顺序 + /// 玩家颜色 + /// 新的房间玩家实例 + public static RoomPlayer CreateRoomPlayer(Guid roomId, Guid userId, int? joinOrder = null, string? playerColor = null) + { + if (roomId == Guid.Empty) + throw new ArgumentException("房间ID不能为空", nameof(roomId)); + if (userId == Guid.Empty) + throw new ArgumentException("用户ID不能为空", nameof(userId)); + + return new RoomPlayer(roomId, userId, joinOrder, playerColor); + } + + // ============ 业务方法 ============ + + /// + /// 设置准备状态 + /// + /// 是否准备 + public void SetReady(bool isReady) + { + IsReady = isReady; + } + + /// + /// 切换准备状态 + /// + public void ToggleReady() + { + IsReady = !IsReady; + } + + /// + /// 设置加入顺序 + /// + /// 加入顺序 + public void SetJoinOrder(int order) + { + if (order < 1) + throw new ArgumentException("加入顺序必须大于0", nameof(order)); + + JoinOrder = order; + } + + /// + /// 设置玩家颜色 + /// + /// 十六进制颜色代码（如：#FF0000） + public void SetPlayerColor(string? color) + { + if (color != null && !IsValidHexColor(color)) + throw new ArgumentException("无效的颜色格式，请使用十六进制格式（如：#FF0000）", nameof(color)); + + PlayerColor = color; + } + + /// + /// 验证十六进制颜色格式 + /// + /// 颜色代码 + /// 是否为有效格式 + private static bool IsValidHexColor(string color) + { + if (string.IsNullOrWhiteSpace(color)) + return false; + + // 必须以#开头，后跟6位十六进制字符 + if (color.Length != 7 || color[0] != '#') + return false; + + for (int i = 1; i < 7; i++) + { + char c = color[i]; + if (!((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f'))) + return false; + } + + return true; + } +} diff --git a/backend/src/CollabApp.Domain/Repositories/IGenericRepository.cs b/backend/src/CollabApp.Domain/Repositories/IGenericRepository.cs new file mode 100644 index 0000000000000000000000000000000000000000..6960517762812b9ddb34b81bc6115370363cde7c --- /dev/null +++ b/backend/src/CollabApp.Domain/Repositories/IGenericRepository.cs @@ -0,0 +1,217 @@ +using System; +using System.Collections.Generic; +using System.Linq.Expressions; +using System.Threading; +using System.Threading.Tasks; +using CollabApp.Domain.Entities; + +namespace CollabApp.Domain.Repositories; + +/// +/// 通用仓储接口 +/// 提供基本的增删改查、条件查询、分页查询等功能 +/// +/// 实体类型，必须继承BaseEntity +public interface IRepository where T : BaseEntity +{ + // ============ 查询操作 ============ + + /// + /// 根据ID查询实体 + /// + /// 实体ID + /// 实体，如果不存在则返回null + Task GetByIdAsync(Guid id); + + /// + /// 获取所有实体 + /// + /// 所有实体集合 + Task> GetAllAsync(); + + /// + /// 根据条件查询单个实体 + /// + /// 查询条件 + /// 符合条件的第一个实体，如果不存在则返回null + Task GetSingleAsync(Expression> predicate); + + /// + /// 根据条件查询多个实体 + /// + /// 查询条件 + /// 符合条件的实体集合 + Task> GetManyAsync(Expression> predicate); + + /// + /// 分页查询数据 + /// + /// 查询条件表达式 + /// 页码（从0开始） + /// 每页数据量 + /// 返回分页后的数据集合和总数 + Task<(IEnumerable Items, int TotalCount)> GetPagedAsync( + Expression> predicate, + int pageIndex, + int pageSize); + + /// + /// 分页查询所有数据 + /// + /// 页码（从0开始） + /// 每页数据量 + /// 返回分页后的数据集合和总数 + Task<(IEnumerable Items, int TotalCount)> GetPagedAsync( + int pageIndex, + int pageSize); + + /// + /// 检查是否存在符合条件的实体 + /// + /// 查询条件 + /// 是否存在 + Task ExistsAsync(Expression> predicate); + + /// + /// 根据条件获取数据条数 + /// + /// 查询条件表达式 + /// 返回符合条件的数据条数 + Task CountAsync(Expression> predicate); + + /// + /// 获取所有数据的总数 + /// + /// 返回所有数据的总条数 + Task CountAllAsync(); + + // ============ 高级查询操作 ============ + + /// + /// 根据条件查询并排序 + /// + /// 排序字段类型 + /// 查询条件 + /// 排序表达式 + /// 是否升序，默认true + /// 排序后的实体集合 + Task> GetOrderedAsync( + Expression> predicate, + Expression> orderBy, + bool ascending = true); + + /// + /// 获取前N条记录 + /// + /// 查询条件 + /// 获取的记录数 + /// 前N条记录 + Task> GetTopAsync(Expression> predicate, int count); + + /// + /// 获取前N条记录并排序 + /// + /// 排序字段类型 + /// 查询条件 + /// 排序表达式 + /// 获取的记录数 + /// 是否升序，默认true + /// 排序后的前N条记录 + Task> GetTopOrderedAsync( + Expression> predicate, + Expression> orderBy, + int count, + bool ascending = true); + + // ============ 增加操作 ============ + + /// + /// 添加单个实体 + /// + /// 要添加的实体 + Task AddAsync(T entity); + + /// + /// 批量添加实体 + /// + /// 要添加的实体集合 + Task AddRangeAsync(IEnumerable entities); + + // ============ 更新操作 ============ + + /// + /// 更新单个实体 + /// + /// 要更新的实体 + Task UpdateAsync(T entity); + + /// + /// 批量更新实体 + /// + /// 要更新的实体集合 + Task UpdateRangeAsync(IEnumerable entities); + + // ============ 删除操作 ============ + + /// + /// 删除单个实体（软删除，设置IsDeleted=true） + /// + /// 要删除的实体 + Task DeleteAsync(T entity); + + /// + /// 根据ID删除实体（软删除） + /// + /// 实体ID + Task DeleteAsync(Guid id); + + /// + /// 批量删除实体（软删除） + /// + /// 要删除的实体集合 + Task DeleteRangeAsync(IEnumerable entities); + + /// + /// 根据条件批量删除实体（软删除） + /// + /// 删除条件 + Task DeleteWhereAsync(Expression> predicate); + + // ============ 工作单元操作 ============ + + /// + /// 保存所有更改到数据库 + /// + /// 取消令牌 + /// 受影响的记录数 + Task SaveChangesAsync(CancellationToken cancellationToken = default); + + // ============ 性能优化方法 ============ + + /// + /// 批量插入（高性能）- 适用于大量数据插入 + /// + /// 要插入的实体集合 + /// 取消令牌 + Task BulkInsertAsync(IEnumerable entities, CancellationToken cancellationToken = default); + + /// + /// 批量更新（高性能）- 适用于大量数据更新 + /// + /// 要更新的实体集合 + /// 取消令牌 + Task BulkUpdateAsync(IEnumerable entities, CancellationToken cancellationToken = default); + + /// + /// 批量软删除（高性能）- 直接执行SQL + /// + /// 删除条件 + /// 取消令牌 + Task BulkSoftDeleteAsync(Expression> predicate, CancellationToken cancellationToken = default); + + /// + /// 检查连接是否可用 + /// + /// 取消令牌 + Task IsHealthyAsync(CancellationToken cancellationToken = default); +} \ No newline at end of file diff --git a/backend/src/CollabApp.Domain/Services/Auth/IAuthService.cs b/backend/src/CollabApp.Domain/Services/Auth/IAuthService.cs new file mode 100644 index 0000000000000000000000000000000000000000..8efec7b142d7060d279b5bafd941171ca4d2dda5 --- /dev/null +++ b/backend/src/CollabApp.Domain/Services/Auth/IAuthService.cs @@ -0,0 +1,19 @@ +namespace CollabApp.Domain.Services.Auth; + +/// +/// 认证服务接口 +/// +public interface IAuthService +{ + // 登录 + Task LoginAsync(string username, string password); + + // 注册 + Task RegisterAsync(string username, string password, string nickname); + + // 刷新令牌 + Task RefreshTokenAsync(string refreshToken); + + // 忘记密码 + Task ForgotPasswordAsync(string username, string newPassword); +} \ No newline at end of file diff --git a/backend/src/CollabApp.Domain/Services/Game/ICollisionDetectionService.cs b/backend/src/CollabApp.Domain/Services/Game/ICollisionDetectionService.cs new file mode 100644 index 0000000000000000000000000000000000000000..2df859586a45efcd69212fb1e4cdf423e61c0461 --- /dev/null +++ b/backend/src/CollabApp.Domain/Services/Game/ICollisionDetectionService.cs @@ -0,0 +1,388 @@ +using CollabApp.Domain.Entities.Game; + +namespace CollabApp.Domain.Services.Game; + +/// +/// 圈地游戏碰撞检测服务接口 +/// 负责处理画线轨迹碰撞、边界检测、道具拾取等核心碰撞检测逻辑 +/// 采用线段相交算法，提供高精度碰撞检测，避免误判 +/// +public interface ICollisionDetectionService +{ + /// + /// 检测轨迹截断碰撞 + /// 检测玩家移动路径是否与其他玩家的轨迹相交（最核心的死亡判定） + /// + /// 游戏标识 + /// 移动的玩家标识 + /// 移动起始位置 + /// 移动目标位置 + /// 该玩家是否正在画线 + /// 轨迹碰撞检测结果 + Task CheckTrailCollisionAsync( + Guid gameId, + Guid playerId, + Position fromPosition, + Position toPosition, + bool isDrawing); + + /// + /// 检测地图边界碰撞 + /// 检查玩家移动是否超出圆形地图边界 + /// + /// 游戏标识 + /// 要检测的位置 + /// 边界碰撞结果 + Task CheckMapBoundaryAsync(Guid gameId, Position position); + + /// + /// 检测障碍物碰撞 + /// 检测玩家移动路径是否与地图中的固定障碍物相交 + /// + /// 游戏标识 + /// 移动起始位置 + /// 移动目标位置 + /// 障碍物碰撞结果 + Task CheckObstacleCollisionAsync( + Guid gameId, + Position fromPosition, + Position toPosition); + + /// + /// 检测道具拾取碰撞 + /// 检测玩家是否接近地图上的道具（拾取距离20像素内） + /// + /// 游戏标识 + /// 玩家标识 + /// 玩家当前位置 + /// 拾取范围 + /// 道具拾取碰撞结果 + Task CheckPowerUpPickupAsync( + Guid gameId, + Guid playerId, + Position playerPosition, + float pickupRadius = 20f); + + /// + /// 检测领地进入/离开 + /// 检测玩家是否进入或离开某个玩家的领地区域 + /// + /// 游戏标识 + /// 移动的玩家标识 + /// 移动起始位置 + /// 移动目标位置 + /// 领地进入/离开结果 + Task CheckTerritoryTransitionAsync( + Guid gameId, + Guid playerId, + Position fromPosition, + Position toPosition); + + /// + /// 检测轨迹预警 + /// 检测敌方玩家是否接近自己的轨迹（3像素内预警） + /// + /// 游戏标识 + /// 轨迹所有者 + /// 威胁玩家位置 + /// 预警距离 + /// 轨迹预警结果 + Task CheckTrailWarningAsync( + Guid gameId, + Guid playerId, + Position threatPlayerPosition, + float warningDistance = 3f); + + /// + /// 检测炸弹道具影响范围 + /// 检测炸弹道具爆炸范围内的所有轨迹和玩家 + /// + /// 游戏标识 + /// 爆炸中心位置 + /// 爆炸半径 + /// 爆炸影响检测结果 + Task CheckBombExplosionAsync( + Guid gameId, + Position explosionCenter, + float explosionRadius = 30f); + + /// + /// 检测圈地闭合 + /// 检测玩家画线轨迹是否与自己的领地形成闭合回路 + /// + /// 游戏标识 + /// 玩家标识 + /// 当前画线轨迹 + /// 结束位置 + /// 圈地闭合检测结果 + Task CheckTerritoryEnclosureAsync( + Guid gameId, + Guid playerId, + List currentTrail, + Position endPosition); + + /// + /// 检测地图缩圈影响 + /// 检测地图缩圈时哪些玩家的领地会受到影响 + /// + /// 游戏标识 + /// 新的地图半径 + /// 地图缩圈影响结果 + Task CheckMapShrinkCollisionAsync(Guid gameId, float newMapRadius); + + /// + /// 批量碰撞检测优化 + /// 一次性检测多个玩家的移动碰撞，提高服务器性能 + /// + /// 游戏标识 + /// 玩家移动列表 + /// 批量碰撞检测结果 + Task CheckBatchPlayerMovementsAsync( + Guid gameId, + List playerMovements); +} + +/// +/// 轨迹碰撞检测结果 +/// +public class TrailCollisionResult +{ + public bool HasCollision { get; set; } + public Guid? CollidedWithPlayerId { get; set; } + public Position CollisionPoint { get; set; } = new(); + public bool IsDeadly { get; set; } // 是否导致死亡 + public bool CanPassThrough { get; set; } // 是否可以穿过（幽灵模式） + public bool ShieldBlocked { get; set; } // 是否被护盾阻挡 + public string CollisionType { get; set; } = string.Empty; // Trail, SelfTrail, Territory +} + +/// +/// 边界碰撞结果 +/// +public class BoundaryCollisionResult +{ + public bool IsOutOfBounds { get; set; } + public Position ValidPosition { get; set; } = new(); // 修正后的有效位置 + public float DistanceFromCenter { get; set; } + public float MapRadius { get; set; } + public string BoundaryType { get; set; } = "Circle"; +} + +/// +/// 障碍物碰撞结果 +/// +public class ObstacleCollisionResult +{ + public bool HasCollision { get; set; } + public List CollidedObstacles { get; set; } = new(); + public Position ValidPosition { get; set; } = new(); + public bool BlocksMovement { get; set; } = true; +} + +/// +/// 道具拾取碰撞结果 +/// +public class PowerUpPickupCollisionResult +{ + public bool CanPickup { get; set; } + public List NearbyPowerUps { get; set; } = new(); + public PickupablePowerUp? ClosestPowerUp { get; set; } + public float ClosestDistance { get; set; } +} + +/// +/// 领地转换结果 +/// +public class TerritoryTransitionResult +{ + public bool TerritoryChanged { get; set; } + public Guid? PreviousOwnerId { get; set; } + public Guid? CurrentOwnerId { get; set; } + public string? PreviousOwnerName { get; set; } + public string? CurrentOwnerName { get; set; } + public TerritoryTransitionType TransitionType { get; set; } + public float SpeedModifier { get; set; } = 1.0f; // 在不同领地的速度修正 +} + +/// +/// 轨迹预警结果 +/// +public class TrailWarningResult +{ + public bool ShouldWarn { get; set; } + public List Threats { get; set; } = new(); + public TrailThreat? ImmediateThreat { get; set; } + public float MinimumDistance { get; set; } +} + +/// +/// 爆炸碰撞结果 +/// +public class ExplosionCollisionResult +{ + public bool HasTargets { get; set; } + public List AffectedPlayerTrails { get; set; } = new(); + public List ClearedTrailPoints { get; set; } = new(); + public decimal TerritoryAreaGained { get; set; } + public List NewTerritoryBoundary { get; set; } = new(); +} + +/// +/// 圈地闭合检测结果 +/// +public class EnclosureDetectionResult +{ + public bool IsEnclosed { get; set; } + public List EnclosedArea { get; set; } = new(); + public decimal AreaSize { get; set; } + public List EnclosedPlayerTerritories { get; set; } = new(); // 被包围的敌方领地 + public bool IsValidEnclosure { get; set; } + public string? InvalidReason { get; set; } +} + +/// +/// 地图缩圈碰撞结果 +/// +public class MapShrinkCollisionResult +{ + public bool HasAffectedTerritories { get; set; } + public List TerritoryLosses { get; set; } = new(); + public float NewMapRadius { get; set; } + public Position MapCenter { get; set; } = new(); + public int TotalAffectedPlayers { get; set; } +} + +/// +/// 批量碰撞检测结果 +/// +public class BatchCollisionResult +{ + public List Results { get; set; } = new(); + public int TotalCollisions { get; set; } + public int ProcessedMovements { get; set; } + public List Errors { get; set; } = new(); +} + +/// +/// 玩家移动信息 +/// +public class PlayerMovement +{ + public Guid PlayerId { get; set; } + public Position FromPosition { get; set; } = new(); + public Position ToPosition { get; set; } = new(); + public bool IsDrawing { get; set; } + public long Timestamp { get; set; } + public float Speed { get; set; } +} + +/// +/// 玩家碰撞结果 +/// +public class PlayerCollisionResult +{ + public Guid PlayerId { get; set; } + public bool HasCollision { get; set; } + public Position ValidPosition { get; set; } = new(); + public List Collisions { get; set; } = new(); + public bool ShouldDie { get; set; } + public string? DeathReason { get; set; } +} + +/// +/// 地图障碍物 +/// +public class MapObstacle +{ + public Guid Id { get; set; } + public List Boundary { get; set; } = new(); + public string ObstacleType { get; set; } = "Static"; // Static, Destructible + public bool IsDestructible { get; set; } + public Position Center { get; set; } = new(); + public float Radius { get; set; } +} + +/// +/// 可拾取道具 +/// +public class PickupablePowerUp +{ + public Guid Id { get; set; } + public TerritoryGamePowerUpType Type { get; set; } + public Position Position { get; set; } = new(); + public float DistanceFromPlayer { get; set; } + public bool IsPickupable { get; set; } = true; + public DateTime SpawnTime { get; set; } +} + +/// +/// 轨迹威胁 +/// +public class TrailThreat +{ + public Guid ThreatPlayerId { get; set; } + public Position ThreatPosition { get; set; } = new(); + public Position NearestTrailPoint { get; set; } = new(); + public float Distance { get; set; } + public ThreatLevel Level { get; set; } + public float TimeToContact { get; set; } // 预计接触时间（秒） +} + +/// +/// 玩家领地损失 +/// +public class PlayerTerritoryLoss +{ + public Guid PlayerId { get; set; } + public string PlayerName { get; set; } = string.Empty; + public decimal AreaLost { get; set; } + public decimal RemainingArea { get; set; } + public List LostTerritoryBoundary { get; set; } = new(); +} + +/// +/// 碰撞详情 +/// +public class CollisionDetail +{ + public CollisionCategory Category { get; set; } + public Position CollisionPoint { get; set; } = new(); + public Guid? OtherPlayerId { get; set; } + public string Description { get; set; } = string.Empty; + public Dictionary Properties { get; set; } = new(); +} + +/// +/// 领地转换类型 +/// +public enum TerritoryTransitionType +{ + NeutralToOwned, // 从中立区域进入玩家领地 + OwnedToNeutral, // 从玩家领地进入中立区域 + OwnedToOtherOwned, // 从一个玩家领地进入另一个玩家领地 + NoChange // 没有变化 +} + +/// +/// 威胁等级 +/// +public enum ThreatLevel +{ + None, // 无威胁 + Low, // 低威胁 + Medium, // 中等威胁 + High, // 高威胁 + Critical // 紧急威胁 +} + +/// +/// 碰撞分类 +/// +public enum CollisionCategory +{ + TrailCollision, // 轨迹碰撞 + BoundaryHit, // 边界碰撞 + ObstacleHit, // 障碍物碰撞 + TerritoryTransition, // 领地转换 + PowerUpPickup // 道具拾取 +} diff --git a/backend/src/CollabApp.Domain/Services/Game/IGameBroadcastService.cs b/backend/src/CollabApp.Domain/Services/Game/IGameBroadcastService.cs new file mode 100644 index 0000000000000000000000000000000000000000..1a6f40c306de3ff8358c8e5677e16dcf9be216bd --- /dev/null +++ b/backend/src/CollabApp.Domain/Services/Game/IGameBroadcastService.cs @@ -0,0 +1,315 @@ +using CollabApp.Domain.Entities.Game; + +namespace CollabApp.Domain.Services.Game; + +/// +/// 游戏广播服务接口 +/// 负责实时推送游戏状态变化、事件通知和玩家互动信息 +/// +public interface IGameBroadcastService +{ + /// + /// 广播游戏状态更新 + /// 向所有游戏参与者推送游戏状态的变化 + /// + /// 游戏标识 + /// 状态更新信息 + /// 广播是否成功 + Task BroadcastGameStateUpdateAsync(Guid gameId, GameStateUpdate stateUpdate); + + /// + /// 广播玩家行为 + /// 向其他玩家推送某个玩家的行为信息 + /// + /// 游戏标识 + /// 玩家行为信息 + /// 排除的玩家ID（通常是行为发起者） + /// 广播是否成功 + Task BroadcastPlayerActionAsync(Guid gameId, PlayerActionBroadcast playerAction, Guid? excludePlayerId = null); + + /// + /// 广播游戏事件 + /// 推送重要的游戏事件给相关玩家 + /// + /// 游戏标识 + /// 游戏事件 + /// 目标玩家列表，为空则广播给所有人 + /// 广播是否成功 + Task BroadcastGameEventAsync(Guid gameId, GameEventBroadcast gameEvent, List? targetPlayers = null); + + /// + /// 发送私人消息 + /// 向特定玩家发送私人消息或通知 + /// + /// 游戏标识 + /// 目标玩家标识 + /// 消息内容 + /// 发送是否成功 + Task SendPrivateMessageAsync(Guid gameId, Guid playerId, PrivateMessage message); + + /// + /// 广播计分更新 + /// 推送计分变化和排名更新 + /// + /// 游戏标识 + /// 计分更新信息 + /// 广播是否成功 + Task BroadcastScoreUpdateAsync(Guid gameId, ScoreUpdateBroadcast scoreUpdate); + + /// + /// 广播地图变化 + /// 推送地图状态的变化（如领土变更、物品刷新等） + /// + /// 游戏标识 + /// 地图更新信息 + /// 广播是否成功 + Task BroadcastMapUpdateAsync(Guid gameId, MapUpdateBroadcast mapUpdate); + + /// + /// 广播玩家状态变化 + /// 推送玩家状态的变化（如血量、位置、装备等） + /// + /// 游戏标识 + /// 玩家状态更新 + /// 广播是否成功 + Task BroadcastPlayerStatusUpdateAsync(Guid gameId, PlayerStatusUpdate playerUpdate); + + /// + /// 广播系统通知 + /// 发送系统级别的通知消息 + /// + /// 游戏标识 + /// 系统通知 + /// 目标玩家，为空则发送给所有人 + /// 广播是否成功 + Task BroadcastSystemNotificationAsync(Guid gameId, SystemNotification notification, List? targetPlayers = null); + + /// + /// 加入游戏房间 + /// 将玩家连接添加到游戏房间的广播组 + /// + /// 连接标识 + /// 游戏标识 + /// 玩家标识 + /// 操作是否成功 + Task JoinGameRoomAsync(string connectionId, Guid gameId, Guid playerId); + + /// + /// 离开游戏房间 + /// 从游戏房间的广播组中移除玩家连接 + /// + /// 连接标识 + /// 游戏标识 + /// 玩家标识 + /// 操作是否成功 + Task LeaveGameRoomAsync(string connectionId, Guid gameId, Guid playerId); + + /// + /// 获取游戏房间在线玩家 + /// 获取当前在游戏房间中的所有在线玩家 + /// + /// 游戏标识 + /// 在线玩家列表 + Task> GetOnlinePlayersAsync(Guid gameId); +} + +/// +/// 游戏状态更新广播 +/// +public class GameStateUpdate +{ + public Guid GameId { get; set; } + public Entities.Game.GameStatus Status { get; set; } + public DateTime Timestamp { get; set; } + public TimeSpan? RemainingTime { get; set; } + public int Round { get; set; } + public Dictionary StateData { get; set; } = new(); +} + +/// +/// 玩家行为广播 +/// +public class PlayerActionBroadcast +{ + public Guid PlayerId { get; set; } + public string PlayerName { get; set; } = string.Empty; + public ActionType ActionType { get; set; } + public Position? Position { get; set; } + public Position? TargetPosition { get; set; } + public Guid? TargetPlayerId { get; set; } + public DateTime Timestamp { get; set; } + public Dictionary ActionData { get; set; } = new(); +} + +/// +/// 游戏事件广播 +/// +public class GameEventBroadcast +{ + public string EventType { get; set; } = string.Empty; + public string Title { get; set; } = string.Empty; + public string Message { get; set; } = string.Empty; + public EventPriority Priority { get; set; } + public Guid? RelatedPlayerId { get; set; } + public Position? Location { get; set; } + public DateTime Timestamp { get; set; } + public Dictionary EventData { get; set; } = new(); +} + +/// +/// 私人消息 +/// +public class PrivateMessage +{ + public Guid SenderId { get; set; } + public string SenderName { get; set; } = string.Empty; + public string Content { get; set; } = string.Empty; + public MessageType MessageType { get; set; } + public DateTime Timestamp { get; set; } + public Dictionary Metadata { get; set; } = new(); +} + +/// +/// 计分更新广播 +/// +public class ScoreUpdateBroadcast +{ + public Guid GameId { get; set; } + public List PlayerScores { get; set; } = new(); + public List Rankings { get; set; } = new(); + public DateTime Timestamp { get; set; } +} + +/// +/// 玩家计分更新 +/// +public class PlayerScoreUpdate +{ + public Guid PlayerId { get; set; } + public string PlayerName { get; set; } = string.Empty; + public int PreviousScore { get; set; } + public int CurrentScore { get; set; } + public int ScoreChange { get; set; } + public string Reason { get; set; } = string.Empty; +} + +/// +/// 地图更新广播 +/// +public class MapUpdateBroadcast +{ + public Guid GameId { get; set; } + public MapUpdateType UpdateType { get; set; } + public Position? Position { get; set; } + public float? Radius { get; set; } + public Guid? OwnerId { get; set; } + public string? ItemId { get; set; } + public DateTime Timestamp { get; set; } + public Dictionary UpdateData { get; set; } = new(); +} + +/// +/// 玩家状态更新 +/// +public class PlayerStatusUpdate +{ + public Guid PlayerId { get; set; } + public string PlayerName { get; set; } = string.Empty; + public Position Position { get; set; } = new(); + public float Health { get; set; } + public float MaxHealth { get; set; } + public PlayerState State { get; set; } + public List ActiveEffects { get; set; } = new(); + public DateTime Timestamp { get; set; } + public Dictionary CustomStatus { get; set; } = new(); +} + +/// +/// 系统通知 +/// +public class SystemNotification +{ + public string Id { get; set; } = string.Empty; + public string Title { get; set; } = string.Empty; + public string Message { get; set; } = string.Empty; + public NotificationType Type { get; set; } + public EventPriority Priority { get; set; } + public TimeSpan? DisplayDuration { get; set; } + public DateTime Timestamp { get; set; } + public Dictionary Data { get; set; } = new(); +} + +/// +/// 在线玩家信息 +/// +public class OnlinePlayer +{ + public Guid PlayerId { get; set; } + public string PlayerName { get; set; } = string.Empty; + public string ConnectionId { get; set; } = string.Empty; + public DateTime ConnectedAt { get; set; } + public PlayerState State { get; set; } + public bool IsReady { get; set; } +} + +/// +/// 事件优先级 +/// +public enum EventPriority +{ + Low, + Normal, + High, + Critical +} + +/// +/// 消息类型 +/// +public enum MessageType +{ + Chat, + System, + Achievement, + Warning, + Info +} + +/// +/// 地图更新类型 +/// +public enum MapUpdateType +{ + TerritoryChanged, + ItemSpawned, + ItemRemoved, + ObstacleAdded, + ObstacleRemoved, + EffectApplied, + EffectRemoved +} + +/// +/// 玩家状态 +/// +public enum PlayerState +{ + Waiting, + Ready, + Playing, + Dead, + Spectating, + Disconnected +} + +/// +/// 通知类型 +/// +public enum NotificationType +{ + Info, + Success, + Warning, + Error, + Achievement +} diff --git a/backend/src/CollabApp.Domain/Services/Game/IGamePlayService.cs b/backend/src/CollabApp.Domain/Services/Game/IGamePlayService.cs new file mode 100644 index 0000000000000000000000000000000000000000..e3815ebe02b47b58eb4475a07e659bcfe714e3b6 --- /dev/null +++ b/backend/src/CollabApp.Domain/Services/Game/IGamePlayService.cs @@ -0,0 +1,307 @@ +using CollabApp.Domain.Entities.Game; + +namespace CollabApp.Domain.Services.Game; + +/// +/// 游戏玩法服务接口 +/// 负责处理游戏核心玩法逻辑，包括移动、攻击、收集等游戏行为 +/// +public interface IGamePlayService +{ + /// + /// 处理玩家移动 + /// 验证移动的合法性，更新玩家位置，检测碰撞和边界 + /// + /// 游戏标识 + /// 玩家标识 + /// 移动命令 + /// 移动处理结果 + Task ProcessPlayerMoveAsync(Guid gameId, Guid playerId, MoveCommand moveCommand); + + /// + /// 处理玩家攻击行为 + /// 验证攻击条件，计算伤害，更新游戏状态 + /// + /// 游戏标识 + /// 攻击者标识 + /// 攻击命令 + /// 攻击处理结果 + Task ProcessPlayerAttackAsync(Guid gameId, Guid attackerId, AttackCommand attackCommand); + + /// + /// 处理物品收集 + /// 验证收集条件，更新玩家库存，移除地图物品 + /// + /// 游戏标识 + /// 玩家标识 + /// 物品标识 + /// 收集处理结果 + Task ProcessItemCollectionAsync(Guid gameId, Guid playerId, Guid itemId); + + /// + /// 使用道具/技能 + /// 验证使用条件，应用道具效果，更新冷却时间 + /// + /// 游戏标识 + /// 玩家标识 + /// 技能使用命令 + /// 技能使用结果 + Task UsePlayerSkillAsync(Guid gameId, Guid playerId, SkillUseCommand skillCommand); + + /// + /// 处理领土占领 + /// 验证占领条件，更新领土归属，计算影响范围 + /// + /// 游戏标识 + /// 玩家标识 + /// 领土命令 + /// 占领处理结果 + Task ProcessTerritoryClaimAsync(Guid gameId, Guid playerId, TerritoryClaimCommand territoryCommand); + + /// + /// 执行游戏规则检查 + /// 检查当前游戏状态是否符合规则要求 + /// + /// 游戏标识 + /// 规则检查结果 + Task ExecuteRuleCheckAsync(Guid gameId); + + /// + /// 获取玩家可执行的行为列表 + /// 基于当前游戏状态和玩家状态，返回合法的行为选项 + /// + /// 游戏标识 + /// 玩家标识 + /// 可用行为列表 + Task> GetAvailableActionsAsync(Guid gameId, Guid playerId); + + /// + /// 计算行为执行的预期结果 + /// 在不实际执行的情况下，模拟行为的影响 + /// + /// 游戏标识 + /// 玩家标识 + /// 行为命令 + /// 预期结果 + Task PredictActionResultAsync(Guid gameId, Guid playerId, IGameActionCommand actionCommand); +} + +/// +/// 移动命令 +/// +public class MoveCommand : IGameActionCommand +{ + public Guid PlayerId { get; set; } + public Position NewPosition { get; set; } = new(); + public Direction Direction { get; set; } + public float Speed { get; set; } + public DateTime Timestamp { get; set; } +} + +/// +/// 攻击命令 +/// +public class AttackCommand : IGameActionCommand +{ + public Guid PlayerId { get; set; } + public Guid? TargetPlayerId { get; set; } + public Position TargetPosition { get; set; } = new(); + public AttackType AttackType { get; set; } + public float Damage { get; set; } + public DateTime Timestamp { get; set; } +} + +/// +/// 技能使用命令 +/// +public class SkillUseCommand : IGameActionCommand +{ + public Guid PlayerId { get; set; } + public string SkillId { get; set; } = string.Empty; + public Position? TargetPosition { get; set; } + public Guid? TargetPlayerId { get; set; } + public Dictionary Parameters { get; set; } = new(); + public DateTime Timestamp { get; set; } +} + +/// +/// 领土占领命令 +/// +public class TerritoryClaimCommand : IGameActionCommand +{ + public Guid PlayerId { get; set; } + public Position Position { get; set; } = new(); + public float Radius { get; set; } + public TerritoryType TerritoryType { get; set; } + public DateTime Timestamp { get; set; } +} + +/// +/// 游戏行为命令基接口 +/// +public interface IGameActionCommand +{ + Guid PlayerId { get; set; } + DateTime Timestamp { get; set; } +} + +/// +/// 移动处理结果 +/// +public class MoveResult +{ + public bool Success { get; set; } + public Position OldPosition { get; set; } = new(); + public Position NewPosition { get; set; } = new(); + public List Errors { get; set; } = new(); + public List TriggeredEvents { get; set; } = new(); +} + +/// +/// 攻击处理结果 +/// +public class AttackResult +{ + public bool Success { get; set; } + public float DamageDealt { get; set; } + public List AffectedPlayers { get; set; } = new(); + public List Errors { get; set; } = new(); + public List TriggeredEvents { get; set; } = new(); +} + +/// +/// 收集处理结果 +/// +public class CollectResult +{ + public bool Success { get; set; } + public string ItemName { get; set; } = string.Empty; + public int Quantity { get; set; } + public List Errors { get; set; } = new(); + public List TriggeredEvents { get; set; } = new(); +} + +/// +/// 技能使用结果 +/// +public class SkillUseResult +{ + public bool Success { get; set; } + public string SkillId { get; set; } = string.Empty; + public TimeSpan CooldownRemaining { get; set; } + public List AffectedPlayers { get; set; } = new(); + public List Errors { get; set; } = new(); + public List TriggeredEvents { get; set; } = new(); +} + +/// +/// 领土占领结果 +/// +public class TerritoryClaimResult +{ + public bool Success { get; set; } + public Guid TerritoryId { get; set; } + public float TerritoryGained { get; set; } + public float TerritoryLost { get; set; } + public float NewTotalArea { get; set; } + public int BonusScore { get; set; } + public List AffectedPlayers { get; set; } = new(); + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); + public List TriggeredEvents { get; set; } = new(); +} + +/// +/// 规则检查结果 +/// +public class RuleCheckResult +{ + public bool IsValid { get; set; } + public List Violations { get; set; } = new(); + public List Warnings { get; set; } = new(); + public List TriggeredEvents { get; set; } = new(); +} + +/// +/// 可用行为 +/// +public class AvailableAction +{ + public string ActionId { get; set; } = string.Empty; + public string ActionName { get; set; } = string.Empty; + public ActionType ActionType { get; set; } + public bool IsAvailable { get; set; } + public string? DisabledReason { get; set; } + public TimeSpan? CooldownRemaining { get; set; } + public Dictionary Parameters { get; set; } = new(); +} + +/// +/// 行为预测结果 +/// +public class ActionPredictionResult +{ + public bool CanExecute { get; set; } + public float SuccessProbability { get; set; } + public List PredictedEffects { get; set; } = new(); + public List Risks { get; set; } = new(); + public Dictionary PredictedChanges { get; set; } = new(); +} + +/// +/// 游戏事件 +/// +public class GameEvent +{ + public string EventType { get; set; } = string.Empty; + public Guid? PlayerId { get; set; } + public string Description { get; set; } = string.Empty; + public DateTime Timestamp { get; set; } + public Dictionary Data { get; set; } = new(); +} + +/// +/// 位置信息 +/// +public class Position +{ + public float X { get; set; } + public float Y { get; set; } + public float Z { get; set; } +} + +/// +/// 方向枚举 +/// +public enum Direction +{ + North, South, East, West, NorthEast, NorthWest, SouthEast, SouthWest +} + +/// +/// 攻击类型 +/// +public enum AttackType +{ + Melee, Ranged, Area, Special +} + +/// +/// 领土类型 +/// +public enum TerritoryType +{ + Basic, // 基础领土 + Fortress, // 要塞领土 + Resource, // 资源领土 + Strategic, // 战略领土 + Circular // 圆形领土（画线圈地专用） +} + +/// +/// 行为类型 +/// +public enum ActionType +{ + Move, Attack, Collect, UseSkill, ClaimTerritory, Defend, Special +} diff --git a/backend/src/CollabApp.Domain/Services/Game/IGameResultService.cs b/backend/src/CollabApp.Domain/Services/Game/IGameResultService.cs new file mode 100644 index 0000000000000000000000000000000000000000..8de17377a9e24cb91f526603303057a15bc942a8 --- /dev/null +++ b/backend/src/CollabApp.Domain/Services/Game/IGameResultService.cs @@ -0,0 +1,303 @@ +using CollabApp.Domain.Entities.Game; + +namespace CollabApp.Domain.Services.Game; + +/// +/// 游戏结果服务接口 +/// 负责计算游戏结果、排名、奖励分配和成就解锁 +/// +public interface IGameResultService +{ + /// + /// 计算游戏最终结果 + /// 基于游戏类型和规则，计算所有玩家的最终成绩和排名 + /// + /// 游戏标识 + /// 游戏结果详情 + Task CalculateGameResultAsync(Guid gameId); + + /// + /// 计算玩家排名 + /// 根据得分、完成时间等因素确定玩家排名 + /// + /// 游戏标识 + /// 玩家排名列表 + Task> CalculatePlayerRankingsAsync(Guid gameId); + + /// + /// 计算经验值奖励 + /// 基于游戏表现和排名计算玩家获得的经验值 + /// + /// 游戏标识 + /// 玩家标识 + /// 经验值奖励详情 + Task CalculateExperienceRewardAsync(Guid gameId, Guid playerId); + + /// + /// 计算积分奖励 + /// 基于游戏结果计算玩家获得的积分 + /// + /// 游戏标识 + /// 玩家标识 + /// 积分奖励详情 + Task CalculateScoreRewardAsync(Guid gameId, Guid playerId); + + /// + /// 检查成就解锁 + /// 检查玩家在游戏中是否达成了特定成就 + /// + /// 游戏标识 + /// 玩家标识 + /// 解锁的成就列表 + Task> CheckAchievementUnlocksAsync(Guid gameId, Guid playerId); + + /// + /// 生成游戏统计报告 + /// 创建详细的游戏数据统计报告 + /// + /// 游戏标识 + /// 统计报告 + Task GenerateStatisticsReportAsync(Guid gameId); + + /// + /// 计算玩家评级变化 + /// 基于游戏结果更新玩家的技能评级 + /// + /// 游戏标识 + /// 玩家标识 + /// 评级变化详情 + Task CalculateRatingChangeAsync(Guid gameId, Guid playerId); + + /// + /// 保存游戏结果到历史记录 + /// 将游戏结果持久化到数据库 + /// + /// 游戏结果 + /// 保存是否成功 + Task SaveGameResultAsync(GameResult gameResult); + + /// + /// 获取历史游戏结果 + /// 检索指定游戏的历史结果数据 + /// + /// 游戏标识 + /// 历史游戏结果，如果不存在则返回null + Task GetGameResultAsync(Guid gameId); + + /// + /// 计算团队奖励 + /// 为团队游戏计算额外的团队协作奖励 + /// + /// 游戏标识 + /// 团队标识 + /// 团队奖励详情 + Task CalculateTeamRewardAsync(Guid gameId, Guid teamId); +} + +/// +/// 游戏结果 +/// +public class GameResult +{ + public Guid GameId { get; set; } + public DateTime StartTime { get; set; } + public DateTime EndTime { get; set; } + public TimeSpan Duration { get; set; } + public GameType GameType { get; set; } + public GameEndReason EndReason { get; set; } + public List PlayerResults { get; set; } = new(); + public GameStatistics Statistics { get; set; } = new(); + public Dictionary Metadata { get; set; } = new(); +} + +/// +/// 玩家结果 +/// +public class PlayerResult +{ + public Guid PlayerId { get; set; } + public string PlayerName { get; set; } = string.Empty; + public int FinalScore { get; set; } + public int Rank { get; set; } + public TimeSpan PlayTime { get; set; } + public bool IsWinner { get; set; } + public PlayerStatistics Statistics { get; set; } = new(); + public List AchievementsUnlocked { get; set; } = new(); + public ExperienceReward ExperienceGained { get; set; } = new(); + public ScoreReward ScoreGained { get; set; } = new(); + public RatingChange RatingChange { get; set; } = new(); +} + +/// +/// 玩家排名 +/// +public class PlayerRanking +{ + public Guid PlayerId { get; set; } + public string PlayerName { get; set; } = string.Empty; + public int Rank { get; set; } + public int Score { get; set; } + public float TerritoryPercentage { get; set; } + public int KillCount { get; set; } + public int DeathCount { get; set; } + public TimeSpan SurvivalTime { get; set; } + public Dictionary CustomMetrics { get; set; } = new(); +} + +/// +/// 经验值奖励 +/// +public class ExperienceReward +{ + public int BaseExperience { get; set; } + public int BonusExperience { get; set; } + public int TotalExperience { get; set; } + public List Sources { get; set; } = new(); + public int LevelBefore { get; set; } + public int LevelAfter { get; set; } + public bool LeveledUp { get; set; } +} + +/// +/// 积分奖励 +/// +public class ScoreReward +{ + public int BaseScore { get; set; } + public int BonusScore { get; set; } + public int TotalScore { get; set; } + public List Sources { get; set; } = new(); + public float Multiplier { get; set; } = 1.0f; +} + +/// +/// 成就 +/// +public class Achievement +{ + public string Id { get; set; } = string.Empty; + public string Name { get; set; } = string.Empty; + public string Description { get; set; } = string.Empty; + public AchievementType Type { get; set; } + public int Points { get; set; } + public DateTime UnlockedAt { get; set; } + public Dictionary Criteria { get; set; } = new(); +} + +/// +/// 游戏统计报告 +/// +public class GameStatisticsReport +{ + public Guid GameId { get; set; } + public DateTime GeneratedAt { get; set; } + public TimeSpan GameDuration { get; set; } + public int TotalPlayers { get; set; } + public int TotalActions { get; set; } + public Dictionary ActionBreakdown { get; set; } = new(); + public PlayerStatistics TopPerformer { get; set; } = new(); + public List KeyEvents { get; set; } = new(); + public Dictionary CustomMetrics { get; set; } = new(); +} + +/// +/// 玩家统计 +/// +public class PlayerStatistics +{ + public Guid PlayerId { get; set; } + public int ActionsPerformed { get; set; } + public int KillCount { get; set; } + public int DeathCount { get; set; } + public float TerritoryControlled { get; set; } + public float MaxTerritoryControlled { get; set; } + public int ItemsCollected { get; set; } + public int SkillsUsed { get; set; } + public float DistanceTraveled { get; set; } + public TimeSpan TimeAlive { get; set; } + public Dictionary DetailedStats { get; set; } = new(); +} + +/// +/// 评级变化 +/// +public class RatingChange +{ + public int RatingBefore { get; set; } + public int RatingAfter { get; set; } + public int Change { get; set; } + public RatingTier TierBefore { get; set; } + public RatingTier TierAfter { get; set; } + public bool TierChanged { get; set; } + public string Reason { get; set; } = string.Empty; +} + +/// +/// 团队奖励 +/// +public class TeamReward +{ + public Guid TeamId { get; set; } + public int BaseReward { get; set; } + public int CooperationBonus { get; set; } + public int TotalReward { get; set; } + public List MemberRewards { get; set; } = new(); +} + +/// +/// 团队成员奖励 +/// +public class TeamMemberReward +{ + public Guid PlayerId { get; set; } + public int IndividualReward { get; set; } + public int TeamBonus { get; set; } + public int TotalReward { get; set; } +} + +/// +/// 经验值来源 +/// +public class ExperienceSource +{ + public string Source { get; set; } = string.Empty; + public int Amount { get; set; } + public string Description { get; set; } = string.Empty; +} + +/// +/// 积分来源 +/// +public class ScoreSource +{ + public string Source { get; set; } = string.Empty; + public int Amount { get; set; } + public string Description { get; set; } = string.Empty; +} + +/// +/// 成就类型 +/// +public enum AchievementType +{ + Combat, // 战斗相关 + Territory, // 领土相关 + Survival, // 生存相关 + Collection, // 收集相关 + Social, // 社交相关 + Special // 特殊成就 +} + +/// +/// 评级等级 +/// +public enum RatingTier +{ + Bronze, + Silver, + Gold, + Platinum, + Diamond, + Master, + Grandmaster +} diff --git a/backend/src/CollabApp.Domain/Services/Game/IGameStateService.cs b/backend/src/CollabApp.Domain/Services/Game/IGameStateService.cs new file mode 100644 index 0000000000000000000000000000000000000000..2818f1eb01109dce0622fd4454f99d3af09ddb75 --- /dev/null +++ b/backend/src/CollabApp.Domain/Services/Game/IGameStateService.cs @@ -0,0 +1,199 @@ +using CollabApp.Domain.Entities.Game; + +namespace CollabApp.Domain.Services.Game; + +/// +/// 游戏状态管理服务接口 +/// 负责管理游戏的整体状态，包括游戏生命周期、状态转换和状态验证 +/// +public interface IGameStateService +{ + /// + /// 初始化新游戏 + /// 创建游戏实例，设置初始状态，配置游戏参数 + /// + /// 游戏唯一标识 + /// 房间标识 + /// 游戏配置参数 + /// 初始化后的游戏实例 + Task InitializeGameAsync(Guid gameId, Guid roomId, GameSettings gameSettings); + + /// + /// 开始游戏 + /// 将游戏状态从等待转为进行中，启动游戏计时器 + /// + /// 游戏标识 + /// 操作是否成功 + Task StartGameAsync(Guid gameId); + + /// + /// 结束游戏 + /// 终止游戏进程，计算最终结果，清理资源 + /// + /// 游戏标识 + /// 结束原因 + /// 游戏结束结果 + Task EndGameAsync(Guid gameId, GameEndReason reason); + + /// + /// 获取游戏当前状态 + /// 返回游戏的实时状态信息 + /// + /// 游戏标识 + /// 游戏状态信息 + Task GetGameStateAsync(Guid gameId); + + /// + /// 验证状态转换的合法性 + /// 检查从当前状态到目标状态的转换是否被允许 + /// + /// 游戏标识 + /// 目标状态 + /// 转换是否合法 + Task ValidateStateTransitionAsync(Guid gameId, Entities.Game.GameStatus targetState); + + /// + /// 更新游戏状态 + /// 执行状态转换并触发相关事件 + /// + /// 游戏标识 + /// 新状态 + /// 状态更新的元数据 + /// 更新是否成功 + Task UpdateGameStateAsync(Guid gameId, Entities.Game.GameStatus newState, Dictionary? metadata = null); +} + +/// +/// 游戏配置参数 +/// +public class GameSettings +{ + public TimeSpan Duration { get; set; } = TimeSpan.FromMinutes(3); + public int MaxPlayers { get; set; } = 6; + public int MinPlayers { get; set; } = 2; + public GameMode GameMode { get; set; } = GameMode.Classic; + public int MapWidth { get; set; } = 1000; + public int MapHeight { get; set; } = 1000; + public string MapShape { get; set; } = "circle"; + public bool EnableDynamicBalance { get; set; } = true; + public int PowerUpSpawnInterval { get; set; } = 25; + public int MaxPowerUps { get; set; } = 3; + public int SpecialEventChance { get; set; } = 0; + public Dictionary CustomSettings { get; set; } = new(); +} + +/// +/// 游戏结束结果 +/// +public class GameEndResult +{ + public Guid GameId { get; set; } + public GameEndReason Reason { get; set; } + public DateTime EndTime { get; set; } + public List PlayerResults { get; set; } = new(); + public GameStatistics Statistics { get; set; } = new(); +} + +/// +/// 游戏状态信息 +/// +public class GameStateInfo +{ + public Guid GameId { get; set; } + public Entities.Game.GameStatus Status { get; set; } + public DateTime StartTime { get; set; } + public TimeSpan ElapsedTime { get; set; } + public TimeSpan? RemainingTime { get; set; } + public int ConnectedPlayers { get; set; } + public Dictionary StateData { get; set; } = new(); +} + +/// +/// 玩家游戏结果 +/// +public class PlayerGameResult +{ + public Guid PlayerId { get; set; } + public string PlayerName { get; set; } = string.Empty; + public int Score { get; set; } + public int Rank { get; set; } + public TimeSpan PlayTime { get; set; } + public Dictionary Statistics { get; set; } = new(); +} + +/// +/// 游戏统计信息 +/// +public class GameStatistics +{ + public TimeSpan TotalDuration { get; set; } + public int TotalActions { get; set; } + public int TotalPlayers { get; set; } + public Dictionary ActionCounts { get; set; } = new(); + public Dictionary CustomStats { get; set; } = new(); +} + +/// +/// 游戏结束原因 +/// +public enum GameEndReason +{ + Completed, // 正常完成 + TimeExpired, // 时间到 + PlayerLeft, // 玩家离开 + ServerError, // 服务器错误 + AdminTerminated // 管理员终止 +} + +/// +/// 游戏类型 +/// +public enum GameType +{ + Territory, // 领土争夺 + Survival, // 生存模式 + Race, // 竞速模式 + Puzzle // 解谜模式 +} + +/// +/// 游戏模式枚举 +/// +public enum GameMode +{ + /// + /// 经典模式：标准规则，适合所有玩家 + /// + Classic, + + /// + /// 极速模式：移动速度+50%，90秒快速对战 + /// + Speed, + + /// + /// 道具狂欢：道具刷新频率×3，效果时间×1.5，特殊事件 + /// + PowerUpCarnival, + + /// + /// 生存模式：只有一条命，死亡即出局 + /// + Survival, + + /// + /// 团队模式：2v2或3v3，队友领地可以连通 + /// + Team +} + +/// +/// 难度等级 +/// +public enum DifficultyLevel +{ + Easy, + Normal, + Hard, + Expert +} diff --git a/backend/src/CollabApp.Domain/Services/Game/IPlayerStateService.cs b/backend/src/CollabApp.Domain/Services/Game/IPlayerStateService.cs new file mode 100644 index 0000000000000000000000000000000000000000..31f0b519b8f541e20e7a2327ae1d9702af027059 --- /dev/null +++ b/backend/src/CollabApp.Domain/Services/Game/IPlayerStateService.cs @@ -0,0 +1,744 @@ +using CollabApp.Domain.Entities.Game; + +namespace CollabApp.Domain.Services.Game; + +/// +/// 画线圈地游戏 - 玩家状态管理服务接口 +/// +/// 职责说明： +/// 1. 管理游戏中玩家的完整状态（位置、画线、领地、道具） +/// 2. 处理玩家移动和画线轨迹的实时更新 +/// 3. 执行碰撞检测和死亡/复活机制 +/// 4. 计算和维护玩家领地面积和排名 +/// 5. 管理道具拾取、使用和效果系统 +/// +/// 业务规则遵循： +/// - 严格按照画线圈地游戏规则执行碰撞检测 +/// - 玩家死亡后5秒复活，带有无敌时间 +/// - 实时计算领地面积并更新排名 +/// - 道具效果时长和作用严格按照游戏设定 +/// - 确保游戏公平性和一致性 +/// +/// 设计原则： +/// - 所有操作异步执行，支持高并发 +/// - 使用事件驱动模式通知状态变更 +/// - 实现完整的错误处理和业务验证 +/// - 支持实时状态查询和历史追踪 +/// +public interface IPlayerStateService +{ + #region 玩家基础状态管理 + + /// + /// 获取玩家完整游戏状态 + /// + /// 返回信息包括： + /// 1. 基础信息：ID、姓名、颜色、位置 + /// 2. 游戏状态：画线状态、生存状态、无敌状态 + /// 3. 领地信息：拥有的所有领地、总面积、排名 + /// 4. 道具信息：背包道具、活跃效果、剩余时长 + /// 5. 统计信息：移动距离、死亡次数、击杀次数 + /// + /// 性能优化： + /// - 支持缓存机制，减少数据库查询 + /// - 增量更新，只返回变化的部分 + /// - 批量查询，支持同时获取多个玩家状态 + /// + /// 游戏标识 + /// 玩家标识 + /// 玩家完整状态信息 + Task GetPlayerStateAsync(Guid gameId, Guid playerId); + + /// + /// 获取游戏中所有玩家状态 + /// + /// 用途： + /// 1. 游戏界面显示所有玩家信息 + /// 2. 排行榜计算和显示 + /// 3. 游戏结束时的最终统计 + /// 4. 管理员监控和调试 + /// + /// 游戏标识 + /// 所有玩家状态列表 + Task> GetAllPlayerStatesAsync(Guid gameId); + + /// + /// 初始化玩家游戏状态 + /// + /// 初始化内容： + /// 1. 分配玩家专属颜色（红、蓝、绿、黄、紫、橙、粉、青） + /// 2. 设置出生点位置（地图边缘均匀分布） + /// 3. 创建初始安全区域（出生点周围小片领地） + /// 4. 初始化统计数据和背包 + /// 5. 设置玩家状态为Idle + /// + /// 分配规则： + /// - 颜色按加入顺序分配，避免重复 + /// - 出生点距离其他玩家尽可能远 + /// - 初始安全区域大小固定（50x50像素） + /// + /// 游戏标识 + /// 玩家标识 + /// 玩家昵称 + /// 初始化结果，包含分配的颜色和出生点 + Task InitializePlayerStateAsync(Guid gameId, Guid playerId, string playerName); + + #endregion + + #region 移动和画线系统 + + /// + /// 更新玩家位置并处理移动逻辑 + /// + /// 移动处理流程： + /// 1. 验证移动的合法性（速度限制、边界检查） + /// 2. 计算实际移动距离和方向 + /// 3. 检测移动路径上的碰撞（边界、障碍物、其他玩家轨迹） + /// 4. 如果正在画线，添加轨迹点 + /// 5. 更新玩家统计数据（移动距离） + /// 6. 触发相关游戏事件 + /// + /// 碰撞处理： + /// - 边界碰撞：阻止移动，保持原位置 + /// - 障碍物碰撞：阻止移动，保持原位置 + /// - 轨迹碰撞：如果正在画线，触发死亡；否则正常穿过 + /// - 领地穿越：允许穿越，但不能在其他玩家领地内开始画线 + /// + /// 速度加成： + /// - 基础速度：每秒100像素 + /// - 闪电道具：速度提升50%，每秒150像素 + /// - 速度限制：防止作弊，最大不超过200像素/秒 + /// + /// 游戏标识 + /// 玩家标识 + /// 目标位置 + /// 移动时间戳 + /// 是否正在画线 + /// 位置更新结果，包含实际位置和碰撞信息 + Task UpdatePlayerPositionAsync( + Guid gameId, + Guid playerId, + Position newPosition, + DateTime timestamp, + bool isDrawing = false); + + /// + /// 玩家开始画线 + /// + /// 开始条件检查： + /// 1. 玩家必须处于Idle状态（非死亡、非画线中） + /// 2. 开始位置必须在玩家的领地内或出生点 + /// 3. 玩家不能处于其他玩家的领地内 + /// 4. 玩家不能处于无敌状态结束前 + /// + /// 开始画线处理： + /// 1. 验证开始位置的合法性 + /// 2. 清空之前的轨迹（如果有） + /// 3. 设置玩家状态为Drawing + /// 4. 记录画线开始时间和位置 + /// 5. 初始化轨迹点列表 + /// 6. 广播画线开始事件 + /// + /// 错误情况： + /// - 不在自己领地内开始：返回错误 + /// - 已经在画线中：返回错误 + /// - 玩家已死亡：返回错误 + /// + /// 游戏标识 + /// 玩家标识 + /// 开始画线的位置 + /// 画线开始结果 + Task StartDrawingAsync(Guid gameId, Guid playerId, Position startPosition); + + /// + /// 玩家停止画线并尝试圈地 + /// + /// 停止画线处理： + /// 1. 验证玩家确实在画线状态 + /// 2. 检查画线轨迹是否形成闭合回路 + /// 3. 如果闭合，计算新领地面积 + /// 4. 验证新领地的合法性（不与现有领地冲突） + /// 5. 更新玩家领地和面积统计 + /// 6. 设置玩家状态回到Idle + /// 7. 广播圈地成功/失败事件 + /// + /// 闭合回路判定： + /// 1. 轨迹终点必须回到玩家的现有领地 + /// 2. 轨迹不能自相交（除了起点和终点） + /// 3. 形成的区域必须有有效面积（>100像素²） + /// + /// 面积计算： + /// - 使用多边形面积计算算法（Shoelace公式） + /// - 排除已属于其他玩家的区域 + /// - 包含区域内的道具和中立区域 + /// + /// 特殊情况： + /// - 未形成闭合：清除轨迹，回到Idle状态 + /// - 包含其他玩家：只获得未被占领的部分 + /// - 面积过小：不获得领地，清除轨迹 + /// + /// 游戏标识 + /// 玩家标识 + /// 结束画线的位置 + /// 画线结束结果，包含新获得的领地信息 + Task StopDrawingAsync(Guid gameId, Guid playerId, Position endPosition); + + #endregion + + #region 碰撞和战斗系统 + + /// + /// 处理玩家轨迹被其他玩家碰撞（截断死亡） + /// + /// 碰撞检测逻辑： + /// 1. 检测碰撞发生的精确位置和时间 + /// 2. 验证碰撞的合法性（攻击者不能是自己） + /// 3. 确认被攻击者正在画线状态 + /// 4. 计算碰撞的影响范围 + /// + /// 死亡处理： + /// 1. 立即清除被攻击者的所有轨迹 + /// 2. 设置被攻击者状态为Dead + /// 3. 记录死亡原因和攻击者信息 + /// 4. 更新攻击者击杀统计 + /// 5. 启动5秒复活倒计时 + /// 6. 广播玩家死亡事件 + /// + /// 护盾道具效果： + /// - 如果被攻击者有活跃的护盾：免疫此次攻击 + /// - 消耗护盾效果，继续游戏 + /// - 显示护盾抵挡特效 + /// + /// 统计更新： + /// - 被攻击者：死亡次数+1 + /// - 攻击者：击杀次数+1 + /// - 游戏总体：总死亡数+1 + /// + /// 游戏标识 + /// 被攻击的玩家标识 + /// 碰撞发生位置 + /// 攻击者玩家标识（可选，可能是自己撞到自己） + /// 碰撞处理结果 + Task HandleTrailCollisionAsync( + Guid gameId, + Guid victimPlayerId, + Position collisionPosition, + Guid? attackerPlayerId = null); + + /// + /// 处理玩家死亡的完整流程 + /// + /// 死亡类型： + /// 1. 轨迹被其他玩家碰撞（最常见） + /// 2. 撞到自己的轨迹（自杀） + /// 3. 撞到地图边界（边界死亡） + /// 4. 撞到障碍物（障碍死亡） + /// 5. 其他特殊情况（如炸弹攻击） + /// + /// 死亡处理步骤： + /// 1. 记录死亡时间、位置和原因 + /// 2. 清除玩家当前所有轨迹 + /// 3. 保留玩家已占领的领地 + /// 4. 更新玩家状态为Dead + /// 5. 计算复活倒计时（5秒） + /// 6. 清除玩家身上的临时道具效果 + /// 7. 更新死亡统计数据 + /// 8. 广播死亡事件给所有玩家 + /// + /// 复活准备： + /// - 设置复活位置为出生点 + /// - 预计算复活后的无敌时间（5秒） + /// - 清理死亡位置周围的干扰因素 + /// + /// 游戏标识 + /// 死亡的玩家标识 + /// 死亡原因描述 + /// 击杀者标识（如果有） + /// 死亡位置 + /// 死亡处理结果 + Task HandlePlayerDeathAsync( + Guid gameId, + Guid playerId, + string deathReason, + Guid? killerId = null, + Position? deathPosition = null); + + /// + /// 复活已死亡的玩家 + /// + /// 复活条件检查： + /// 1. 玩家必须处于Dead状态 + /// 2. 复活倒计时必须已结束 + /// 3. 游戏必须仍在进行中 + /// 4. 出生点位置必须安全（无其他玩家占据） + /// + /// 复活处理： + /// 1. 将玩家传送到出生点位置 + /// 2. 设置玩家状态为Invulnerable（无敌） + /// 3. 启动5秒无敌时间倒计时 + /// 4. 重置玩家速度和临时效果 + /// 5. 清空画线轨迹缓存 + /// 6. 广播玩家复活事件 + /// + /// 无敌机制： + /// - 无敌期间不会因碰撞死亡 + /// - 无敌期间不能画线 + /// - 无敌期间可以正常移动 + /// - 视觉效果：玩家闪烁显示 + /// - 5秒后自动结束无敌状态 + /// + /// 异常处理： + /// - 出生点被占据：延迟复活，等待位置清空 + /// - 复活过程中断：重新开始复活流程 + /// - 游戏已结束：取消复活操作 + /// + /// 游戏标识 + /// 要复活的玩家标识 + /// 复活操作结果 + Task RespawnPlayerAsync(Guid gameId, Guid playerId); + + #endregion + + #region 领地和排名系统 + + /// + /// 计算玩家当前总领地面积 + /// + /// 计算方法： + /// 1. 遍历玩家拥有的所有领地区域 + /// 2. 使用几何算法计算每块领地的精确面积 + /// 3. 处理领地重叠部分（去重计算） + /// 4. 排除被其他玩家侵占的部分 + /// 5. 累加得出总面积 + /// + /// 面积单位： + /// - 使用像素平方（px²）作为基础单位 + /// - 支持转换为百分比（相对于地图总面积） + /// - 支持转换为游戏内积分 + /// + /// 优化策略： + /// - 使用空间索引加速面积计算 + /// - 缓存计算结果，避免重复计算 + /// - 增量更新，只重新计算变化的部分 + /// + /// 精度保证： + /// - 使用高精度浮点数计算 + /// - 考虑像素边界的影响 + /// - 处理边缘情况和数值误差 + /// + /// 游戏标识 + /// 玩家标识 + /// 领地计算结果 + Task CalculatePlayerTerritoryAsync(Guid gameId, Guid playerId); + + /// + /// 获取游戏实时排名 + /// + /// 排名规则： + /// 1. 主要依据：当前领地总面积（降序） + /// 2. 面积相同时：先达到该面积的玩家排名靠前 + /// 3. 同时达到：按玩家加入游戏的顺序 + /// 4. 死亡玩家：保持死亡前的排名 + /// 5. 离线玩家：保持离线前的排名 + /// + /// 排名计算： + /// - 实时计算，每次移动/圈地后更新 + /// - 支持缓存机制，减少计算开销 + /// - 提供排名变化历史记录 + /// - 支持并发访问和更新 + /// + /// 显示信息： + /// - 排名位置（1-8名） + /// - 玩家基本信息（昵称、颜色） + /// - 当前领地面积和百分比 + /// - 领地数量统计 + /// - 当前状态（存活/死亡/离线） + /// + /// 性能优化： + /// - 批量计算所有玩家面积 + /// - 使用内存排序而非数据库排序 + /// - 支持分页查询大量玩家 + /// + /// 游戏标识 + /// 实时排名列表 + Task> GetGameRankingAsync(Guid gameId); + + #endregion + + #region 道具系统 + + /// + /// 玩家拾取地图上的道具 + /// + /// 拾取条件检查： + /// 1. 玩家必须存活（非死亡状态） + /// 2. 玩家位置与道具位置足够接近（<20像素） + /// 3. 道具必须仍然存在且未过期 + /// 4. 玩家背包未满（最多持有3个道具） + /// 5. 玩家不处于无敌状态 + /// + /// 拾取处理： + /// 1. 验证拾取条件的合法性 + /// 2. 从地图上移除该道具 + /// 3. 将道具添加到玩家背包 + /// 4. 更新道具拾取统计 + /// 5. 广播道具被拾取事件 + /// 6. 触发道具拾取音效和特效 + /// + /// 道具类型识别： + /// - 闪电道具：金黄色闪电图标 + /// - 护盾道具：蓝色盾牌图标 + /// - 炸弹道具：红色炸弹图标 + /// + /// 背包管理： + /// - 同类道具可叠加 + /// - 不同道具分别计数 + /// - 背包满时阻止拾取 + /// - 支持道具丢弃功能 + /// + /// 异常处理： + /// - 道具已被其他玩家拾取：返回失败 + /// - 网络延迟导致的重复拾取：去重处理 + /// - 背包状态不一致：重新同步 + /// + /// 游戏标识 + /// 玩家标识 + /// 道具标识 + /// 拾取位置 + /// 道具拾取结果 + Task PickupItemAsync( + Guid gameId, + Guid playerId, + Guid itemId, + Position pickupPosition); + + /// + /// 玩家使用背包中的道具 + /// + /// 道具效果详解： + /// + /// 1. 闪电道具 (Lightning)： + /// - 效果：移动速度提升50% + /// - 持续时间：10秒 + /// - 视觉效果：玩家周围闪电特效 + /// - 叠加规则：不可叠加，重复使用刷新时间 + /// - 使用限制：任何状态下都可使用 + /// + /// 2. 护盾道具 (Shield)： + /// - 效果：免疫下一次轨迹碰撞攻击 + /// - 持续时间：15秒或被攻击一次 + /// - 视觉效果：玩家周围蓝色护盾光环 + /// - 叠加规则：不可叠加，重复使用刷新时间 + /// - 使用限制：死亡状态下不可使用 + /// + /// 3. 炸弹道具 (Bomb)： + /// - 效果：清除指定位置周围轨迹（半径100像素） + /// - 持续时间：瞬间效果 + /// - 视觉效果：爆炸动画和声效 + /// - 目标选择：需要指定目标位置 + /// - 使用限制：不能在自己领地内使用 + /// + /// 使用处理流程： + /// 1. 验证玩家背包中是否有该道具 + /// 2. 检查道具使用条件和限制 + /// 3. 消耗背包中的道具数量 + /// 4. 应用道具效果到玩家状态 + /// 5. 设置效果持续时间和属性 + /// 6. 广播道具使用事件 + /// 7. 更新道具使用统计 + /// + /// 特殊情况处理： + /// - 炸弹道具：需要验证目标位置合法性 + /// - 效果冲突：新效果覆盖旧效果 + /// - 使用失败：返还道具到背包 + /// + /// 游戏标识 + /// 玩家标识 + /// 要使用的道具类型 + /// 目标位置（炸弹道具需要） + /// 道具使用结果 + Task UseItemAsync( + Guid gameId, + Guid playerId, + DrawingGameItemType itemType, + Position? targetPosition = null); + + #endregion +} + +#region 数据传输对象和枚举 + +/// +/// 玩家画线状态枚举 +/// +public enum PlayerDrawingState +{ + Idle, // 空闲状态 - 玩家可以开始画线 + Drawing, // 正在画线 - 玩家正在移动并留下轨迹 + Dead, // 死亡状态 - 玩家已死亡，无法移动 + Respawning, // 重生中 - 死亡后等待复活 + Invulnerable // 无敌状态 - 复活后5秒内免疫攻击 +} + +/// +/// 画线圈地游戏道具类型枚举 +/// +public enum DrawingGameItemType +{ + Lightning, // 闪电道具 - 移动速度提升50%，持续10秒 + Shield, // 护盾道具 - 免疫一次截断攻击，持续15秒 + Bomb, // 炸弹道具 - 清除周围小范围内所有玩家轨迹 + SpeedBoost, // 加速道具 - 移动速度提升（与闪电类似） + SlowTrap, // 减速陷阱 - 放置陷阱减缓其他玩家 + Teleport // 传送道具 - 瞬移到指定位置 +} + +/// +/// 画线圈地游戏碰撞类型枚举 +/// +public enum DrawingGameCollisionType +{ + TrailCollision, // 轨迹碰撞（截断）- 最常见的死亡原因 + TerritoryEntry, // 进入其他玩家领地 - 可以穿越但不能画线 + BoundaryHit, // 撞到地图边界 - 阻止移动 + ObstacleHit // 撞到障碍物 - 阻止移动 +} + +/// +/// 玩家游戏状态 - 完整的玩家信息 +/// +public class PlayerGameState +{ + public Guid PlayerId { get; set; } + public string PlayerName { get; set; } = string.Empty; + public string PlayerColor { get; set; } = string.Empty; + public Position CurrentPosition { get; set; } = new(); + public Position SpawnPoint { get; set; } = new(); + public PlayerDrawingState State { get; set; } = PlayerDrawingState.Idle; + public List CurrentTrail { get; set; } = new(); + public List OwnedTerritories { get; set; } = new(); + public float TotalTerritoryArea { get; set; } + public int CurrentRank { get; set; } + public List Inventory { get; set; } = new(); + public List ActiveEffects { get; set; } = new(); + public bool IsInvulnerable { get; set; } + public DateTime? InvulnerabilityEndTime { get; set; } + public DateTime LastActivity { get; set; } + public PlayerGameStatistics Statistics { get; set; } = new(); +} + +/// +/// 玩家初始化结果 +/// +public class PlayerInitResult +{ + public bool Success { get; set; } + public string AssignedColor { get; set; } = string.Empty; + public Position SpawnPoint { get; set; } = new(); + public Territory InitialTerritory { get; set; } = new(); + public int PlayerNumber { get; set; } + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} + +/// +/// 位置更新结果 +/// +public class PositionUpdateResult +{ + public bool Success { get; set; } + public Position OldPosition { get; set; } = new(); + public Position NewPosition { get; set; } = new(); + public float DistanceMoved { get; set; } + public float CurrentSpeed { get; set; } + public bool CollisionDetected { get; set; } + public PlayerCollisionInfo? CollisionInfo { get; set; } + public List Events { get; set; } = new(); + public List Errors { get; set; } = new(); +} + +/// +/// 画线开始结果 +/// +public class DrawingStartResult +{ + public bool Success { get; set; } + public Position StartPosition { get; set; } = new(); + public DateTime StartTime { get; set; } + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} + +/// +/// 画线结束结果 +/// +public class DrawingEndResult +{ + public bool Success { get; set; } + public Position EndPosition { get; set; } = new(); + public List CompletedTrail { get; set; } = new(); + public Territory? NewTerritory { get; set; } + public float AreaGained { get; set; } + public bool IsClosedLoop { get; set; } + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} + +/// +/// 玩家碰撞处理结果 +/// +public class PlayerCollisionHandleResult +{ + public bool Success { get; set; } + public bool PlayerDied { get; set; } + public Guid? KillerId { get; set; } + public string? KillerName { get; set; } + public List ClearedTrail { get; set; } = new(); + public string DeathReason { get; set; } = string.Empty; + public bool ShieldBlocked { get; set; } + public List Messages { get; set; } = new(); +} + +/// +/// 死亡结果 +/// +public class DeathResult +{ + public bool Success { get; set; } + public string DeathReason { get; set; } = string.Empty; + public Guid? KillerId { get; set; } + public string? KillerName { get; set; } + public Position DeathPosition { get; set; } = new(); + public List ClearedTrail { get; set; } = new(); + public DateTime RespawnTime { get; set; } + public List Messages { get; set; } = new(); +} + +/// +/// 复活结果 +/// +public class RespawnResult +{ + public bool Success { get; set; } + public Position RespawnPosition { get; set; } = new(); + public DateTime InvulnerabilityEndTime { get; set; } + public TimeSpan InvulnerabilityDuration { get; set; } = TimeSpan.FromSeconds(5); + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} + +/// +/// 领地计算结果 +/// +public class TerritoryResult +{ + public bool Success { get; set; } + public float TotalArea { get; set; } + public List Territories { get; set; } = new(); + public int TerritoryCount { get; set; } + public float AreaPercentage { get; set; } + public List Messages { get; set; } = new(); +} + +/// +/// 道具拾取结果 +/// +public class ItemPickupResult +{ + public bool Success { get; set; } + public Guid ItemId { get; set; } + public DrawingGameItemType ItemType { get; set; } + public Position PickupPosition { get; set; } = new(); + public bool InventoryFull { get; set; } + public int NewItemCount { get; set; } + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} + +/// +/// 道具使用结果 +/// +public class ItemUseResult +{ + public bool Success { get; set; } + public DrawingGameItemType ItemType { get; set; } + public ActiveEffect? AppliedEffect { get; set; } + public List? ClearedTrails { get; set; } + public List? AffectedPlayers { get; set; } + public Position? TargetPosition { get; set; } + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} + +/// +/// 玩家碰撞信息 +/// +public class PlayerCollisionInfo +{ + public DrawingGameCollisionType Type { get; set; } + public Guid? OtherPlayerId { get; set; } + public Position CollisionPoint { get; set; } = new(); + public string Description { get; set; } = string.Empty; +} + +/// +/// 领地区域 +/// +public class Territory +{ + public Guid Id { get; set; } + public Guid PlayerId { get; set; } + public List Boundary { get; set; } = new(); + public float Area { get; set; } + public DateTime CapturedTime { get; set; } + public string Color { get; set; } = string.Empty; +} + +/// +/// 活跃道具效果 +/// +public class ActiveEffect +{ + public Guid Id { get; set; } + public DrawingGameItemType EffectType { get; set; } + public DateTime StartTime { get; set; } + public TimeSpan Duration { get; set; } + public DateTime EndTime => StartTime.Add(Duration); + public bool IsExpired => DateTime.UtcNow > EndTime; + public Dictionary Properties { get; set; } = new(); +} + +/// +/// 玩家游戏排名信息 +/// +public class PlayerGameRanking +{ + public int Rank { get; set; } + public Guid PlayerId { get; set; } + public string PlayerName { get; set; } = string.Empty; + public string PlayerColor { get; set; } = string.Empty; + public float TerritoryArea { get; set; } + public int TerritoryCount { get; set; } + public float AreaPercentage { get; set; } + public PlayerDrawingState CurrentState { get; set; } + public DateTime LastUpdate { get; set; } +} + +/// +/// 玩家游戏统计信息 +/// +public class PlayerGameStatistics +{ + public int Deaths { get; set; } + public int Kills { get; set; } + public float MaxTerritoryArea { get; set; } + public float TotalDistanceMoved { get; set; } + public int ItemsUsed { get; set; } + public int ItemsPickedUp { get; set; } + public TimeSpan TotalDrawingTime { get; set; } + public int TerritoryCaptures { get; set; } + public DateTime GameStartTime { get; set; } + public DateTime LastActivity { get; set; } +} + +#endregion diff --git a/backend/src/CollabApp.Domain/Services/Game/IPowerUpService.cs b/backend/src/CollabApp.Domain/Services/Game/IPowerUpService.cs new file mode 100644 index 0000000000000000000000000000000000000000..488852ae384a10384c2653da76209c201f1c7a1e --- /dev/null +++ b/backend/src/CollabApp.Domain/Services/Game/IPowerUpService.cs @@ -0,0 +1,323 @@ +using CollabApp.Domain.Entities.Game; + +namespace CollabApp.Domain.Services.Game; + +/// +/// 圈地游戏道具系统服务接口 +/// 负责管理游戏中的四种核心道具：闪电、护盾、炸弹、幽灵 +/// 实现智能刷新机制、道具效果管理和平衡性控制 +/// +public interface IPowerUpService +{ + /// + /// 智能生成道具 + /// 根据玩家密度和领地分布调整刷新位置，优先在无人领地区域生成 + /// + /// 游戏标识 + /// 是否排除被占领的区域 + /// 生成的道具列表 + Task> SpawnPowerUpsAsync(Guid gameId, bool excludeOccupiedAreas = true); + + /// + /// 玩家拾取道具 + /// 玩家接近道具时自动拾取，每个玩家最多持有1个道具 + /// + /// 游戏标识 + /// 玩家标识 + /// 道具标识 + /// 玩家位置 + /// 拾取结果 + Task PickupPowerUpAsync(Guid gameId, Guid playerId, Guid powerUpId, Position playerPosition); + + /// + /// 使用闪电道具 + /// 效果：移动速度提升60%，持续8秒，但画线轨迹更粗（3像素）更易被发现 + /// + /// 游戏标识 + /// 玩家标识 + /// 闪电道具使用结果 + Task UseLightningPowerUpAsync(Guid gameId, Guid playerId); + + /// + /// 使用护盾道具 + /// 效果：免疫一次截断攻击，持续12秒或触发一次保护，使用时移动速度降低10% + /// + /// 游戏标识 + /// 玩家标识 + /// 护盾道具使用结果 + Task UseShieldPowerUpAsync(Guid gameId, Guid playerId); + + /// + /// 使用炸弹道具 + /// 效果：以当前位置为中心，半径30像素范围变成领地，只能在中立区域或己方领地使用 + /// + /// 游戏标识 + /// 玩家标识 + /// 目标位置 + /// 炸弹道具使用结果 + Task UseBombPowerUpAsync(Guid gameId, Guid playerId, Position targetPosition); + + /// + /// 使用幽灵道具 + /// 效果：10秒内可以穿越敌方轨迹而不死亡，但不能圈地 + /// + /// 游戏标识 + /// 玩家标识 + /// 幽灵道具使用结果 + Task UseGhostPowerUpAsync(Guid gameId, Guid playerId); + + /// + /// 获取玩家当前道具 + /// 每个玩家最多持有1个道具 + /// + /// 游戏标识 + /// 玩家标识 + /// 玩家持有的道具，如果没有返回null + Task GetPlayerPowerUpAsync(Guid gameId, Guid playerId); + + /// + /// 获取玩家活跃道具效果 + /// 获取玩家当前所有活跃的道具效果（闪电、护盾、幽灵等） + /// + /// 游戏标识 + /// 玩家标识 + /// 活跃效果列表 + Task> GetActiveEffectsAsync(Guid gameId, Guid playerId); + + /// + /// 获取地图上所有道具 + /// 获取当前地图上存在的所有道具点 + /// + /// 游戏标识 + /// 地图道具列表 + Task> GetMapPowerUpsAsync(Guid gameId); + + /// + /// 更新道具效果状态 + /// 每帧调用，更新所有活跃道具效果的剩余时间和状态 + /// + /// 游戏标识 + /// 时间增量（毫秒） + /// 更新结果，包含过期的效果列表 + Task UpdatePowerUpEffectsAsync(Guid gameId, long deltaTime); + + /// + /// 检查护盾是否能阻挡攻击 + /// 当玩家轨迹被攻击时检查是否有护盾保护 + /// + /// 游戏标识 + /// 被攻击的玩家标识 + /// 护盾检查结果 + Task CheckShieldBlockAsync(Guid gameId, Guid playerId); + + /// + /// 检查幽灵状态 + /// 检查玩家是否处于幽灵状态（可以穿越敌方轨迹） + /// + /// 游戏标识 + /// 玩家标识 + /// 是否处于幽灵状态 + Task IsPlayerInGhostModeAsync(Guid gameId, Guid playerId); + + /// + /// 获取玩家当前移动速度 + /// 考虑闪电道具和护盾道具的速度影响 + /// + /// 游戏标识 + /// 玩家标识 + /// 当前移动速度倍率 + Task GetPlayerSpeedMultiplierAsync(Guid gameId, Guid playerId); + + /// + /// 清理过期道具 + /// 清理地图上过期的道具，为新道具让出空间 + /// + /// 游戏标识 + /// 清理的道具数量 + Task CleanupExpiredPowerUpsAsync(Guid gameId); + + /// + /// 获取道具刷新配置 + /// 根据游戏模式获取道具刷新间隔和数量配置 + /// + /// 游戏模式 + /// 道具刷新配置 + PowerUpSpawnConfig GetPowerUpConfig(string gameMode); +} + +/// +/// 圈地游戏道具类型枚举 +/// +public enum TerritoryGamePowerUpType +{ + /// + /// 闪电道具（蓝色）：移动速度提升60%，持续8秒，但轨迹更粗 + /// + Lightning, + + /// + /// 护盾道具（金色）：免疫一次截断攻击，持续12秒或触发一次 + /// + Shield, + + /// + /// 炸弹道具（红色）：以当前位置为中心，半径30像素范围变成领地 + /// + Bomb, + + /// + /// 幽灵道具（紫色）：10秒内可以穿越敌方轨迹而不死亡，但不能圈地 + /// + Ghost +} + +/// +/// 道具实例 +/// +public class PowerUpInstance +{ + public Guid Id { get; set; } + public TerritoryGamePowerUpType Type { get; set; } + public Position Position { get; set; } = new(); + public DateTime SpawnTime { get; set; } + public bool IsActive { get; set; } = true; + public string Color { get; set; } = string.Empty; + public string Icon { get; set; } = string.Empty; + public Dictionary Properties { get; set; } = new(); +} + +/// +/// 道具拾取结果 +/// +public class PowerUpPickupResult +{ + public bool Success { get; set; } + public TerritoryGamePowerUpType PowerUpType { get; set; } + public string? ReplacedPowerUp { get; set; } + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} + +/// +/// 闪电道具使用结果 +/// +public class LightningUseResult +{ + public bool Success { get; set; } + public float SpeedMultiplier { get; set; } = 1.6f; // 60%提升 + public int DurationSeconds { get; set; } = 8; + public float TrailThickness { get; set; } = 3f; // 更粗的轨迹 + public DateTime EffectEndTime { get; set; } + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} + +/// +/// 护盾道具使用结果 +/// +public class ShieldUseResult +{ + public bool Success { get; set; } + public int DurationSeconds { get; set; } = 12; + public float SpeedPenalty { get; set; } = 0.9f; // 10%速度降低 + public DateTime EffectEndTime { get; set; } + public int BlocksRemaining { get; set; } = 1; + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} + +/// +/// 炸弹道具使用结果 +/// +public class BombUseResult +{ + public bool Success { get; set; } + public Position ExplosionCenter { get; set; } = new(); + public float ExplosionRadius { get; set; } = 30f; + public decimal AreaGained { get; set; } + public List NewTerritory { get; set; } = new(); + public List AffectedPlayers { get; set; } = new(); + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} + +/// +/// 幽灵道具使用结果 +/// +public class GhostUseResult +{ + public bool Success { get; set; } + public int DurationSeconds { get; set; } = 10; + public DateTime EffectEndTime { get; set; } + public bool CanDrawWhileGhost { get; set; } = false; // 不能圈地 + public List Messages { get; set; } = new(); + public List Errors { get; set; } = new(); +} + +/// +/// 玩家道具状态 +/// +public class PlayerPowerUp +{ + public Guid PlayerId { get; set; } + public TerritoryGamePowerUpType? PowerUpType { get; set; } + public DateTime? ObtainedTime { get; set; } + public bool CanUse { get; set; } = true; +} + +/// +/// 活跃道具效果 +/// +public class ActivePowerUpEffect +{ + public Guid EffectId { get; set; } + public Guid PlayerId { get; set; } + public TerritoryGamePowerUpType Type { get; set; } + public string Name { get; set; } = string.Empty; + public DateTime StartTime { get; set; } + public int DurationSeconds { get; set; } + public DateTime EndTime { get; set; } + public bool IsActive { get; set; } = true; + public Dictionary Effects { get; set; } = new(); +} + +/// +/// 道具更新结果 +/// +public class PowerUpUpdateResult +{ + public int ActiveEffectsCount { get; set; } + public int ExpiredEffectsCount { get; set; } + public List ExpiredEffectIds { get; set; } = new(); + public List NewlyActivatedEffects { get; set; } = new(); +} + +/// +/// 护盾阻挡结果 +/// +public class ShieldBlockResult +{ + public bool HasShield { get; set; } + public bool BlockedAttack { get; set; } + public bool ShieldExpired { get; set; } + public int RemainingBlocks { get; set; } + public DateTime? ShieldEndTime { get; set; } +} + +/// +/// 道具刷新配置 +/// +public class PowerUpSpawnConfig +{ + public int MaxConcurrentPowerUps { get; set; } = 3; + public int SpawnIntervalSeconds { get; set; } = 25; + public Dictionary SpawnWeights { get; set; } = new() + { + { TerritoryGamePowerUpType.Lightning, 0.3f }, + { TerritoryGamePowerUpType.Shield, 0.3f }, + { TerritoryGamePowerUpType.Bomb, 0.2f }, + { TerritoryGamePowerUpType.Ghost, 0.2f } + }; + public List PreferredSpawnAreas { get; set; } = new(); + public bool AvoidPlayerTerritories { get; set; } = true; +} diff --git a/backend/src/CollabApp.Domain/Services/Game/ITerritoryService.cs b/backend/src/CollabApp.Domain/Services/Game/ITerritoryService.cs new file mode 100644 index 0000000000000000000000000000000000000000..efe02788606e9c5c7e989c1fbe54c6c7f3e3d98a --- /dev/null +++ b/backend/src/CollabApp.Domain/Services/Game/ITerritoryService.cs @@ -0,0 +1,288 @@ +using CollabApp.Domain.Entities.Game; + +namespace CollabApp.Domain.Services.Game; + +/// +/// 领土管理服务接口 +/// 负责管理圈地游戏中的领土系统，包括画线轨迹、领地计算、圈地检测等 +/// +public interface ITerritoryService +{ + /// + /// 开始画线 + /// 玩家从己方领地或出生点开始画线 + /// + /// 游戏标识 + /// 玩家标识 + /// 起始位置 + /// 画线开始结果 + Task StartDrawingAsync(Guid gameId, Guid playerId, Position startPosition); + + /// + /// 更新画线轨迹 + /// 玩家移动时更新画线轨迹 + /// + /// 游戏标识 + /// 玩家标识 + /// 新位置 + /// 轨迹更新结果 + Task UpdateTrailAsync(Guid gameId, Guid playerId, Position newPosition); + + /// + /// 完成圈地 + /// 当玩家画线回到己方领地时完成圈地 + /// + /// 游戏标识 + /// 玩家标识 + /// 结束位置 + /// 圈地完成结果 + Task CompleteTerritoryAsync(Guid gameId, Guid playerId, Position endPosition); + + /// + /// 计算玩家领地面积 + /// 使用多边形面积算法计算玩家当前领地面积 + /// + /// 游戏标识 + /// 玩家标识 + /// 领地面积信息 + Task CalculatePlayerTerritoryAsync(Guid gameId, Guid playerId); + + /// + /// 检查位置是否在玩家领地内 + /// 检查指定位置是否属于某玩家的领地 + /// + /// 游戏标识 + /// 检查位置 + /// 玩家标识（可选） + /// 领地归属信息 + Task CheckTerritoryOwnershipAsync(Guid gameId, Position position, Guid? playerId = null); + + /// + /// 重置玩家领地 + /// 玩家死亡时重置领地到出生点安全区 + /// + /// 游戏标识 + /// 玩家标识 + /// 保留的领地记忆百分比 + /// 重置结果 + Task ResetPlayerTerritoryAsync(Guid gameId, Guid playerId, decimal keepPercentage = 0.2m); + + /// + /// 获取地图领土分布 + /// 获取当前游戏中所有玩家的领地分布情况 + /// + /// 游戏标识 + /// 地图领土分布信息 + Task GetMapTerritoryDistributionAsync(Guid gameId); + + /// + /// 计算领地争夺 + /// 当圈地包围敌方领地时计算争夺结果 + /// + /// 游戏标识 + /// 攻击者ID + /// 新圈定的领地 + /// 争夺结果 + Task CalculateTerritoryConquestAsync(Guid gameId, Guid attackerId, List newTerritory); + + /// + /// 检查画线长度限制 + /// 检查玩家当前画线长度是否超过限制 + /// + /// 游戏标识 + /// 玩家标识 + /// 长度检查结果 + Task CheckTrailLengthLimitAsync(Guid gameId, Guid playerId); + + /// + /// 应用地图缩圈效果 + /// 游戏最后30秒时应用地图缩圈效果 + /// + /// 游戏标识 + /// 缩圈半径 + /// 缩圈应用结果 + Task ApplyMapShrinkAsync(Guid gameId, float shrinkRadius); + + /// + /// 检查提前结束条件 + /// 检查是否有玩家占领超过70%地图 + /// + /// 游戏标识 + /// 提前结束检查结果 + Task CheckEarlyEndConditionAsync(Guid gameId); +} + +/// +/// 轨迹更新结果 +/// +public class TrailUpdateResult +{ + public bool Success { get; set; } + public Guid TrailId { get; set; } + public List CurrentTrail { get; set; } = new(); + public float TrailLength { get; set; } + public bool IsNearLimit { get; set; } + public string? ErrorMessage { get; set; } +} + +/// +/// 圈地完成结果 +/// +public class TerritoryCompleteResult +{ + public bool Success { get; set; } + public decimal AreaGained { get; set; } + public decimal NewTotalArea { get; set; } + public List NewTerritory { get; set; } = new(); + public List ConqueredPlayers { get; set; } = new(); + public decimal ConqueredArea { get; set; } + public string? ErrorMessage { get; set; } +} + +/// +/// 领地面积信息 +/// +public class TerritoryAreaInfo +{ + public Guid PlayerId { get; set; } + public decimal CurrentArea { get; set; } + public decimal MaxHistoryArea { get; set; } + public decimal AreaPercentage { get; set; } + public int Rank { get; set; } + public List TerritoryBoundary { get; set; } = new(); + public Position Center { get; set; } = new(); +} + +/// +/// 领地归属信息 +/// +public class TerritoryOwnership +{ + public bool IsOwned { get; set; } + public Guid? OwnerId { get; set; } + public string? OwnerColor { get; set; } + public bool IsNeutralZone { get; set; } + public bool IsSpawnArea { get; set; } + public float DistanceToNearestBoundary { get; set; } +} + +/// +/// 领地重置结果 +/// +public class TerritoryResetResult +{ + public bool Success { get; set; } + public decimal RemainingArea { get; set; } + public Position NewSpawnArea { get; set; } = new(); + public decimal LostArea { get; set; } +} + +/// +/// 地图领土分布 +/// +public class MapTerritoryDistribution +{ + public Guid GameId { get; set; } + public DateTime Timestamp { get; set; } + public float TotalMapArea { get; set; } + public float ClaimedArea { get; set; } + public float NeutralArea { get; set; } + public List PlayerTerritories { get; set; } = new(); + public bool HasDominantPlayer { get; set; } + public Guid? DominantPlayerId { get; set; } +} + +/// +/// 玩家领土信息 +/// +public class PlayerTerritoryInfo +{ + public Guid PlayerId { get; set; } + public string PlayerName { get; set; } = string.Empty; + public string PlayerColor { get; set; } = string.Empty; + public decimal Area { get; set; } + public decimal Percentage { get; set; } + public int Rank { get; set; } + public List Territory { get; set; } = new(); + public Position SpawnPoint { get; set; } = new(); + public bool IsDrawing { get; set; } + public List? CurrentTrail { get; set; } +} + +/// +/// 领地征服结果 +/// +public class TerritoryConquestResult +{ + public bool Success { get; set; } + public List ConqueredPlayers { get; set; } = new(); + public decimal TotalConqueredArea { get; set; } + public List Conquests { get; set; } = new(); + public decimal NewTotalArea { get; set; } +} + +/// +/// 领土征服详情 +/// +public class TerritoryConquest +{ + public Guid ConqueredPlayerId { get; set; } + public decimal ConqueredArea { get; set; } + public List ConqueredTerritory { get; set; } = new(); +} + +/// +/// 轨迹长度检查结果 +/// +public class TrailLengthCheckResult +{ + public bool IsWithinLimit { get; set; } + public float CurrentLength { get; set; } + public float MaxLength { get; set; } + public float RemainingLength { get; set; } + public bool IsNearLimit { get; set; } +} + +/// +/// 地图缩圈结果 +/// +public class MapShrinkResult +{ + public bool Success { get; set; } + public float NewMapRadius { get; set; } + public List AffectedPlayers { get; set; } = new(); + public decimal TotalAreaLost { get; set; } + public List PlayerLosses { get; set; } = new(); +} + +/// +/// 玩家面积损失 +/// +public class PlayerAreaLoss +{ + public Guid PlayerId { get; set; } + public decimal AreaLost { get; set; } + public decimal RemainingArea { get; set; } +} + +/// +/// 提前结束检查结果 +/// +public class EarlyEndCheckResult +{ + public bool CanEndEarly { get; set; } + public Guid? DominantPlayerId { get; set; } + public decimal DominantPlayerPercentage { get; set; } + public EarlyEndReason Reason { get; set; } +} + +/// +/// 提前结束原因 +/// +public enum EarlyEndReason +{ + None, + DominantPlayer, // 单一玩家占领70%地图 + LastPlayerStanding, // 只剩一名存活玩家 + TimeExpired // 时间到 +} diff --git a/backend/src/CollabApp.Domain/ValueObjects/README.md b/backend/src/CollabApp.Domain/ValueObjects/README.md new file mode 100644 index 0000000000000000000000000000000000000000..68065f0f004ebd0f8779beb4fa72b4398ddd1594 --- /dev/null +++ b/backend/src/CollabApp.Domain/ValueObjects/README.md @@ -0,0 +1,35 @@ +# 值对象层 (Value Objects) + +## 目的 +存放值对象，代表没有唯一标识但具有特定含义的概念。 + +## 内容 +- **值对象类**: 不可变的、通过值来识别的对象 +- **复合值对象**: 由多个属性组成的值对象 +- **验证逻辑**: 值对象的格式和规则验证 + +## 特点 +- 不可变性 (Immutable) +- 通过值相等而非引用相等 +- 无唯一标识 +- 可以被自由传递和复制 + +## 示例 +```csharp +public class Email : ValueObject +{ + public string Value { get; private set; } + + public Email(string value) + { + if (!IsValidEmail(value)) + throw new ArgumentException("Invalid email format"); + Value = value; + } + + protected override IEnumerable GetEqualityComponents() + { + yield return Value; + } +} +``` diff --git a/backend/src/CollabApp.Infrastructure/CollabApp.Infrastructure.csproj b/backend/src/CollabApp.Infrastructure/CollabApp.Infrastructure.csproj new file mode 100644 index 0000000000000000000000000000000000000000..ee94fdc1daf15059b00d9c546560f0291f6d2e2f --- /dev/null +++ b/backend/src/CollabApp.Infrastructure/CollabApp.Infrastructure.csproj @@ -0,0 +1,28 @@ + + + + + + + + + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + + + + + + + + + net9.0 + enable + enable + + + diff --git a/backend/src/CollabApp.Infrastructure/Data/ApplicationDbContext.cs b/backend/src/CollabApp.Infrastructure/Data/ApplicationDbContext.cs new file mode 100644 index 0000000000000000000000000000000000000000..9615dd4b05af8b9ff99cebba7405d76adcdf67c4 --- /dev/null +++ b/backend/src/CollabApp.Infrastructure/Data/ApplicationDbContext.cs @@ -0,0 +1,351 @@ +using Microsoft.EntityFrameworkCore; +using CollabApp.Domain.Entities; +using CollabApp.Domain.Entities.Auth; +using CollabApp.Domain.Entities.Room; +using CollabApp.Domain.Entities.Game; + +namespace CollabApp.Infrastructure.Data; + +/// +/// 应用程序数据库上下文 - 主要的EF Core DbContext +/// 负责所有实体的配置和数据库操作 +/// +public class ApplicationDbContext : DbContext +{ + public ApplicationDbContext(DbContextOptions options) : base(options) + { + } + + // ============ 用户相关实体 ============ + + /// + /// 用户实体集合 + /// + public DbSet Users { get; set; } + + /// + /// 用户统计实体集合 + /// + public DbSet UserStatistics { get; set; } + + // ============ 房间相关实体 ============ + + /// + /// 房间实体集合 + /// + public DbSet Rooms { get; set; } + + /// + /// 房间玩家实体集合 + /// + public DbSet RoomPlayers { get; set; } + + /// + /// 房间消息实体集合 + /// + public DbSet RoomMessages { get; set; } + + // ============ 游戏相关实体 ============ + + /// + /// 游戏实体集合 + /// + public DbSet Games { get; set; } + + /// + /// 游戏玩家实体集合 + /// + public DbSet GamePlayers { get; set; } + + /// + /// 游戏操作实体集合 + /// + public DbSet GameActions { get; set; } + + // ============ 排行榜和通知实体 ============ + + /// + /// 排行榜实体集合 + /// + public DbSet Rankings { get; set; } + + /// + /// 排名历史实体集合 + /// + public DbSet RankingHistories { get; set; } + + /// + /// 通知实体集合 + /// + public DbSet Notifications { get; set; } + + /// + /// 配置实体模型和关系 + /// + /// 模型构建器 + protected override void OnModelCreating(ModelBuilder modelBuilder) + { + base.OnModelCreating(modelBuilder); + + // ============ 用户相关配置 ============ + + // 用户实体配置 + modelBuilder.Entity(entity => + { + // 索引配置 + entity.HasIndex(e => e.Username).IsUnique().HasDatabaseName("IX_Users_Username"); + entity.HasIndex(e => e.AccessToken).HasFilter("[access_token] IS NOT NULL").HasDatabaseName("IX_Users_AccessToken"); + entity.HasIndex(e => e.RefreshToken).HasFilter("[refresh_token] IS NOT NULL").HasDatabaseName("IX_Users_RefreshToken"); + entity.HasIndex(e => new { e.TokenStatus, e.AccessTokenExpiresAt }).HasDatabaseName("IX_Users_TokenStatus_AccessTokenExpires"); + entity.HasIndex(e => new { e.TokenStatus, e.RefreshTokenExpiresAt }).HasDatabaseName("IX_Users_TokenStatus_RefreshTokenExpires"); + entity.HasIndex(e => e.LastActivityAt).HasDatabaseName("IX_Users_LastActivity"); + entity.HasIndex(e => e.Status).HasDatabaseName("IX_Users_Status"); + + // 软删除全局过滤器 + entity.HasQueryFilter(e => !e.IsDeleted); + }); + + // 用户统计实体配置 + modelBuilder.Entity(entity => + { + // 一对一关系配置 + entity.HasOne(e => e.User) + .WithOne(e => e.Statistics) + .HasForeignKey(e => e.UserId) + .OnDelete(DeleteBehavior.Cascade); + + // 索引配置 + entity.HasIndex(e => e.UserId).IsUnique().HasDatabaseName("IX_UserStatistics_UserId"); + entity.HasIndex(e => e.CurrentRank).HasDatabaseName("IX_UserStatistics_CurrentRank"); + entity.HasIndex(e => e.TotalScore).HasDatabaseName("IX_UserStatistics_TotalScore"); + entity.HasIndex(e => e.WinRate).HasDatabaseName("IX_UserStatistics_WinRate"); + + // 软删除全局过滤器 + entity.HasQueryFilter(e => !e.IsDeleted); + }); + + // ============ 房间相关配置 ============ + + // 房间实体配置 + modelBuilder.Entity(entity => + { + // 外键关系配置 + entity.HasOne(e => e.Owner) + .WithMany(e => e.OwnedRooms) + .HasForeignKey(e => e.OwnerId) + .OnDelete(DeleteBehavior.Restrict); + + // 索引配置 + entity.HasIndex(e => e.OwnerId).HasDatabaseName("IX_Rooms_OwnerId"); + entity.HasIndex(e => e.Status).HasDatabaseName("IX_Rooms_Status"); + entity.HasIndex(e => new { e.Status, e.IsPrivate }).HasDatabaseName("IX_Rooms_Status_IsPrivate"); + entity.HasIndex(e => e.CreatedAt).HasDatabaseName("IX_Rooms_CreatedAt"); + + // 软删除全局过滤器 + entity.HasQueryFilter(e => !e.IsDeleted); + }); + + // 房间玩家实体配置 + modelBuilder.Entity(entity => + { + // 外键关系配置 + entity.HasOne(e => e.Room) + .WithMany(e => e.Players) + .HasForeignKey(e => e.RoomId) + .OnDelete(DeleteBehavior.Cascade); + + entity.HasOne(e => e.User) + .WithMany(e => e.RoomPlayers) + .HasForeignKey(e => e.UserId) + .OnDelete(DeleteBehavior.Cascade); + + // 复合唯一索引 - 确保同一用户在同一房间只能有一条记录 + entity.HasIndex(e => new { e.RoomId, e.UserId }).IsUnique().HasDatabaseName("IX_RoomPlayers_RoomId_UserId"); + entity.HasIndex(e => e.JoinOrder).HasDatabaseName("IX_RoomPlayers_JoinOrder"); + }); + + // 房间消息实体配置 + modelBuilder.Entity(entity => + { + // 外键关系配置 + entity.HasOne(e => e.Room) + .WithMany(e => e.Messages) + .HasForeignKey(e => e.RoomId) + .OnDelete(DeleteBehavior.Cascade); + + entity.HasOne(e => e.User) + .WithMany() + .HasForeignKey(e => e.UserId) + .OnDelete(DeleteBehavior.Restrict); + + // 索引配置 + entity.HasIndex(e => e.RoomId).HasDatabaseName("IX_RoomMessages_RoomId"); + entity.HasIndex(e => e.UserId).HasDatabaseName("IX_RoomMessages_UserId"); + entity.HasIndex(e => e.CreatedAt).HasDatabaseName("IX_RoomMessages_CreatedAt"); + entity.HasIndex(e => new { e.RoomId, e.CreatedAt }).HasDatabaseName("IX_RoomMessages_RoomId_CreatedAt"); + }); + + // ============ 游戏相关配置 ============ + + // 游戏实体配置 + modelBuilder.Entity(entity => + { + // 外键关系配置 + entity.HasOne(e => e.Room) + .WithMany(e => e.Games) + .HasForeignKey(e => e.RoomId) + .OnDelete(DeleteBehavior.Cascade); + + entity.HasOne(e => e.Winner) + .WithMany() + .HasForeignKey(e => e.WinnerId) + .OnDelete(DeleteBehavior.SetNull); + + // 索引配置 + entity.HasIndex(e => e.RoomId).HasDatabaseName("IX_Games_RoomId"); + entity.HasIndex(e => e.Status).HasDatabaseName("IX_Games_Status"); + entity.HasIndex(e => e.WinnerId).HasDatabaseName("IX_Games_WinnerId"); + entity.HasIndex(e => e.StartedAt).HasDatabaseName("IX_Games_StartedAt"); + entity.HasIndex(e => e.FinishedAt).HasDatabaseName("IX_Games_FinishedAt"); + + // 软删除全局过滤器 + entity.HasQueryFilter(e => !e.IsDeleted); + }); + + // 游戏玩家实体配置 + modelBuilder.Entity(entity => + { + // 外键关系配置 + entity.HasOne(e => e.Game) + .WithMany(e => e.Players) + .HasForeignKey(e => e.GameId) + .OnDelete(DeleteBehavior.Cascade); + + entity.HasOne(e => e.User) + .WithMany(e => e.GamePlayers) + .HasForeignKey(e => e.UserId) + .OnDelete(DeleteBehavior.Cascade); + + // 复合唯一索引 - 确保同一用户在同一游戏只能有一条记录 + entity.HasIndex(e => new { e.GameId, e.UserId }).IsUnique().HasDatabaseName("IX_GamePlayers_GameId_UserId"); + entity.HasIndex(e => e.FinalRank).HasDatabaseName("IX_GamePlayers_FinalRank"); + entity.HasIndex(e => e.FinalArea).HasDatabaseName("IX_GamePlayers_FinalArea"); + entity.HasIndex(e => e.ScoreChange).HasDatabaseName("IX_GamePlayers_ScoreChange"); + }); + + // 游戏操作实体配置 + modelBuilder.Entity(entity => + { + // 外键关系配置 + entity.HasOne(e => e.Game) + .WithMany(e => e.Actions) + .HasForeignKey(e => e.GameId) + .OnDelete(DeleteBehavior.Cascade); + + entity.HasOne(e => e.User) + .WithMany() + .HasForeignKey(e => e.UserId) + .OnDelete(DeleteBehavior.Restrict); + + // 索引配置 + entity.HasIndex(e => e.GameId).HasDatabaseName("IX_GameActions_GameId"); + entity.HasIndex(e => e.UserId).HasDatabaseName("IX_GameActions_UserId"); + entity.HasIndex(e => e.Timestamp).HasDatabaseName("IX_GameActions_Timestamp"); + entity.HasIndex(e => new { e.GameId, e.Timestamp }).HasDatabaseName("IX_GameActions_GameId_Timestamp"); + entity.HasIndex(e => e.ActionType).HasDatabaseName("IX_GameActions_ActionType"); + }); + + // ============ 排行榜和通知配置 ============ + + // 排行榜实体配置 + modelBuilder.Entity(entity => + { + // 外键关系配置 + entity.HasOne(e => e.User) + .WithMany() + .HasForeignKey(e => e.UserId) + .OnDelete(DeleteBehavior.Cascade); + + // 复合唯一索引 - 确保同一用户在同一类型排行榜同一周期只能有一条记录 + entity.HasIndex(e => new { e.UserId, e.RankingType, e.PeriodStart, e.PeriodEnd }) + .IsUnique() + .HasDatabaseName("IX_Rankings_UserId_Type_Period"); + entity.HasIndex(e => new { e.RankingType, e.CurrentRank }).HasDatabaseName("IX_Rankings_Type_Rank"); + entity.HasIndex(e => new { e.RankingType, e.Score }).HasDatabaseName("IX_Rankings_Type_Score"); + entity.HasIndex(e => e.UpdatedAt).HasDatabaseName("IX_Rankings_UpdatedAt"); + }); + + // 排名历史实体配置 + modelBuilder.Entity(entity => + { + // 外键关系配置 + entity.HasOne(e => e.User) + .WithMany() + .HasForeignKey(e => e.UserId) + .OnDelete(DeleteBehavior.Cascade); + + // 索引配置 + entity.HasIndex(e => e.UserId).HasDatabaseName("IX_RankingHistories_UserId"); + entity.HasIndex(e => new { e.RankingType, e.RecordedAt }).HasDatabaseName("IX_RankingHistories_Type_RecordedAt"); + entity.HasIndex(e => new { e.UserId, e.RankingType, e.RecordedAt }).HasDatabaseName("IX_RankingHistories_UserId_Type_RecordedAt"); + }); + + // 通知实体配置 + modelBuilder.Entity(entity => + { + // 外键关系配置 + entity.HasOne(e => e.User) + .WithMany(e => e.Notifications) + .HasForeignKey(e => e.UserId) + .OnDelete(DeleteBehavior.Cascade); + + // 索引配置 + entity.HasIndex(e => e.UserId).HasDatabaseName("IX_Notifications_UserId"); + entity.HasIndex(e => new { e.UserId, e.IsRead }).HasDatabaseName("IX_Notifications_UserId_IsRead"); + entity.HasIndex(e => e.NotificationType).HasDatabaseName("IX_Notifications_Type"); + entity.HasIndex(e => e.CreatedAt).HasDatabaseName("IX_Notifications_CreatedAt"); + entity.HasIndex(e => new { e.UserId, e.CreatedAt }).HasDatabaseName("IX_Notifications_UserId_CreatedAt"); + }); + } + + /// + /// 重写SaveChanges方法，自动处理审计字段和软删除 + /// + public override int SaveChanges() + { + HandleAuditFields(); + return base.SaveChanges(); + } + + /// + /// 重写SaveChangesAsync方法，自动处理审计字段和软删除 + /// + public override async Task SaveChangesAsync(CancellationToken cancellationToken = default) + { + HandleAuditFields(); + return await base.SaveChangesAsync(cancellationToken); + } + + /// + /// 处理审计字段的自动填充 + /// + private void HandleAuditFields() + { + var entries = ChangeTracker.Entries() + .Where(e => e.Entity is BaseEntity && + (e.State == EntityState.Added || e.State == EntityState.Modified)); + + foreach (var entry in entries) + { + var entity = (BaseEntity)entry.Entity; + var now = DateTime.UtcNow; + + if (entry.State == EntityState.Added) + { + entity.CreatedAt = now; + } + + entity.UpdatedAt = now; + } + } +} diff --git a/backend/src/CollabApp.Infrastructure/Data/README.md b/backend/src/CollabApp.Infrastructure/Data/README.md new file mode 100644 index 0000000000000000000000000000000000000000..37d2898f10af20c633ae7edad71e8bc83256af64 --- /dev/null +++ b/backend/src/CollabApp.Infrastructure/Data/README.md @@ -0,0 +1,30 @@ +# 数据访问层 (Data) + +## 目的 +实现数据持久化，包含数据库上下文和配置。 + +## 内容 +- **DbContext**: Entity Framework数据库上下文 +- **实体配置**: 数据库表和字段的映射配置 +- **迁移文件**: 数据库结构变更的版本控制 +- **种子数据**: 初始化和测试数据 + +## 特点 +- 封装数据库访问细节 +- 提供事务支持 +- 支持数据库迁移 +- 配置实体关系映射 + +## 示例 +```csharp +public class CollabAppDbContext : DbContext +{ + public DbSet Users { get; set; } + public DbSet Documents { get; set; } + + protected override void OnModelCreating(ModelBuilder modelBuilder) + { + modelBuilder.ApplyConfigurationsFromAssembly(typeof(CollabAppDbContext).Assembly); + } +} +``` diff --git a/backend/src/CollabApp.Infrastructure/Repositories/GenericRepository.cs b/backend/src/CollabApp.Infrastructure/Repositories/GenericRepository.cs new file mode 100644 index 0000000000000000000000000000000000000000..fa588bedd59caf03bbcdf6af4ef7e3c168fe0a10 --- /dev/null +++ b/backend/src/CollabApp.Infrastructure/Repositories/GenericRepository.cs @@ -0,0 +1,507 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Threading; +using System.Threading.Tasks; +using Microsoft.EntityFrameworkCore; +using CollabApp.Domain.Entities; +using CollabApp.Domain.Repositories; +using CollabApp.Infrastructure.Data; + +namespace CollabApp.Infrastructure.Repositories; + +/// +/// 通用仓储实现 +/// 提供基本的增删改查、条件查询、分页查询等功能的具体实现 +/// +/// 实体类型，必须继承BaseEntity +public class GenericRepository : IRepository where T : BaseEntity +{ + protected readonly ApplicationDbContext _context; + protected readonly DbSet _dbSet; + + /// + /// 构造函数 + /// + /// 数据库上下文 + public GenericRepository(ApplicationDbContext context) + { + _context = context ?? throw new ArgumentNullException(nameof(context)); + _dbSet = _context.Set(); + } + + // ============ 查询操作 ============ + + /// + /// 根据ID查询实体 + /// + /// 实体ID + /// 实体，如果不存在则返回null + public virtual async Task GetByIdAsync(Guid id) + { + return await _dbSet + .Where(e => !e.IsDeleted) + .FirstOrDefaultAsync(e => e.Id == id); + } + + /// + /// 获取所有实体 + /// + /// 所有实体集合 + public virtual async Task> GetAllAsync() + { + return await _dbSet + .Where(e => !e.IsDeleted) + .ToListAsync(); + } + + /// + /// 根据条件查询单个实体 + /// + /// 查询条件 + /// 符合条件的第一个实体，如果不存在则返回null + public virtual async Task GetSingleAsync(Expression> predicate) + { + return await _dbSet + .Where(e => !e.IsDeleted) + .Where(predicate) + .FirstOrDefaultAsync(); + } + + /// + /// 根据条件查询多个实体 + /// + /// 查询条件 + /// 符合条件的实体集合 + public virtual async Task> GetManyAsync(Expression> predicate) + { + return await _dbSet + .Where(e => !e.IsDeleted) + .Where(predicate) + .ToListAsync(); + } + + /// + /// 分页查询数据 + /// + /// 查询条件表达式 + /// 页码（从0开始） + /// 每页数据量 + /// 返回分页后的数据集合和总数 + public virtual async Task<(IEnumerable Items, int TotalCount)> GetPagedAsync( + Expression> predicate, + int pageIndex, + int pageSize) + { + if (pageIndex < 0) + throw new ArgumentException("页码不能小于0", nameof(pageIndex)); + if (pageSize <= 0) + throw new ArgumentException("每页数据量必须大于0", nameof(pageSize)); + + var query = _dbSet + .Where(e => !e.IsDeleted) + .Where(predicate); + + var totalCount = await query.CountAsync(); + + var items = await query + .Skip(pageIndex * pageSize) + .Take(pageSize) + .ToListAsync(); + + return (items, totalCount); + } + + /// + /// 分页查询所有数据 + /// + /// 页码（从0开始） + /// 每页数据量 + /// 返回分页后的数据集合和总数 + public virtual async Task<(IEnumerable Items, int TotalCount)> GetPagedAsync( + int pageIndex, + int pageSize) + { + if (pageIndex < 0) + throw new ArgumentException("页码不能小于0", nameof(pageIndex)); + if (pageSize <= 0) + throw new ArgumentException("每页数据量必须大于0", nameof(pageSize)); + + var query = _dbSet.Where(e => !e.IsDeleted); + + var totalCount = await query.CountAsync(); + + var items = await query + .Skip(pageIndex * pageSize) + .Take(pageSize) + .ToListAsync(); + + return (items, totalCount); + } + + /// + /// 检查是否存在符合条件的实体 + /// + /// 查询条件 + /// 是否存在 + public virtual async Task ExistsAsync(Expression> predicate) + { + return await _dbSet + .Where(e => !e.IsDeleted) + .AnyAsync(predicate); + } + + /// + /// 根据条件获取数据条数 + /// + /// 查询条件表达式 + /// 返回符合条件的数据条数 + public virtual async Task CountAsync(Expression> predicate) + { + return await _dbSet + .Where(e => !e.IsDeleted) + .CountAsync(predicate); + } + + /// + /// 获取所有数据的总数 + /// + /// 返回所有数据的总条数 + public virtual async Task CountAllAsync() + { + return await _dbSet + .Where(e => !e.IsDeleted) + .CountAsync(); + } + + // ============ 高级查询操作 ============ + + /// + /// 根据条件查询并排序 + /// + /// 排序字段类型 + /// 查询条件 + /// 排序表达式 + /// 是否升序，默认true + /// 排序后的实体集合 + public virtual async Task> GetOrderedAsync( + Expression> predicate, + Expression> orderBy, + bool ascending = true) + { + var query = _dbSet + .Where(e => !e.IsDeleted) + .Where(predicate); + + query = ascending + ? query.OrderBy(orderBy) + : query.OrderByDescending(orderBy); + + return await query.ToListAsync(); + } + + /// + /// 获取前N条记录 + /// + /// 查询条件 + /// 获取的记录数 + /// 前N条记录 + public virtual async Task> GetTopAsync(Expression> predicate, int count) + { + if (count <= 0) + throw new ArgumentException("获取记录数必须大于0", nameof(count)); + + return await _dbSet + .Where(e => !e.IsDeleted) + .Where(predicate) + .Take(count) + .ToListAsync(); + } + + /// + /// 获取前N条记录并排序 + /// + /// 排序字段类型 + /// 查询条件 + /// 排序表达式 + /// 获取的记录数 + /// 是否升序，默认true + /// 排序后的前N条记录 + public virtual async Task> GetTopOrderedAsync( + Expression> predicate, + Expression> orderBy, + int count, + bool ascending = true) + { + if (count <= 0) + throw new ArgumentException("获取记录数必须大于0", nameof(count)); + + var query = _dbSet + .Where(e => !e.IsDeleted) + .Where(predicate); + + query = ascending + ? query.OrderBy(orderBy) + : query.OrderByDescending(orderBy); + + return await query.Take(count).ToListAsync(); + } + + // ============ 增加操作 ============ + + /// + /// 添加单个实体 + /// + /// 要添加的实体 + public virtual async Task AddAsync(T entity) + { + if (entity == null) + throw new ArgumentNullException(nameof(entity)); + + // 确保创建时间和更新时间被设置 + if (entity.CreatedAt == default) + entity.CreatedAt = DateTime.UtcNow; + if (entity.UpdatedAt == default) + entity.UpdatedAt = DateTime.UtcNow; + + await _dbSet.AddAsync(entity); + } + + /// + /// 批量添加实体 + /// + /// 要添加的实体集合 + public virtual async Task AddRangeAsync(IEnumerable entities) + { + if (entities == null) + throw new ArgumentNullException(nameof(entities)); + + var entityList = entities.ToList(); + if (!entityList.Any()) + return; + + // 确保所有实体的创建时间和更新时间被设置 + var now = DateTime.UtcNow; + foreach (var entity in entityList) + { + if (entity.CreatedAt == default) + entity.CreatedAt = now; + if (entity.UpdatedAt == default) + entity.UpdatedAt = now; + } + + await _dbSet.AddRangeAsync(entityList); + } + + // ============ 更新操作 ============ + + /// + /// 更新单个实体 + /// + /// 要更新的实体 + public virtual Task UpdateAsync(T entity) + { + if (entity == null) + throw new ArgumentNullException(nameof(entity)); + + // 更新时间戳 + entity.UpdatedAt = DateTime.UtcNow; + + _dbSet.Update(entity); + return Task.CompletedTask; + } + + /// + /// 批量更新实体 + /// + /// 要更新的实体集合 + public virtual Task UpdateRangeAsync(IEnumerable entities) + { + if (entities == null) + throw new ArgumentNullException(nameof(entities)); + + var entityList = entities.ToList(); + if (!entityList.Any()) + return Task.CompletedTask; + + // 更新时间戳 + var now = DateTime.UtcNow; + foreach (var entity in entityList) + { + entity.UpdatedAt = now; + } + + _dbSet.UpdateRange(entityList); + return Task.CompletedTask; + } + + // ============ 删除操作 ============ + + /// + /// 删除单个实体（软删除，设置IsDeleted=true） + /// + /// 要删除的实体 + public virtual Task DeleteAsync(T entity) + { + if (entity == null) + throw new ArgumentNullException(nameof(entity)); + + // 直接设置BaseEntity属性，类型安全且高效 + entity.IsDeleted = true; + entity.UpdatedAt = DateTime.UtcNow; + + _dbSet.Update(entity); + return Task.CompletedTask; + } + + /// + /// 根据ID删除实体（软删除） + /// + /// 实体ID + public virtual async Task DeleteAsync(Guid id) + { + var entity = await GetByIdAsync(id); + if (entity != null) + { + await DeleteAsync(entity); + } + } + + /// + /// 批量删除实体（软删除） + /// + /// 要删除的实体集合 + public virtual Task DeleteRangeAsync(IEnumerable entities) + { + if (entities == null) + throw new ArgumentNullException(nameof(entities)); + + var entityList = entities.ToList(); + if (!entityList.Any()) + return Task.CompletedTask; + + // 直接设置BaseEntity属性，类型安全且高效 + var now = DateTime.UtcNow; + foreach (var entity in entityList) + { + entity.IsDeleted = true; + entity.UpdatedAt = now; + } + + _dbSet.UpdateRange(entityList); + return Task.CompletedTask; + } + + /// + /// 根据条件批量删除实体（软删除） + /// + /// 删除条件 + public virtual async Task DeleteWhereAsync(Expression> predicate) + { + var entities = await GetManyAsync(predicate); + await DeleteRangeAsync(entities); + } + + // ============ 工作单元操作 ============ + + /// + /// 保存所有更改到数据库 + /// + /// 取消令牌 + /// 受影响的记录数 + public virtual async Task SaveChangesAsync(CancellationToken cancellationToken = default) + { + return await _context.SaveChangesAsync(cancellationToken); + } + + // ============ 性能优化方法 ============ + + /// + /// 批量插入（高性能）- 适用于大量数据插入 + /// + /// 要插入的实体集合 + /// 取消令牌 + public virtual async Task BulkInsertAsync(IEnumerable entities, CancellationToken cancellationToken = default) + { + if (entities == null) + throw new ArgumentNullException(nameof(entities)); + + var entityList = entities.ToList(); + if (!entityList.Any()) + return; + + // 确保时间戳 + var now = DateTime.UtcNow; + foreach (var entity in entityList) + { + if (entity.CreatedAt == default) + entity.CreatedAt = now; + if (entity.UpdatedAt == default) + entity.UpdatedAt = now; + } + + // 使用EF Core的AddRange进行批量插入 + await _dbSet.AddRangeAsync(entityList, cancellationToken); + await _context.SaveChangesAsync(cancellationToken); + } + + /// + /// 批量更新（高性能）- 适用于大量数据更新 + /// + /// 要更新的实体集合 + /// 取消令牌 + public virtual async Task BulkUpdateAsync(IEnumerable entities, CancellationToken cancellationToken = default) + { + if (entities == null) + throw new ArgumentNullException(nameof(entities)); + + var entityList = entities.ToList(); + if (!entityList.Any()) + return; + + // 更新时间戳 + var now = DateTime.UtcNow; + foreach (var entity in entityList) + { + entity.UpdatedAt = now; + } + + _dbSet.UpdateRange(entityList); + await _context.SaveChangesAsync(cancellationToken); + } + + /// + /// 批量软删除（高性能）- 直接执行SQL + /// + /// 删除条件 + /// 取消令牌 + public virtual async Task BulkSoftDeleteAsync(Expression> predicate, CancellationToken cancellationToken = default) + { + var now = DateTime.UtcNow; + + // 使用ExecuteUpdateAsync进行批量更新（EF Core 7+的高性能方法） + await _dbSet + .Where(e => !e.IsDeleted) + .Where(predicate) + .ExecuteUpdateAsync(setters => setters + .SetProperty(e => e.IsDeleted, true) + .SetProperty(e => e.UpdatedAt, now), cancellationToken); + } + + /// + /// 检查连接是否可用 + /// + /// 取消令牌 + public virtual async Task IsHealthyAsync(CancellationToken cancellationToken = default) + { + try + { + return await _context.Database.CanConnectAsync(cancellationToken); + } + catch + { + return false; + } + } +} diff --git a/backend/src/CollabApp.Infrastructure/Repositories/README.md b/backend/src/CollabApp.Infrastructure/Repositories/README.md new file mode 100644 index 0000000000000000000000000000000000000000..4d008d2a6f283b9045dd8488877775c22874ddb6 --- /dev/null +++ b/backend/src/CollabApp.Infrastructure/Repositories/README.md @@ -0,0 +1,34 @@ +# 仓储实现层 (Repositories) + +## 目的 +实现领域层定义的仓储接口，提供具体的数据访问实现。 + +## 内容 +- **仓储实现类**: 实现领域层仓储接口的具体类 +- **基础仓储**: 通用的CRUD操作基类 +- **查询优化**: 针对特定查询的性能优化 + +## 特点 +- 实现领域层定义的接口 +- 封装具体的数据访问技术 +- 提供查询优化和缓存 +- 支持事务和并发控制 + +## 示例 +```csharp +public class UserRepository : IUserRepository +{ + private readonly CollabAppDbContext _context; + + public UserRepository(CollabAppDbContext context) + { + _context = context; + } + + public async Task GetByIdAsync(UserId id) + { + return await _context.Users + .FirstOrDefaultAsync(u => u.Id == id); + } +} +``` diff --git a/backend/src/CollabApp.Infrastructure/ServiceCollectionExtenstion.cs b/backend/src/CollabApp.Infrastructure/ServiceCollectionExtenstion.cs new file mode 100644 index 0000000000000000000000000000000000000000..3d4a6b8c47028452bf4122aeee7ed3b6dfebc64e --- /dev/null +++ b/backend/src/CollabApp.Infrastructure/ServiceCollectionExtenstion.cs @@ -0,0 +1,46 @@ +using CollabApp.Application.DTOs; +using CollabApp.Application.Interfaces; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.DependencyInjection; +using CollabApp.Infrastructure.Data; +using CollabApp.Infrastructure.Services; +using CollabApp.Domain.Repositories; +using CollabApp.Infrastructure.Repositories; + +namespace CollabApp.Infrastructure; + +/// +/// 扩展方法。基础服务注册。 +/// +public static class ServiceCollectionExtenstion +{ + public static IServiceCollection AddInfrastructure(this IServiceCollection services, IConfiguration configuration) + { + + //注册JwtTokenService + services.AddSingleton(); + + //获取PostgreSql连接字符串 + var connString = configuration.GetConnectionString("pgsql"); + //注册 ApplicationDbContext，配置使用 PostgreSQL 数据库 + services.AddDbContext(options => + { + options.UseNpgsql(connString); + }); + + //获取redis连接字符串 + var redisConnStr = configuration.GetConnectionString("redis"); + if (string.IsNullOrWhiteSpace(redisConnStr)) + { + throw new InvalidOperationException("Redis 连接字符串未配置!!!"); + } + // 注册 AddSingleton, 配置使用Redis 数据库 + services.AddSingleton(new RedisService(redisConnStr)); + + // 注册通用仓储服务 + services.AddScoped(typeof(IRepository<>), typeof(GenericRepository<>)); + + return services; + } +} \ No newline at end of file diff --git a/backend/src/CollabApp.Infrastructure/Services/JwtTokenService.cs b/backend/src/CollabApp.Infrastructure/Services/JwtTokenService.cs new file mode 100644 index 0000000000000000000000000000000000000000..8b0c3d9f64ac97f4bf3e87164a2c8a5fa1b96c45 --- /dev/null +++ b/backend/src/CollabApp.Infrastructure/Services/JwtTokenService.cs @@ -0,0 +1,46 @@ +using CollabApp.Application.Interfaces; +using CollabApp.Application.DTOs; +using Microsoft.Extensions.Options; +using Microsoft.IdentityModel.Tokens; +using System; +using System.IdentityModel.Tokens.Jwt; +using System.Security.Claims; +using System.Text; + +namespace CollabApp.Infrastructure.Services; + +/// +/// JWT令牌服务实现 +/// +public class JwtTokenService : IJwtTokenService +{ + private readonly JwtSettings _jwtSettings; + + public JwtTokenService(IOptions jwtSettings) + { + _jwtSettings = jwtSettings.Value; + } + + public string GenerateToken(Guid userId, string userName) + { + var claims = new[] + { + new Claim(JwtRegisteredClaimNames.Sub, userId.ToString()), // Guid 转 string 存储 + new Claim(JwtRegisteredClaimNames.UniqueName, userName), + new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()) + }; + + var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_jwtSettings.SecretKey)); + var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256); + + var token = new JwtSecurityToken( + issuer: _jwtSettings.Issuer, + audience: _jwtSettings.Audience, + claims: claims, + expires: DateTime.UtcNow.AddMinutes(_jwtSettings.ExpireMinutes), + signingCredentials: creds + ); + + return new JwtSecurityTokenHandler().WriteToken(token); + } +} diff --git a/backend/src/CollabApp.Infrastructure/Services/README.md b/backend/src/CollabApp.Infrastructure/Services/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f6f659ffa549a8dadcfd7ab54d0789b3b00d4335 --- /dev/null +++ b/backend/src/CollabApp.Infrastructure/Services/README.md @@ -0,0 +1,34 @@ +# 基础设施服务层 (Services) + +## 目的 +实现应用层定义的外部服务接口，提供具体的技术实现。 + +## 内容 +- **外部服务实现**: 邮件、短信、支付等外部服务的具体实现 +- **缓存服务**: Redis、内存缓存等缓存实现 +- **文件服务**: 文件上传、存储等服务实现 +- **消息队列**: 事件发布、消息处理等实现 + +## 特点 +- 实现应用层定义的服务接口 +- 封装第三方技术和库 +- 提供配置和错误处理 +- 支持服务降级和熔断 + +## 示例 +```csharp +public class EmailService : IEmailService +{ + private readonly IConfiguration _configuration; + + public EmailService(IConfiguration configuration) + { + _configuration = configuration; + } + + public async Task SendEmailAsync(string to, string subject, string body) + { + // 实现邮件发送逻辑 + } +} +``` diff --git a/backend/src/CollabApp.Infrastructure/Services/RedisService.cs b/backend/src/CollabApp.Infrastructure/Services/RedisService.cs new file mode 100644 index 0000000000000000000000000000000000000000..a9c8468c51067d2ddca4b183f37507380b28e5d4 --- /dev/null +++ b/backend/src/CollabApp.Infrastructure/Services/RedisService.cs @@ -0,0 +1,150 @@ +using CollabApp.Application.Interfaces; +using StackExchange.Redis; + +namespace CollabApp.Infrastructure.Services; + +/// +/// Redis 服务实现 +/// 提供Redis数据库操作的具体实现，封装StackExchange.Redis的复杂性 +/// +public class RedisService : IRedisService +{ + private readonly ConnectionMultiplexer _redis; + private readonly IDatabase _database; + + public RedisService(string connectionString) + { + _redis = ConnectionMultiplexer.Connect(connectionString); + _database = _redis.GetDatabase(); + } + + // Hash操作 + public async Task> GetHashAllAsync(string key) + { + var result = await _database.HashGetAllAsync(key); + return result.ToDictionary(x => x.Name.ToString(), x => x.Value.ToString()); + } + + public async Task HashSetAsync(string key, string field, string value) + { + return await _database.HashSetAsync(key, field, value); + } + + public async Task HashDeleteAsync(string key, string field) + { + return await _database.HashDeleteAsync(key, field); + } + + public async Task HashGetAsync(string key, string field) + { + return await _database.HashGetAsync(key, field); + } + + public async Task SetHashMultipleAsync(string key, Dictionary hash) + { + var hashEntries = hash.Select(kvp => new HashEntry(kvp.Key, kvp.Value)).ToArray(); + await _database.HashSetAsync(key, hashEntries); + } + + public async Task SetHashAsync(string key, string field, string value) + { + await _database.HashSetAsync(key, field, value); + } + + // List操作 + public async Task> ListRangeAsync(string key, long start = 0, long stop = -1) + { + var result = await _database.ListRangeAsync(key, start, stop); + return result.Select(x => x.ToString()).ToList(); + } + + public async Task ListLeftPushAsync(string key, string value) + { + return await _database.ListLeftPushAsync(key, value); + } + + public async Task ListRightPushAsync(string key, string value) + { + return await _database.ListRightPushAsync(key, value); + } + + public async Task ListLeftPopAsync(string key) + { + return await _database.ListLeftPopAsync(key); + } + + public async Task ListRightPopAsync(string key) + { + return await _database.ListRightPopAsync(key); + } + + public async Task ListPushAsync(string key, string value) + { + return await _database.ListLeftPushAsync(key, value); + } + + // Set操作 + public async Task> GetSetMembersAsync(string key) + { + var result = await _database.SetMembersAsync(key); + return result.Select(x => x.ToString()).ToHashSet(); + } + + public async Task SetAddAsync(string key, string value) + { + return await _database.SetAddAsync(key, value); + } + + public async Task SetRemoveAsync(string key, string value) + { + return await _database.SetRemoveAsync(key, value); + } + + public async Task SetContainsAsync(string key, string value) + { + return await _database.SetContainsAsync(key, value); + } + + public async Task GetSetCardinalityAsync(string key) + { + return await _database.SetLengthAsync(key); + } + + // String操作 + public async Task StringSetAsync(string key, string value, TimeSpan? expiry = null) + { + return await _database.StringSetAsync(key, value, expiry); + } + + public async Task StringGetAsync(string key) + { + return await _database.StringGetAsync(key); + } + + public async Task KeyDeleteAsync(string key) + { + return await _database.KeyDeleteAsync(key); + } + + public async Task KeyExistsAsync(string key) + { + return await _database.KeyExistsAsync(key); + } + + // 过期时间 + public async Task KeyExpireAsync(string key, TimeSpan expiry) + { + return await _database.KeyExpireAsync(key, expiry); + } + + public async Task SetExpireAsync(string key, TimeSpan expiry) + { + return await _database.KeyExpireAsync(key, expiry); + } + + // 资源释放 + public void Dispose() + { + _redis?.Dispose(); + } +} \ No newline at end of file diff --git a/backend/tests/CollabApp.Application.Tests/CollabApp.Application.Tests.csproj b/backend/tests/CollabApp.Application.Tests/CollabApp.Application.Tests.csproj new file mode 100644 index 0000000000000000000000000000000000000000..d7f0b2e9e5ce0c10c1915375e0a0f513bda83319 --- /dev/null +++ b/backend/tests/CollabApp.Application.Tests/CollabApp.Application.Tests.csproj @@ -0,0 +1,21 @@ + + + + net9.0 + enable + enable + false + + + + + + + + + + + + + + diff --git a/backend/tests/CollabApp.Application.Tests/UnitTest1.cs b/backend/tests/CollabApp.Application.Tests/UnitTest1.cs new file mode 100644 index 0000000000000000000000000000000000000000..2dabd25aeb729b86a68ab0b13f5fa49daade8c45 --- /dev/null +++ b/backend/tests/CollabApp.Application.Tests/UnitTest1.cs @@ -0,0 +1,10 @@ +namespace CollabApp.Application.Tests; + +public class UnitTest1 +{ + [Fact] + public void Test1() + { + + } +} diff --git a/backend/tests/CollabApp.Domain.Tests/CollabApp.Domain.Tests.csproj b/backend/tests/CollabApp.Domain.Tests/CollabApp.Domain.Tests.csproj new file mode 100644 index 0000000000000000000000000000000000000000..d7f0b2e9e5ce0c10c1915375e0a0f513bda83319 --- /dev/null +++ b/backend/tests/CollabApp.Domain.Tests/CollabApp.Domain.Tests.csproj @@ -0,0 +1,21 @@ + + + + net9.0 + enable + enable + false + + + + + + + + + + + + + + diff --git a/backend/tests/CollabApp.Domain.Tests/UnitTest1.cs b/backend/tests/CollabApp.Domain.Tests/UnitTest1.cs new file mode 100644 index 0000000000000000000000000000000000000000..94fe7cfdfa9da0b30909344b29bea26f2868c231 --- /dev/null +++ b/backend/tests/CollabApp.Domain.Tests/UnitTest1.cs @@ -0,0 +1,10 @@ +namespace CollabApp.Domain.Tests; + +public class UnitTest1 +{ + [Fact] + public void Test1() + { + + } +} diff --git a/backend/tests/CollabApp.Tests/CollabApp.Tests.csproj b/backend/tests/CollabApp.Tests/CollabApp.Tests.csproj new file mode 100644 index 0000000000000000000000000000000000000000..d7f0b2e9e5ce0c10c1915375e0a0f513bda83319 --- /dev/null +++ b/backend/tests/CollabApp.Tests/CollabApp.Tests.csproj @@ -0,0 +1,21 @@ + + + + net9.0 + enable + enable + false + + + + + + + + + + + + + + diff --git a/backend/tests/CollabApp.Tests/UnitTest1.cs b/backend/tests/CollabApp.Tests/UnitTest1.cs new file mode 100644 index 0000000000000000000000000000000000000000..ba0e888b8009da002e3dff2ad47669c0449c2b4b --- /dev/null +++ b/backend/tests/CollabApp.Tests/UnitTest1.cs @@ -0,0 +1,10 @@ +namespace CollabApp.Tests; + +public class UnitTest1 +{ + [Fact] + public void Test1() + { + + } +} diff --git a/docs/DATABASE_DESIGN.md b/docs/DATABASE_DESIGN.md new file mode 100644 index 0000000000000000000000000000000000000000..73c40320f0d8dab81589e0909a97be582a742908 --- /dev/null +++ b/docs/DATABASE_DESIGN.md @@ -0,0 +1,1301 @@ +# 数据库设计 - Entity Framework Core 实体模型 + +## 基类定义 + +### BaseEntity 基础实体类 +```csharp +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; + +/// +/// 基础实体类 - 包含所有实体的共有属性 +/// 提供统一的主键、时间戳和软删除功能 +/// +public abstract class BaseEntity +{ + /// + /// 实体唯一标识符 - 主键，所有实体的统一标识 + /// + [Key] + public Guid Id { get; set; } = Guid.NewGuid(); + + /// + /// 创建时间 - 实体首次创建的UTC时间 + /// + [Column("created_at")] + public DateTime CreatedAt { get; set; } = DateTime.UtcNow; + + /// + /// 更新时间 - 实体最后一次修改的UTC时间 + /// + [Column("updated_at")] + public DateTime UpdatedAt { get; set; } = DateTime.UtcNow; + + /// + /// 软删除标志 - 标记实体是否被逻辑删除 + /// false: 正常状态, true: 已删除状态 + /// + [Column("is_deleted")] + public bool IsDeleted { get; set; } = false; +} +``` + +## 1. 用户相关实体 + +### User 用户实体 +```csharp +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; + +/// +/// 用户实体 - 存储用户基本信息和账户状态 +/// 继承AuditableEntity，支持审计和软删除功能 +/// +[Table("users")] +public class User : AuditableEntity +{ + /// + /// 用户名 - 登录用，唯一且不可重复 + /// + [Required] + [MaxLength(50)] + [Column("username")] + public string Username { get; set; } = string.Empty; + + /// + /// 密码哈希值 - 存储经过哈希处理的密码，不存储明文 + /// + [Required] + [MaxLength(255)] + [Column("password_hash")] + public string PasswordHash { get; set; } = string.Empty; + + /// + /// 密码盐值 - 用于增强密码安全性，防止彩虹表攻击 + /// + [Required] + [MaxLength(255)] + [Column("password_salt")] + public string PasswordSalt { get; set; } = string.Empty; + + /// + /// 游戏昵称 - 在游戏中显示的名称 + /// + [Required] + [MaxLength(50)] + [Column("nickname")] + public string Nickname { get; set; } = string.Empty; + + /// + /// 头像URL - 用户头像图片的存储地址 + /// + [MaxLength(255)] + [Column("avatar_url")] + public string? AvatarUrl { get; set; } + + /// + /// 隐私设置 - JSON格式存储用户的隐私偏好配置 + /// + [Column("privacy_settings", TypeName = "json")] + public string? PrivacySettings { get; set; } + + /// + /// 最后登录时间 - 记录用户最近一次登录的时间 + /// + [Column("last_login_at")] + public DateTime? LastLoginAt { get; set; } + + /// + /// 账户状态 - 正常,封禁等状态 + /// + [Column("status")] + public UserStatus Status { get; set; } = UserStatus.Active; + + // ============ 双Token认证字段 ============ + + /// + /// 访问令牌 - 短期有效的身份验证令牌 + /// 用于API请求的身份验证，通常有效期较短（如15-30分钟） + /// + [MaxLength(512)] + [Column("access_token")] + public string? AccessToken { get; set; } + + /// + /// 刷新令牌 - 长期有效的令牌，用于刷新访问令牌 + /// 安全性更高，有效期较长（如7-30天），用于获取新的访问令牌 + /// + [MaxLength(512)] + [Column("refresh_token")] + public string? RefreshToken { get; set; } + + /// + /// 访问令牌过期时间 - AccessToken的有效期 + /// + [Column("access_token_expires_at")] + public DateTime? AccessTokenExpiresAt { get; set; } + + /// + /// 刷新令牌过期时间 - RefreshToken的有效期 + /// + [Column("refresh_token_expires_at")] + public DateTime? RefreshTokenExpiresAt { get; set; } + + /// + /// 记住登录状态 - 是否启用长期登录功能 + /// 启用时RefreshToken有效期会延长 + /// + [Column("remember_me")] + public bool RememberMe { get; set; } = false; + + /// + /// 令牌状态 - 活跃、已吊销、已过期等状态 + /// + [Column("token_status")] + public TokenStatus TokenStatus { get; set; } = TokenStatus.None; + + /// + /// 最后活跃时间 - 用户最后一次使用令牌的时间 + /// + [Column("last_activity_at")] + public DateTime? LastActivityAt { get; set; } + + /// + /// 登录设备信息 - JSON格式存储设备类型、IP地址等信息 + /// + [Column("device_info", TypeName = "json")] + public string? DeviceInfo { get; set; } + + /// + /// 令牌吊销原因 - 令牌被吊销时的原因说明 + /// + [MaxLength(200)] + [Column("token_revoked_reason")] + public string? TokenRevokedReason { get; set; } + + /// + /// 令牌吊销时间 - 令牌被手动吊销的时间 + /// + [Column("token_revoked_at")] + public DateTime? TokenRevokedAt { get; set; } + + // ============ 导航属性 ============ + + /// + /// 用户统计信息 - 一对一关系 + /// + public virtual UserStatistics? Statistics { get; set; } + + /// + /// 用户创建的房间列表 - 一对多关系，用户作为房主的房间 + /// + public virtual ICollection OwnedRooms { get; set; } = new List(); + + /// + /// 用户参与的房间记录 - 一对多关系，用户加入过的所有房间 + /// + public virtual ICollection RoomPlayers { get; set; } = new List(); + + /// + /// 用户游戏记录 - 一对多关系，用户参与过的所有游戏 + /// + public virtual ICollection GamePlayers { get; set; } = new List(); + + /// + /// 用户通知列表 - 一对多关系，用户收到的所有通知 + /// + public virtual ICollection Notifications { get; set; } = new List(); +} + +/// +/// 令牌状态枚举 - 定义用户认证令牌的各种状态 +/// +public enum TokenStatus +{ + /// + /// 无令牌状态 - 用户未登录或令牌已清空 + /// + None, + + /// + /// 活跃状态 - 令牌正常有效 + /// + Active, + + /// + /// 已过期 - 令牌已超过有效期 + /// + Expired, + + /// + /// 已吊销 - 令牌被用户或系统主动撤销 + /// + Revoked, + + /// + /// 需要刷新 - AccessToken过期，需要使用RefreshToken刷新 + /// + NeedsRefresh +} + +/// +/// 用户状态枚举 +/// +public enum UserStatus +{ + /// + /// 正常状态 - 正常可用 + /// + Active, + + /// + /// 封禁状态 - 账户被管理员封禁 + /// + Banned +} +``` + +### UserStatistics 用户统计实体 +```csharp +/// +/// 用户统计实体 - 存储用户的游戏数据统计信息 +/// 继承BaseEntity，支持软删除和时间戳功能 +/// +[Table("user_statistics")] +public class UserStatistics : BaseEntity +{ + /// + /// 关联用户ID - 外键，指向Users表，一对一关系 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; set; } + + /// + /// 总游戏场次 - 用户参与的游戏总数 + /// + [Column("total_games")] + public int TotalGames { get; set; } = 0; + + /// + /// 胜利次数 - 用户获得第一名的次数 + /// + [Column("wins")] + public int Wins { get; set; } = 0; + + /// + /// 失败次数 - 用户未获得第一名的次数 + /// + [Column("losses")] + public int Losses { get; set; } = 0; + + /// + /// 胜率 - 胜利次数占总游戏场次的百分比 + /// + [Column("win_rate")] + [Precision(5, 2)] + public decimal WinRate { get; set; } = 0; + + /// + /// 总积分 - 用户累计获得的积分（根据排名计算） + /// + [Column("total_score")] + public int TotalScore { get; set; } = 0; + + /// + /// 最高占领面积 - 用户在单局游戏中的最佳成绩 + /// + [Column("max_area")] + [Precision(10, 2)] + public decimal MaxArea { get; set; } = 0; + + /// + /// 总游戏时长 - 用户累计游戏时间（秒） + /// + [Column("total_play_time")] + public int TotalPlayTime { get; set; } = 0; + + /// + /// 当前排名 - 用户在全服排行榜中的位置 + /// + [Column("current_rank")] + public int CurrentRank { get; set; } = 0; + + /// + /// 历史最高排名 - 用户曾经达到的最高排名 + /// + [Column("highest_rank")] + public int HighestRank { get; set; } = 0; + + /// + /// 统计创建时间 - 记录初始化时间 + /// + [Column("created_at")] + public DateTime CreatedAt { get; set; } = DateTime.UtcNow; + + /// + /// 统计更新时间 - 最后一次数据更新时间 + /// + [Column("updated_at")] + public DateTime UpdatedAt { get; set; } = DateTime.UtcNow; + + // ============ 导航属性 ============ + + /// + /// 关联的用户实体 - 一对一关系 + /// + [ForeignKey("UserId")] + public virtual User User { get; set; } = null!; +} +``` + +## 2. 房间相关实体 + +### Room 房间实体 +```csharp +/// +/// 房间实体 - 游戏房间的基本信息和配置 +/// 继承AuditableEntity，支持审计、软删除和时间戳功能 +/// +[Table("rooms")] +public class Room : AuditableEntity +{ + /// + /// 房间名称 - 显示给玩家的房间标题 + /// + [Required] + [MaxLength(100)] + [Column("name")] + public string Name { get; set; } = string.Empty; + + /// + /// 房主用户ID - 外键，指向创建房间的用户 + /// + [Required] + [Column("owner_id")] + public Guid OwnerId { get; set; } + + /// + /// 最大玩家数 - 房间可容纳的最大玩家数量 + /// + [Column("max_players")] + public int MaxPlayers { get; set; } = 4; + + /// + /// 当前玩家数 - 房间内当前的玩家数量，通过触发器自动更新 + /// + [Column("current_players")] + public int CurrentPlayers { get; set; } = 0; + + /// + /// 房间密码 - 私有房间的进入密码，为空则表示公开房间 + /// + [MaxLength(255)] + [Column("password")] + public string? Password { get; set; } + + /// + /// 是否私有房间 - 私有房间不会在房间列表中显示 + /// + [Column("is_private")] + public bool IsPrivate { get; set; } = false; + + /// + /// 房间状态 - 等待中、游戏中、已结束 + /// + [Column("status")] + public RoomStatus Status { get; set; } = RoomStatus.Waiting; + + /// + /// 房间设置 - JSON格式存储房间的自定义配置 + /// + [Column("settings", TypeName = "json")] + public string? Settings { get; set; } + + // ============ 导航属性 ============ + + /// + /// 房主用户实体 - 多对一关系 + /// + [ForeignKey("OwnerId")] + public virtual User Owner { get; set; } = null!; + + /// + /// 房间内的玩家列表 - 一对多关系 + /// + public virtual ICollection Players { get; set; } = new List(); + + /// + /// 房间聊天消息列表 - 一对多关系 + /// + public virtual ICollection Messages { get; set; } = new List(); + + /// + /// 房间内进行的游戏列表 - 一对多关系 + /// + public virtual ICollection Games { get; set; } = new List(); +} + +/// +/// 房间状态枚举 +/// +public enum RoomStatus +{ + /// + /// 等待中 - 房间已创建，等待玩家加入和准备 + /// + Waiting, + + /// + /// 游戏中 - 房间内正在进行游戏 + /// + Playing, + + /// + /// 已结束 - 游戏已结束，房间即将关闭 + /// + Finished +} +``` + +### RoomPlayer 房间玩家实体 +```csharp +/// +/// 房间玩家实体 - 记录玩家在房间中的状态和信息 +/// +[Table("room_players")] +public class RoomPlayer +{ + /// + /// 房间玩家记录唯一标识符 - 主键 + /// + [Key] + public Guid Id { get; set; } = Guid.NewGuid(); + + /// + /// 关联房间ID - 外键，指向Rooms表 + /// + [Required] + [Column("room_id")] + public Guid RoomId { get; set; } + + /// + /// 关联用户ID - 外键，指向Users表 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; set; } + + /// + /// 是否准备就绪 - 玩家是否已准备开始游戏 + /// + [Column("is_ready")] + public bool IsReady { get; set; } = false; + + /// + /// 加入顺序 - 玩家加入房间的先后顺序，可用于分配颜色等 + /// + [Column("join_order")] + public int? JoinOrder { get; set; } + + /// + /// 玩家颜色 - 十六进制颜色代码，用于游戏中区分不同玩家 + /// + [MaxLength(7)] + [Column("player_color")] + public string? PlayerColor { get; set; } + + /// + /// 加入房间时间 - 玩家进入房间的时间戳 + /// + [Column("joined_at")] + public DateTime JoinedAt { get; set; } = DateTime.UtcNow; + + // ============ 导航属性 ============ + + /// + /// 关联的房间实体 - 多对一关系 + /// + [ForeignKey("RoomId")] + public virtual Room Room { get; set; } = null!; + + /// + /// 关联的用户实体 - 多对一关系 + /// + [ForeignKey("UserId")] + public virtual User User { get; set; } = null!; +} +``` + +### RoomMessage 房间聊天消息实体 +```csharp +/// +/// 房间聊天消息实体 - 存储房间内的聊天记录 +/// +[Table("room_messages")] +public class RoomMessage +{ + /// + /// 消息唯一标识符 - 主键 + /// + [Key] + public Guid Id { get; set; } = Guid.NewGuid(); + + /// + /// 关联房间ID - 外键，指向Rooms表 + /// + [Required] + [Column("room_id")] + public Guid RoomId { get; set; } + + /// + /// 发送用户ID - 外键，指向Users表 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; set; } + + /// + /// 消息内容 - 聊天消息的具体文本内容 + /// + [Required] + [Column("message")] + public string Message { get; set; } = string.Empty; + + /// + /// 消息类型 - 普通文本消息或系统消息 + /// + [Column("message_type")] + public MessageType MessageType { get; set; } = MessageType.Text; + + /// + /// 消息发送时间 + /// + [Column("created_at")] + public DateTime CreatedAt { get; set; } = DateTime.UtcNow; + + // ============ 导航属性 ============ + + /// + /// 关联的房间实体 - 多对一关系 + /// + [ForeignKey("RoomId")] + public virtual Room Room { get; set; } = null!; + + /// + /// 发送消息的用户实体 - 多对一关系 + /// + [ForeignKey("UserId")] + public virtual User User { get; set; } = null!; +} + +/// +/// 消息类型枚举 +/// +public enum MessageType +{ + /// + /// 普通文本消息 - 用户发送的聊天内容 + /// + Text, + + /// + /// 系统消息 - 由系统自动生成的通知消息 + /// + System +} +``` +## 3. 游戏相关实体 + +### Game 游戏实体 +```csharp +/// +/// 游戏实体 - 存储单局游戏的基本信息和状态 +/// 继承AuditableEntity，支持审计、软删除和时间戳功能 +/// +[Table("games")] +public class Game : AuditableEntity +{ + /// + /// 关联房间ID - 外键，指向游戏所在的房间 + /// + [Required] + [Column("room_id")] + public Guid RoomId { get; set; } + + /// + /// 游戏模式 - 经典模式、竞速模式等游戏类型 + /// + [MaxLength(50)] + [Column("game_mode")] + public string GameMode { get; set; } = "classic"; + + /// + /// 画布宽度 - 游戏区域的像素宽度 + /// + [Column("canvas_width")] + public int CanvasWidth { get; set; } = 800; + + /// + /// 画布高度 - 游戏区域的像素高度 + /// + [Column("canvas_height")] + public int CanvasHeight { get; set; } = 600; + + /// + /// 游戏时长 - 单局游戏的持续时间（秒） + /// + [Column("duration")] + public int Duration { get; set; } = 300; + + /// + /// 游戏状态 - 准备中、进行中、暂停、已结束 + /// + [Column("status")] + public GameStatus Status { get; set; } = GameStatus.Preparing; + + /// + /// 获胜者用户ID - 外键，指向获胜的用户，可为空 + /// + [Column("winner_id")] + public Guid? WinnerId { get; set; } + + /// + /// 游戏开始时间 - 实际游戏开始的时间戳 + /// + [Column("started_at")] + public DateTime? StartedAt { get; set; } + + /// + /// 游戏结束时间 - 游戏完成或终止的时间戳 + /// + [Column("finished_at")] + public DateTime? FinishedAt { get; set; } + + /// + /// 游戏数据快照 - JSON格式存储游戏结束时的状态数据 + /// + [Column("game_data", TypeName = "json")] + public string? GameData { get; set; } + + /// + /// 游戏记录创建时间 + /// + [Column("created_at")] + public DateTime CreatedAt { get; set; } = DateTime.UtcNow; + + /// + /// 游戏记录更新时间 + /// + [Column("updated_at")] + public DateTime UpdatedAt { get; set; } = DateTime.UtcNow; + + // ============ 导航属性 ============ + + /// + /// 关联的房间实体 - 多对一关系 + /// + [ForeignKey("RoomId")] + public virtual Room Room { get; set; } = null!; + + /// + /// 获胜用户实体 - 多对一关系，可为空 + /// + [ForeignKey("WinnerId")] + public virtual User? Winner { get; set; } + + /// + /// 游戏参与玩家列表 - 一对多关系 + /// + public virtual ICollection Players { get; set; } = new List(); + + /// + /// 游戏操作记录列表 - 一对多关系，用于游戏回放 + /// + public virtual ICollection Actions { get; set; } = new List(); +} + +/// +/// 游戏状态枚举 +/// +public enum GameStatus +{ + /// + /// 准备中 - 游戏已创建但尚未开始 + /// + Preparing, + + /// + /// 进行中 - 游戏正在进行 + /// + Playing, + + /// + /// 暂停中 - 游戏被暂时暂停 + /// + Paused, + + /// + /// 已结束 - 游戏已完成 + /// + Finished +} +``` + +### GamePlayer 游戏玩家实体 +```csharp +/// +/// 游戏玩家实体类 - 记录单个玩家在特定游戏中的表现和统计数据 +/// 用于存储玩家的游戏过程数据、最终成绩、排名等信息 +/// +[Table("game_players")] +public class GamePlayer +{ + /// + /// 唯一标识符 - 游戏玩家记录的主键 + /// + [Key] + public Guid Id { get; set; } = Guid.NewGuid(); + + /// + /// 游戏ID - 关联到具体的游戏实例 + /// + [Required] + [Column("game_id")] + public Guid GameId { get; set; } + + /// + /// 用户ID - 关联到参与游戏的用户 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; set; } + + /// + /// 玩家颜色 - 在游戏中代表该玩家的颜色标识 + /// 格式：十六进制颜色值，例如 "#FF0000" + /// + [Required] + [MaxLength(7)] + [Column("player_color")] + public string PlayerColor { get; set; } = string.Empty; + + /// + /// 最终占地面积 - 游戏结束时玩家占据的总面积 + /// 用于计算排名和积分，精确到小数点后2位 + /// + [Column("final_area")] + [Precision(10, 2)] + public decimal FinalArea { get; set; } = 0; + + /// + /// 最终排名 - 玩家在该局游戏中的最终名次 + /// 数值越小排名越高，null表示未完成游戏 + /// + [Column("final_rank")] + public int? FinalRank { get; set; } + + /// + /// 积分变化 - 本局游戏对玩家总积分的影响 + /// 正数表示积分增加，负数表示积分减少 + /// + [Column("score_change")] + public int ScoreChange { get; set; } = 0; + + /// + /// 操作次数 - 玩家在游戏过程中执行的操作总数 + /// 用于统计玩家活跃度和游戏参与度 + /// + [Column("actions_count")] + public int ActionsCount { get; set; } = 0; + + /// + /// 游戏时长 - 玩家在该局游戏中的实际参与时间（秒） + /// 用于统计玩家的游戏投入度和活跃时间 + /// + [Column("play_time")] + public int PlayTime { get; set; } = 0; + + // ============ 导航属性 ============ + + /// + /// 导航属性 - 关联的游戏实例 + /// + [ForeignKey("GameId")] + public virtual Game Game { get; set; } = null!; + + /// + /// 导航属性 - 关联的用户信息 + /// + [ForeignKey("UserId")] + public virtual User User { get; set; } = null!; +} +``` + +### GameAction 游戏操作记录实体 +```csharp +/// +/// 游戏操作记录实体类 - 记录游戏过程中的所有玩家操作 +/// 用于游戏回放、作弊检测、数据分析等功能 +/// +[Table("game_actions")] +public class GameAction +{ + /// + /// 唯一标识符 - 游戏操作记录的主键 + /// + [Key] + public Guid Id { get; set; } = Guid.NewGuid(); + + /// + /// 游戏ID - 关联到具体的游戏实例 + /// + [Required] + [Column("game_id")] + public Guid GameId { get; set; } + + /// + /// 用户ID - 执行操作的用户标识 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; set; } + + /// + /// 操作类型 - 玩家执行的操作种类 + /// 例如：Move(移动)、Attack(攻击)、Defend(防御)、Special(特殊技能)等 + /// + [Required] + [MaxLength(50)] + [Column("action_type")] + public string ActionType { get; set; } = string.Empty; + + /// + /// 操作数据 - 操作的详细参数和状态信息 + /// JSON格式存储，包含坐标、方向、力度等具体操作参数 + /// + [Required] + [Column("action_data", TypeName = "json")] + public string ActionData { get; set; } = string.Empty; + + /// + /// 时间戳 - 操作发生的精确时间（毫秒级） + /// 用于游戏回放时的精确时序控制 + /// + [Column("timestamp")] + public long Timestamp { get; set; } + + /// + /// 创建时间 - 记录在数据库中的创建时间 + /// + [Column("created_at")] + public DateTime CreatedAt { get; set; } = DateTime.UtcNow; + + // ============ 导航属性 ============ + + /// + /// 导航属性 - 关联的游戏实例 + /// + [ForeignKey("GameId")] + public virtual Game Game { get; set; } = null!; + + /// + /// 导航属性 - 执行操作的用户 + /// + [ForeignKey("UserId")] + public virtual User User { get; set; } = null!; +} +``` + +### Ranking 排行榜实体 +```csharp +/// +/// 排行榜实体类 - 存储各种类型的玩家排名数据 +/// 支持不同时间周期和排名类型的排行榜统计 +/// +[Table("rankings")] +public class Ranking +{ + /// + /// 唯一标识符 - 排行榜记录的主键 + /// + [Key] + public Guid Id { get; set; } = Guid.NewGuid(); + + /// + /// 用户ID - 排行榜中的用户标识 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; set; } + + /// + /// 排行榜类型 - 排名的计算依据 + /// 例如：总积分、周积分、月积分、胜率等 + /// + [Required] + [Column("ranking_type")] + public RankingType RankingType { get; set; } + + /// + /// 当前排名 - 用户在该排行榜中的位次 + /// 数值越小排名越高，1为第一名 + /// + [Column("current_rank")] + public int CurrentRank { get; set; } + + /// + /// 分数 - 用于排名计算的分数值 + /// 具体含义根据排行榜类型而定 + /// + [Column("score")] + public int Score { get; set; } + + /// + /// 统计周期开始时间 - 该排行榜统计的起始时间 + /// + [Column("period_start")] + public DateTime PeriodStart { get; set; } + + /// + /// 统计周期结束时间 - 该排行榜统计的结束时间 + /// + [Column("period_end")] + public DateTime PeriodEnd { get; set; } + + /// + /// 更新时间 - 排行榜最后更新的时间 + /// + [Column("updated_at")] + public DateTime UpdatedAt { get; set; } = DateTime.UtcNow; + + // ============ 导航属性 ============ + + /// + /// 导航属性 - 关联的用户信息 + /// + [ForeignKey("UserId")] + public virtual User User { get; set; } = null!; +} + +/// +/// 排行榜类型枚举 - 定义不同的排名计算方式 +/// +public enum RankingType +{ + /// + /// 总积分排行榜 - 基于用户历史总积分 + /// + TotalScore, + + /// + /// 周积分排行榜 - 基于当周获得的积分 + /// + WeeklyScore, + + /// + /// 月积分排行榜 - 基于当月获得的积分 + /// + MonthlyScore, + + /// + /// 胜率排行榜 - 基于游戏胜率统计 + /// + WinRate, + + /// + /// 活跃度排行榜 - 基于游戏参与度 + /// + Activity +} + +### RankingHistory 排名历史实体 +```csharp +/// +/// 排名历史实体类 - 记录用户排名的历史变化轨迹 +/// 用于分析排名趋势和历史回顾 +/// +[Table("ranking_histories")] +public class RankingHistory +{ + /// + /// 唯一标识符 - 排名历史记录的主键 + /// + [Key] + public Guid Id { get; set; } = Guid.NewGuid(); + + /// + /// 用户ID - 排名变化的用户标识 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; set; } + + /// + /// 排行榜类型 - 历史记录对应的排行榜类型 + /// + [Required] + [Column("ranking_type")] + public RankingType RankingType { get; set; } + + /// + /// 排名 - 该时间点的用户排名 + /// + [Column("rank")] + public int Rank { get; set; } + + /// + /// 分数 - 该时间点的用户分数 + /// + [Column("score")] + public int Score { get; set; } + + /// + /// 记录时间 - 该排名记录的时间点 + /// + [Column("recorded_at")] + public DateTime RecordedAt { get; set; } = DateTime.UtcNow; + + // ============ 导航属性 ============ + + /// + /// 导航属性 - 关联的用户信息 + /// + [ForeignKey("UserId")] + public virtual User User { get; set; } = null!; +} + +### Notification 通知实体 +```csharp +/// +/// 通知实体类 - 存储发送给用户的各种系统通知和消息 +/// 支持多种通知类型和状态管理 +/// +[Table("notifications")] +public class Notification +{ + /// + /// 唯一标识符 - 通知记录的主键 + /// + [Key] + public Guid Id { get; set; } = Guid.NewGuid(); + + /// + /// 用户ID - 接收通知的用户 + /// + [Required] + [Column("user_id")] + public Guid UserId { get; set; } + + /// + /// 通知类型 - 通知的分类和用途 + /// + [Required] + [Column("notification_type")] + public NotificationType NotificationType { get; set; } + + /// + /// 通知标题 - 通知的主题或标题 + /// + [Required] + [MaxLength(100)] + [Column("title")] + public string Title { get; set; } = string.Empty; + + /// + /// 通知内容 - 通知的详细内容或描述 + /// + [Required] + [MaxLength(500)] + [Column("content")] + public string Content { get; set; } = string.Empty; + + /// + /// 是否已读 - 标记用户是否已经查看该通知 + /// + [Column("is_read")] + public bool IsRead { get; set; } = false; + + /// + /// 相关数据 - 通知相关的额外数据，JSON格式存储 + /// 例如：游戏ID、房间ID、用户ID等相关联的信息 + /// + [Column("data", TypeName = "json")] + public string? Data { get; set; } + + /// + /// 创建时间 - 通知产生的时间 + /// + [Column("created_at")] + public DateTime CreatedAt { get; set; } = DateTime.UtcNow; + + /// + /// 阅读时间 - 用户查看通知的时间 + /// + [Column("read_at")] + public DateTime? ReadAt { get; set; } + + // ============ 导航属性 ============ + + /// + /// 导航属性 - 接收通知的用户 + /// + [ForeignKey("UserId")] + public virtual User User { get; set; } = null!; +} + +/// +/// 通知类型枚举 - 定义不同种类的系统通知 +/// +public enum NotificationType +{ + /// + /// 系统通知 - 来自系统的重要消息 + /// + System, + + /// + /// 排名变化 - 用户排名发生变化的通知 + /// + RankingChange, + + /// + /// 成就解锁 - 获得新成就的通知 + /// + Achievement, + + /// + /// 游戏结果 - 游戏结束后的结果通知 + /// + GameResult +} + +## 总结 + +以上完成了EF Core实体模型的重构，主要改进包括： + +### ✅ 基类设计 +1. **BaseEntity** - 包含Id、时间戳、软删除、版本控制等基础属性 +2. **AuditableEntity** - 继承BaseEntity，添加创建者和修改者追踪 + +### 🔐 双Token认证机制 +1. **AccessToken** - 短期访问令牌（15-30分钟） +2. **RefreshToken** - 长期刷新令牌（7-30天） +3. **会话状态管理** - Active/Expired/Revoked/Replaced +4. **设备跟踪** - IP、UserAgent、设备类型等 + +### 🛡️ 数据安全特性 +1. **软删除** - 逻辑删除，数据可恢复 +2. **审计日志** - 自动记录创建者和修改者 +3. **乐观锁** - RowVersion字段防止并发冲突 +4. **全局查询过滤器** - 自动过滤已删除数据 + +### 🚀 性能优化 +1. **索引优化** - 复合索引、唯一索引、过滤索引 +2. **批量操作** - 重写SaveChanges支持批量审计 +3. **查询过滤** - 软删除的全局过滤器 + +### 📱 功能增强 +1. **多设备支持** - 设备类型和名称跟踪 +2. **会话管理** - 支持记住登录、手动吊销 +3. **安全审计** - IP地址、用户代理记录 +4. **种子数据** - 系统初始化数据配置 + +这个设计为实时协作应用提供了完整的数据模型基础，支持现代应用的安全性、可审计性和可扩展性需求！ + +## 重构总结 - 双Token集成到User实体 + +### ✅ **主要改进** + +#### 1. **简化架构** +- **移除UserSession实体**: 将双token机制直接集成到User实体中 +- **减少表关系**: 简化了数据库结构，提高查询效率 +- **统一用户管理**: 用户信息和认证信息在同一个实体中管理 + +#### 2. **双Token认证优化** +- **AccessToken**: 短期访问令牌（15-30分钟） +- **RefreshToken**: 长期刷新令牌（7-30天） +- **TokenStatus**: 令牌状态管理（None/Active/Expired/Revoked/NeedsRefresh） +- **设备跟踪**: DeviceInfo字段存储设备信息（JSON格式） + +#### 3. **安全性增强** +- **令牌唯一性**: AccessToken和RefreshToken的唯一索引 +- **过期时间管理**: 精确的令牌过期时间控制 +- **活跃时间跟踪**: LastActivityAt字段追踪用户活跃度 +- **吊销机制**: 支持令牌手动吊销和原因记录 + +#### 4. **性能优化** +- **减少JOIN操作**: 用户认证查询无需关联UserSession表 +- **过滤索引**: 为非空token字段创建过滤索引 +- **复合索引**: 优化token状态和过期时间查询 + +#### 5. **开发体验改进** +- **简化API**: 用户登录/认证逻辑更简单 +- **减少实体**: 更少的实体类需要维护 +- **统一字段**: 所有用户相关信息集中管理 + +### 🚀 **使用优势** + +1. **架构简洁**: 更少的表和关系，降低复杂度 +2. **查询高效**: 减少JOIN操作，提高认证查询性能 +3. **维护便利**: 用户信息和认证状态统一管理 +4. **扩展灵活**: DeviceInfo JSON字段支持灵活的设备信息存储 +5. **安全可靠**: 完整的token生命周期管理和安全控制 + +### 📝 **API使用示例** + +```csharp +// 用户登录 - 生成双token +var user = await dbContext.Users.FirstOrDefaultAsync(u => u.Username == username); +user.AccessToken = GenerateAccessToken(); +user.RefreshToken = GenerateRefreshToken(); +user.AccessTokenExpiresAt = DateTime.UtcNow.AddMinutes(30); +user.RefreshTokenExpiresAt = DateTime.UtcNow.AddDays(7); +user.TokenStatus = TokenStatus.Active; +user.LastLoginAt = DateTime.UtcNow; +user.LastActivityAt = DateTime.UtcNow; + +// 令牌刷新 +var user = await dbContext.Users.FirstOrDefaultAsync(u => u.RefreshToken == refreshToken); +if (user != null && user.RefreshTokenExpiresAt > DateTime.UtcNow) +{ + user.AccessToken = GenerateAccessToken(); + user.AccessTokenExpiresAt = DateTime.UtcNow.AddMinutes(30); + user.TokenStatus = TokenStatus.Active; +} + +// 用户注销 - 清除token +user.AccessToken = null; +user.RefreshToken = null; +user.TokenStatus = TokenStatus.None; +``` + +--- + +## 原始总结 + +以下是重构前的实体设计工作总结： + +### ✅ 已完成的工作 +1. **用户相关实体**：User、UserStatistics - 详细的中文注释 +2. **房间相关实体**：Room、RoomPlayer、RoomMessage - 完整的属性和导航属性注释 +3. **游戏相关实体**：Game、GamePlayer、GameAction - 游戏逻辑和数据记录注释 +4. **排行榜相关实体**：Ranking、RankingHistory - 排名系统的详细说明 +5. **社交相关实体**：Friend、FriendRequest - 好友系统的状态管理注释 +6. **通知相关实体**：Notification - 消息推送系统的注释 +7. **数据库上下文**：ApplicationDbContext - 完整的EF Core配置和关系映射注释 + +### 📝 注释特点 +- **中文注释**：便于团队理解和维护 +- **XML文档格式**：支持IDE智能提示和API文档生成 +- **详细说明**：每个属性都有用途、格式、约束等详细说明 +- **关系说明**：清楚标注了实体间的导航属性和外键关系 +- **索引配置**：详细说明了各种索引的用途和优化目标 + +### 🎯 实用价值 +1. **代码可维护性**：新团队成员可快速理解数据模型 +2. **开发效率**：IDE智能提示提供详细的属性说明 +3. **文档自动生成**：可基于XML注释自动生成API文档 +4. **数据库设计参考**：清晰的实体关系有助于数据库优化 + +数据库设计文档现已完整，可以作为后续开发的重要参考资料！ \ No newline at end of file diff --git a/docs/ENTITY_CREATION_SUMMARY.md b/docs/ENTITY_CREATION_SUMMARY.md new file mode 100644 index 0000000000000000000000000000000000000000..53c0d15568af9cd38676d700ce803c045f2b91de --- /dev/null +++ b/docs/ENTITY_CREATION_SUMMARY.md @@ -0,0 +1,96 @@ +# Entity Framework Core 实体创建完成总结 + +## ✅ 已创建的实体类 + +### 1. 基类实体 +- **BaseEntity.cs** - 基础实体类，包含Id、时间戳、软删除等共有属性 +- **AuditableEntity.cs** - 可审计实体类，继承BaseEntity，添加创建者和修改者追踪 + +### 2. 用户相关实体 (Auth文件夹) +- **User.cs** - 用户实体，包含登录信息、双Token认证机制、用户状态等 +- **UserStatistics.cs** - 用户统计实体，存储游戏数据统计信息 + +### 3. 房间相关实体 (Room文件夹) +- **Room.cs** - 房间实体，游戏房间的基本信息和配置 +- **RoomPlayer.cs** - 房间玩家实体，记录玩家在房间中的状态 +- **RoomMessage.cs** - 房间聊天消息实体，存储房间内的聊天记录 + +### 4. 游戏相关实体 (Game文件夹) +- **Game.cs** - 游戏实体，存储单局游戏的基本信息和状态 +- **GamePlayer.cs** - 游戏玩家实体，记录玩家在特定游戏中的表现 +- **GameAction.cs** - 游戏操作记录实体，用于游戏回放和数据分析 + +### 5. 排行榜和通知实体 +- **Ranking.cs** - 排行榜实体，存储各种类型的玩家排名数据 +- **RankingHistory.cs** - 排名历史实体，记录用户排名的历史变化 +- **Notification.cs** - 通知实体，存储发送给用户的各种系统通知 + +## 🛠️ 技术特性 + +### 双Token认证机制 +- AccessToken（短期令牌）和RefreshToken（长期令牌） +- TokenStatus枚举管理令牌状态 +- 设备信息跟踪和令牌吊销功能 + +### 数据库优化 +- 完整的索引配置，包括唯一索引、复合索引、过滤索引 +- 软删除全局过滤器 +- 自动审计字段处理 + +### 实体关系配置 +- 一对一：User ↔ UserStatistics +- 一对多：User → OwnedRooms, RoomPlayers, GamePlayers, Notifications +- 一对多：Room → Players, Messages, Games +- 一对多：Game → Players, Actions + +## 📁 文件结构 +``` +CollabApp.Domain/ +├── Entities/ +│ ├── BaseEntity.cs +│ ├── AuditableEntity.cs +│ ├── Auth/ +│ │ ├── User.cs +│ │ └── UserStatistics.cs +│ ├── Room/ +│ │ ├── Room.cs +│ │ ├── RoomPlayer.cs +│ │ └── RoomMessage.cs +│ ├── Game/ +│ │ ├── Game.cs +│ │ ├── GamePlayer.cs +│ │ └── GameAction.cs +│ ├── Ranking.cs +│ ├── RankingHistory.cs +│ └── Notification.cs +``` + +## 🗄️ 数据库上下文 +**ApplicationDbContext.cs** - 完整的EF Core DbContext配置 +- 所有实体的DbSet定义 +- 完整的关系配置和索引设置 +- 自动审计字段处理 +- 软删除全局过滤器 + +## ⚡ 构建状态 +✅ **项目构建成功** - 所有实体类编译通过，无错误 + +## 🔧 包依赖 +- Microsoft.EntityFrameworkCore 9.0.8 +- Microsoft.EntityFrameworkCore.Relational 9.0.8 +- Microsoft.EntityFrameworkCore.SqlServer 9.0.8 +- Microsoft.EntityFrameworkCore.Tools 9.0.8 +- Microsoft.EntityFrameworkCore.Design 9.0.8 + +## 📝 使用说明 +1. 所有实体类已按照设计文档创建完成 +2. 包含详细的中文注释，支持IDE智能提示 +3. 实体关系和索引已优化配置 +4. 支持软删除、审计日志等企业级特性 +5. 双Token认证机制已集成到User实体中 + +## 🚀 下一步 +- 可以开始创建Migration文件生成数据库 +- 实现Repository模式的数据访问层 +- 配置依赖注入和服务注册 +- 开发业务逻辑和API控制器 diff --git a/frontend/.gitattributes b/frontend/.gitattributes new file mode 100644 index 0000000000000000000000000000000000000000..6313b56c57848efce05faa7aa7e901ccfc2886ea --- /dev/null +++ b/frontend/.gitattributes @@ -0,0 +1 @@ +* text=auto eol=lf diff --git a/frontend/.gitignore b/frontend/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..8ee54e8d343e466a213c8c30aa04be77126b170d --- /dev/null +++ b/frontend/.gitignore @@ -0,0 +1,30 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +.DS_Store +dist +dist-ssr +coverage +*.local + +/cypress/videos/ +/cypress/screenshots/ + +# Editor directories and files +.vscode/* +!.vscode/extensions.json +.idea +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? + +*.tsbuildinfo diff --git a/frontend/.prettierrc.json b/frontend/.prettierrc.json new file mode 100644 index 0000000000000000000000000000000000000000..29a2402ef050746efe041b9e3393bf33796407c3 --- /dev/null +++ b/frontend/.prettierrc.json @@ -0,0 +1,6 @@ +{ + "$schema": "https://json.schemastore.org/prettierrc", + "semi": false, + "singleQuote": true, + "printWidth": 100 +} diff --git a/frontend/index.html b/frontend/index.html new file mode 100644 index 0000000000000000000000000000000000000000..82168f0d661822266928386a774576a524b5e4bd --- /dev/null +++ b/frontend/index.html @@ -0,0 +1,15 @@ + + + + + + + 实时协作应用 + + + + +
+ + + diff --git a/frontend/jsconfig.json b/frontend/jsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..5a1f2d222a302a174e710614c6d76531b7bda926 --- /dev/null +++ b/frontend/jsconfig.json @@ -0,0 +1,8 @@ +{ + "compilerOptions": { + "paths": { + "@/*": ["./src/*"] + } + }, + "exclude": ["node_modules", "dist"] +} diff --git a/frontend/package.json b/frontend/package.json new file mode 100644 index 0000000000000000000000000000000000000000..7e5f54576c0f38a5285e51c47f1905fd0eb752b2 --- /dev/null +++ b/frontend/package.json @@ -0,0 +1,32 @@ +{ + "name": "frontend", + "version": "0.0.0", + "private": true, + "type": "module", + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "scripts": { + "dev": "vite", + "build": "vite build", + "preview": "vite preview", + "test:unit": "vitest", + "format": "prettier --write src/" + }, + "dependencies": { + "@microsoft/signalr": "^9.0.6", + "axios": "^1.11.0", + "pinia": "^3.0.3", + "vue": "^3.5.18", + "vue-router": "^4.5.1" + }, + "devDependencies": { + "@vitejs/plugin-vue": "^6.0.1", + "@vue/test-utils": "^2.4.6", + "jsdom": "^26.1.0", + "prettier": "3.6.2", + "vite": "^7.0.6", + "vite-plugin-vue-devtools": "^8.0.0", + "vitest": "^3.2.4" + } +} diff --git a/frontend/profile-preview.html b/frontend/profile-preview.html new file mode 100644 index 0000000000000000000000000000000000000000..c0128250d07526e9a6f0a0a755dfefdc25e6c15c --- /dev/null +++ b/frontend/profile-preview.html @@ -0,0 +1,190 @@ + + + + + + 个人中心页面预览 + + + + +
+
+

个人中心页面完成

+

负责人：钟嘉妮

+
+ +
+
+
+ + 用户信息管理 +
+
+ • 头像上传和预览
+ • 用户名、邮箱编辑
+ • 实时保存功能
+ • 表单验证 +
+
+ +
+
+ + 等级系统 +
+
+ • 动态等级徽章
+ • 经验值进度条
+ • 多级别称号
+ • 视觉效果动画 +
+
+ +
+
+ + 游戏统计 +
+
+ • 总游戏场次
+ • 胜率统计
+ • 排名显示
+ • 最佳连胜记录 +
+
+ +
+
+ + 游戏历史 +
+
+ • 最近游戏记录
+ • 分页加载
+ • 结果状态显示
+ • 时间格式化 +
+
+ +
+
+ + 安全设置 +
+
+ • 密码修改功能
+ • 安全验证
+ • 表单验证
+ • 错误处理 +
+
+ +
+
+ + 通知系统 +
+
+ • 成功/错误提示
+ • 动画效果
+ • 自动消失
+ • 响应式设计 +
+
+
+ +
+

技术栈

+
+ Vue 3 + Composition API + Pinia + Vue Router + Axios + CSS Grid + 响应式设计 + 组件化开发 +
+
+ +
+

个人中心页面开发完成！

+

包含完整的用户信息管理、游戏统计、历史记录和安全设置功能。

+
+
+ + diff --git a/frontend/public/default-avatar.svg b/frontend/public/default-avatar.svg new file mode 100644 index 0000000000000000000000000000000000000000..1da2299154dcd69f33c6b32ce80042b552a9f05b --- /dev/null +++ b/frontend/public/default-avatar.svg @@ -0,0 +1,6 @@ + + + + + + diff --git a/frontend/public/favicon.ico b/frontend/public/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..df36fcfb72584e00488330b560ebcf34a41c64c2 Binary files /dev/null and b/frontend/public/favicon.ico differ diff --git a/frontend/ranking-preview.html b/frontend/ranking-preview.html new file mode 100644 index 0000000000000000000000000000000000000000..df87dfa693abe6b2e82c19a0fe6a70f304211ed4 --- /dev/null +++ b/frontend/ranking-preview.html @@ -0,0 +1,380 @@ + + + + + + 排行榜页面预览 + + + + +
+
+

排行榜页面完成

+

负责人：钟嘉妮

+

一个功能完整、界面美观的竞技排行榜系统

+
+ +
+
+
+ + 多维度排行榜 +
+
    +
  • 总积分排行榜
    • +
  • 周榜实时更新
    • +
  • 月榜历史统计
    • +
  • 好友排行榜
    • +
  • 分游戏类型排名
    • +
+
+ +
+
+ + 领奖台展示 +
+
    +
  • 前三名特殊展示
    • +
  • 金银铜牌设计
    • +
  • 冠军皇冠动效
    • +
  • 等级徽章显示
    • +
  • 头像边框特效
    • +
+
+ +
+
+ + 用户信息展示 +
+
    +
  • 用户头像与等级
    • +
  • 在线状态指示
    • +
  • VIP标识显示
    • +
  • 排名变化趋势
    • +
  • 个人战绩统计
    • +
+
+ +
+
+ + 交互体验 +
+
    +
  • 标签页切换
    • +
  • 分页加载
    • +
  • 实时刷新
    • +
  • 加载状态提示
    • +
  • 响应式布局
    • +
+
+ +
+
+ + 数据统计 +
+
    +
  • 总玩家数统计
    • +
  • 游戏场次统计
    • +
  • 个人排名查询
    • +
  • 今日活跃用户
    • +
  • 胜率统计显示
    • +
+
+ +
+
+ + 移动端适配 +
+
    +
  • 响应式网格布局
    • +
  • 移动端优化显示
    • +
  • 触摸友好交互
    • +
  • 垂直布局适配
    • +
  • 字体大小自适应
    • +
+
+
+ +
+

+ 排行榜统计数据展示 +

+
+
+
1,247
+
总玩家数
+
+
+
15,634
+
总游戏场次
+
+
+
156
+
我的排名
+
+
+
89
+
今日活跃
+
+
+
+ +
+
+ 界面预览功能 +
+
+
+

领奖台

+

前三名玩家特殊展示，包含皇冠动效、奖牌颜色区分和等级徽章

+
+
+

排行榜列表

+

完整的玩家排名列表，显示头像、等级、积分、胜率等详细信息

+
+
+

实时更新

+

支持手动刷新和自动更新，保证排行榜数据的实时性

+
+
+

多维筛选

+

支持总榜、周榜、月榜、好友榜等多种维度的排行榜切换

+
+
+
+ +
+

技术实现亮点

+
+
+
+
Vue 3 Composition API
+
+
+
+
Pinia 状态管理
+
+
+
+
响应式设计
+
+
+
+
CSS Grid 布局
+
+
+
+
动画过渡效果
+
+
+
+
组件化开发
+
+
+
+ +
+ + 排行榜页面开发完成！ +
+ 包含完整的排名展示、数据统计、用户交互和移动端适配功能 +
+ +
+

主要特色：

+

🏆 视觉效果出色的领奖台设计

+

📊 多维度排行榜数据展示

+

📱 完善的移动端适配

+

⚡ 流畅的用户交互体验

+
+
+ + diff --git a/frontend/src/App.vue b/frontend/src/App.vue new file mode 100644 index 0000000000000000000000000000000000000000..929dd6c70e2fc8e8e03df7f77688c0e747aa93dd --- /dev/null +++ b/frontend/src/App.vue @@ -0,0 +1,147 @@ + + + + + diff --git a/frontend/src/api/auth.js b/frontend/src/api/auth.js new file mode 100644 index 0000000000000000000000000000000000000000..c174922b242d434b4a4a8d0a59286001b46aac02 --- /dev/null +++ b/frontend/src/api/auth.js @@ -0,0 +1,39 @@ +import api from './index.js' + +// 认证相关API - 负责人：陆楚盈 +export const authAPI = { + // 用户登录 + login(credentials) { + return api.post('/auth/login', credentials) + }, + + // 用户注册 + register(userData) { + return api.post('/auth/register', userData) + }, + + // 忘记密码 + forgotPassword(email) { + return api.post('/auth/forgot-password', { email }) + }, + + // 重置密码 + resetPassword(token, newPassword) { + return api.post('/auth/reset-password', { token, newPassword }) + }, + + // 刷新token + refreshToken() { + return api.post('/auth/refresh-token') + }, + + // 登出 + logout() { + return api.post('/auth/logout') + }, + + // 验证token + verifyToken() { + return api.get('/auth/verify') + } +} diff --git a/frontend/src/api/common.js b/frontend/src/api/common.js new file mode 100644 index 0000000000000000000000000000000000000000..588ac21768305b4b7691ec8413284463b4d3924d --- /dev/null +++ b/frontend/src/api/common.js @@ -0,0 +1,89 @@ +import api from './index.js' + +// 通知相关API +export const notificationAPI = { + // 获取通知列表 + getNotifications(page = 1, limit = 10, unreadOnly = false) { + return api.get('/notifications', { + params: { page, limit, unreadOnly } + }) + }, + + // 标记通知为已读 + markAsRead(notificationId) { + return api.put(`/notifications/${notificationId}/read`) + }, + + // 标记所有通知为已读 + markAllAsRead() { + return api.put('/notifications/read-all') + }, + + // 删除通知 + deleteNotification(notificationId) { + return api.delete(`/notifications/${notificationId}`) + }, + + // 获取未读通知数量 + getUnreadCount() { + return api.get('/notifications/unread-count') + } +} + +// 好友相关API +export const friendAPI = { + // 获取好友列表 + getFriends() { + return api.get('/friends') + }, + + // 发送好友请求 + sendFriendRequest(userId) { + return api.post('/friends/request', { userId }) + }, + + // 接受好友请求 + acceptFriendRequest(requestId) { + return api.put(`/friends/request/${requestId}/accept`) + }, + + // 拒绝好友请求 + rejectFriendRequest(requestId) { + return api.put(`/friends/request/${requestId}/reject`) + }, + + // 删除好友 + removeFriend(friendId) { + return api.delete(`/friends/${friendId}`) + }, + + // 搜索用户 + searchUsers(keyword) { + return api.get('/users/search', { + params: { keyword } + }) + } +} + +// 系统相关API +export const systemAPI = { + // 获取系统公告 + getAnnouncements() { + return api.get('/system/announcements') + }, + + // 获取游戏配置 + getGameConfig() { + return api.get('/system/config') + }, + + // 获取服务器状态 + getServerStatus() { + return api.get('/system/status') + }, + + // 意见反馈 + submitFeedback(feedback) { + return api.post('/system/feedback', feedback) + } +} diff --git a/frontend/src/api/game.js b/frontend/src/api/game.js new file mode 100644 index 0000000000000000000000000000000000000000..34a756fc384f4edb7bc8a1ab9e8bcf3c8882f5fc --- /dev/null +++ b/frontend/src/api/game.js @@ -0,0 +1,64 @@ +import api from './index.js' + +// 游戏相关API - 负责人：程梦、郭小燕、范鸿雯 +export const gameAPI = { + // 获取游戏状态 + getGameState(gameId) { + return api.get(`/games/${gameId}/state`) + }, + + // 执行游戏操作 + makeMove(gameId, moveData) { + return api.post(`/games/${gameId}/move`, moveData) + }, + + // 暂停游戏 + pauseGame(gameId) { + return api.post(`/games/${gameId}/pause`) + }, + + // 恢复游戏 + resumeGame(gameId) { + return api.post(`/games/${gameId}/resume`) + }, + + // 投降 + surrender(gameId) { + return api.post(`/games/${gameId}/surrender`) + }, + + // 获取游戏结果 + getGameResult(gameId) { + return api.get(`/games/${gameId}/result`) + }, + + // 获取游戏历史记录 + getGameHistory(gameId) { + return api.get(`/games/${gameId}/history`) + }, + + // 获取游戏统计 + getGameStats(gameId) { + return api.get(`/games/${gameId}/stats`) + }, + + // 重新开始游戏 + restartGame(gameId) { + return api.post(`/games/${gameId}/restart`) + }, + + // 邀请玩家再来一局 + inviteReplay(gameId, playerIds) { + return api.post(`/games/${gameId}/invite-replay`, { playerIds }) + }, + + // 保存游戏 + saveGame(gameId) { + return api.post(`/games/${gameId}/save`) + }, + + // 加载游戏 + loadGame(saveId) { + return api.post(`/games/load/${saveId}`) + } +} diff --git a/frontend/src/api/index.js b/frontend/src/api/index.js new file mode 100644 index 0000000000000000000000000000000000000000..fac7a5a82df5963e6ca2f1d5ea76018accc62018 --- /dev/null +++ b/frontend/src/api/index.js @@ -0,0 +1,44 @@ +// API基础配置 +import axios from 'axios' + +// 创建axios实例 +const api = axios.create({ + baseURL: import.meta.env.VITE_API_BASE_URL || 'http://localhost:5000/api', + timeout: 10000, + headers: { + 'Content-Type': 'application/json' + } +}) + +// 请求拦截器 +api.interceptors.request.use( + (config) => { + // 添加token到请求头 + const token = localStorage.getItem('token') + if (token) { + config.headers.Authorization = `Bearer ${token}` + } + return config + }, + (error) => { + return Promise.reject(error) + } +) + +// 响应拦截器 +api.interceptors.response.use( + (response) => { + return response.data + }, + (error) => { + // 处理响应错误 + if (error.response?.status === 401) { + // 未授权，清除token并跳转到登录页 + localStorage.removeItem('token') + window.location.href = '/login' + } + return Promise.reject(error) + } +) + +export default api diff --git a/frontend/src/api/ranking.js b/frontend/src/api/ranking.js new file mode 100644 index 0000000000000000000000000000000000000000..3f36746f8453ce4cef9adfa3b0b299ba75f6304f --- /dev/null +++ b/frontend/src/api/ranking.js @@ -0,0 +1,56 @@ +import api from './index.js' + +// 排行榜相关API - 负责人：钟嘉妮 +export const rankingAPI = { + // 获取总排行榜 + getOverallRanking(page = 1, limit = 20) { + return api.get('/rankings/overall', { + params: { page, limit } + }) + }, + + // 获取周排行榜 + getWeeklyRanking(page = 1, limit = 20) { + return api.get('/rankings/weekly', { + params: { page, limit } + }) + }, + + // 获取月排行榜 + getMonthlyRanking(page = 1, limit = 20) { + return api.get('/rankings/monthly', { + params: { page, limit } + }) + }, + + // 获取好友排行榜 + getFriendsRanking(page = 1, limit = 20) { + return api.get('/rankings/friends', { + params: { page, limit } + }) + }, + + // 获取用户排名信息 + getUserRanking(userId) { + return api.get(`/rankings/user/${userId}`) + }, + + // 获取排行榜统计 + getRankingStats() { + return api.get('/rankings/stats') + }, + + // 按游戏类型获取排行榜 + getRankingByGameType(gameType, period = 'overall', page = 1, limit = 20) { + return api.get(`/rankings/game-type/${gameType}`, { + params: { period, page, limit } + }) + }, + + // 获取段位排行榜 + getTierRanking(tier, page = 1, limit = 20) { + return api.get(`/rankings/tier/${tier}`, { + params: { page, limit } + }) + } +} diff --git a/frontend/src/api/room.js b/frontend/src/api/room.js new file mode 100644 index 0000000000000000000000000000000000000000..1dfc77f8417e72af07ab6ce3609775a28d693efa --- /dev/null +++ b/frontend/src/api/room.js @@ -0,0 +1,63 @@ +import api from './index.js' + +// 房间相关API - 负责人：程梦 +export const roomAPI = { + // 获取房间列表 + getRooms(page = 1, limit = 10, filters = {}) { + return api.get('/rooms', { + params: { page, limit, ...filters } + }) + }, + + // 创建房间 + createRoom(roomData) { + return api.post('/rooms', roomData) + }, + + // 加入房间 + joinRoom(roomId, password = null) { + return api.post(`/rooms/${roomId}/join`, { password }) + }, + + // 离开房间 + leaveRoom(roomId) { + return api.post(`/rooms/${roomId}/leave`) + }, + + // 获取房间详情 + getRoomInfo(roomId) { + return api.get(`/rooms/${roomId}`) + }, + + // 获取房间内玩家列表 + getRoomPlayers(roomId) { + return api.get(`/rooms/${roomId}/players`) + }, + + // 切换准备状态 + toggleReady(roomId) { + return api.post(`/rooms/${roomId}/ready`) + }, + + // 开始游戏（房主） + startGame(roomId) { + return api.post(`/rooms/${roomId}/start`) + }, + + // 踢出玩家（房主） + kickPlayer(roomId, playerId) { + return api.post(`/rooms/${roomId}/kick`, { playerId }) + }, + + // 发送房间聊天消息 + sendMessage(roomId, message) { + return api.post(`/rooms/${roomId}/chat`, { message }) + }, + + // 获取房间聊天历史 + getChatHistory(roomId, page = 1, limit = 50) { + return api.get(`/rooms/${roomId}/chat`, { + params: { page, limit } + }) + } +} diff --git a/frontend/src/api/user.js b/frontend/src/api/user.js new file mode 100644 index 0000000000000000000000000000000000000000..c6c3828b96cced96dc5185a8e63e79f8866dee37 --- /dev/null +++ b/frontend/src/api/user.js @@ -0,0 +1,60 @@ +import api from './index.js' + +// 用户相关API - 负责人：陆楚盈（主页）、钟嘉妮（个人中心） +export const userAPI = { + // 获取用户信息 + getUserInfo() { + return api.get('/user/profile') + }, + + // 更新用户信息 + updateUserInfo(userData) { + return api.put('/user/profile', userData) + }, + + // 上传头像 + uploadAvatar(formData) { + return api.post('/user/avatar', formData, { + headers: { + 'Content-Type': 'multipart/form-data' + } + }) + }, + + // 获取用户统计数据 + getUserStats() { + return api.get('/user/stats') + }, + + // 获取用户游戏历史 + getGameHistory(page = 1, limit = 10) { + return api.get('/user/game-history', { + params: { page, limit } + }) + }, + + // 修改密码 + changePassword(oldPassword, newPassword) { + return api.put('/user/password', { oldPassword, newPassword }) + }, + + // 获取隐私设置 + getPrivacySettings() { + return api.get('/user/privacy-settings') + }, + + // 更新隐私设置 + updatePrivacySettings(settings) { + return api.put('/user/privacy-settings', settings) + }, + + // 导出用户数据 + exportUserData() { + return api.get('/user/export-data') + }, + + // 删除账户 + deleteAccount() { + return api.delete('/user/account') + } +} diff --git a/frontend/src/components/common/AppNavbar.vue b/frontend/src/components/common/AppNavbar.vue new file mode 100644 index 0000000000000000000000000000000000000000..8ae43b58ccf6eaa1ea3b70f9418ca44330e3a1ee --- /dev/null +++ b/frontend/src/components/common/AppNavbar.vue @@ -0,0 +1,486 @@ + + + + + diff --git a/frontend/src/components/common/AppNavigation.vue b/frontend/src/components/common/AppNavigation.vue new file mode 100644 index 0000000000000000000000000000000000000000..1ace2811b7893b46f2e13b49f85c1b5dd91a3569 --- /dev/null +++ b/frontend/src/components/common/AppNavigation.vue @@ -0,0 +1,124 @@ + + + + + diff --git a/frontend/src/components/common/Notification.vue b/frontend/src/components/common/Notification.vue new file mode 100644 index 0000000000000000000000000000000000000000..ae74813a952c8b485261adef2c8d86985c2c417d --- /dev/null +++ b/frontend/src/components/common/Notification.vue @@ -0,0 +1,267 @@ + + + + + diff --git a/frontend/src/components/common/NotificationContainer.vue b/frontend/src/components/common/NotificationContainer.vue new file mode 100644 index 0000000000000000000000000000000000000000..b48ae9d01dcc8013d638e52a9ce3571ccaa8dccb --- /dev/null +++ b/frontend/src/components/common/NotificationContainer.vue @@ -0,0 +1,258 @@ + + + + + diff --git a/frontend/src/components/common/README.md b/frontend/src/components/common/README.md new file mode 100644 index 0000000000000000000000000000000000000000..632bcef2055de0280b6ec291b3223cec76fc87c8 --- /dev/null +++ b/frontend/src/components/common/README.md @@ -0,0 +1,3 @@ +# common + +通用组件目录，存放项目中可复用的基础组件，如按钮、弹窗、加载、图标等。 diff --git a/frontend/src/components/common/UserLevelBadge.vue b/frontend/src/components/common/UserLevelBadge.vue new file mode 100644 index 0000000000000000000000000000000000000000..7c6a7239139d5d73dbbe3391dff7740e5f38a74c --- /dev/null +++ b/frontend/src/components/common/UserLevelBadge.vue @@ -0,0 +1,176 @@ + + + + + diff --git a/frontend/src/components/editor/README.md b/frontend/src/components/editor/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7486fd8d23ed9eb3d8c7e79546ef7bce21940d9a --- /dev/null +++ b/frontend/src/components/editor/README.md @@ -0,0 +1,3 @@ +# editor + +编辑器相关组件目录，存放富文本、代码编辑器等功能性组件。 diff --git a/frontend/src/components/forms/README.md b/frontend/src/components/forms/README.md new file mode 100644 index 0000000000000000000000000000000000000000..30ffcab438edf0594bc2b057b88335aba0ad83b3 --- /dev/null +++ b/frontend/src/components/forms/README.md @@ -0,0 +1,3 @@ +# forms + +表单相关组件目录，存放登录、注册、信息填写等表单组件。 diff --git a/frontend/src/main.js b/frontend/src/main.js new file mode 100644 index 0000000000000000000000000000000000000000..85287cb9e596957103d41109ed442eb907ff02fa --- /dev/null +++ b/frontend/src/main.js @@ -0,0 +1,14 @@ +import { createApp } from 'vue' +import { createPinia } from 'pinia' + +import App from './App.vue' +import router from './router' +// import notificationPlugin from './utils/notification.js' + +const app = createApp(App) + +app.use(createPinia()) +app.use(router) +// app.use(notificationPlugin) + +app.mount('#app') diff --git a/frontend/src/router/index.js b/frontend/src/router/index.js new file mode 100644 index 0000000000000000000000000000000000000000..70495f4ab65405cebdce11dac9e18df0b6f41a64 --- /dev/null +++ b/frontend/src/router/index.js @@ -0,0 +1,9 @@ +import { createRouter, createWebHistory } from 'vue-router' +import routes from './routes.js' + +const router = createRouter({ + history: createWebHistory(import.meta.env.BASE_URL), + routes +}) + +export default router diff --git a/frontend/src/router/routes.js b/frontend/src/router/routes.js new file mode 100644 index 0000000000000000000000000000000000000000..a41eb0a06acb0d46fd426f6c2ea0c7c61d9fc7eb --- /dev/null +++ b/frontend/src/router/routes.js @@ -0,0 +1,52 @@ +export default [ + { + path: '/', + name: 'Home', + component: () => import('../views/home/HomePage.vue') + }, + { + path: '/auth', + children: [ + { + path: 'login', + name: 'Login', + component: () => import('../views/auth/LoginPage.vue') + }, + { + path: 'register', + name: 'Register', + component: () => import('../views/auth/RegisterPage.vue') + } + ] + }, + { + path: '/lobby', + name: 'Lobby', + component: () => import('../views/lobby/LobbyPage.vue') + }, + { + path: '/room/:id', + name: 'Room', + component: () => import('../views/lobby/RoomPage.vue') + }, + { + path: '/game/:id', + name: 'Game', + component: () => import('../views/game/GamePage.vue') + }, + { + path: '/game-result/:id', + name: 'GameResult', + component: () => import('../views/game/GameResultPage.vue') + }, + { + path: '/profile', + name: 'Profile', + component: () => import('../views/profile/Profile.vue') + }, + { + path: '/ranking', + name: 'Ranking', + component: () => import('../views/ranking/Ranking.vue') + } +] \ No newline at end of file diff --git a/frontend/src/stores/README.md b/frontend/src/stores/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1265942cc3a908bbc38db96b59f7be5d0806cb4c --- /dev/null +++ b/frontend/src/stores/README.md @@ -0,0 +1,3 @@ +# stores + +状态管理目录，建议使用Pinia或Vuex，存放全局和模块化的状态管理文件。 diff --git a/frontend/src/stores/user.js b/frontend/src/stores/user.js new file mode 100644 index 0000000000000000000000000000000000000000..e36e7d24e730699cb1db816d5339f42360045ed9 --- /dev/null +++ b/frontend/src/stores/user.js @@ -0,0 +1,182 @@ +import { defineStore } from 'pinia' +import { ref, reactive, computed } from 'vue' +import { userAPI } from '@/api/user.js' + +export const useUserStore = defineStore('user', () => { + // 状态 + const isLoggedIn = ref(false) + const token = ref(localStorage.getItem('token') || '') + const userInfo = reactive({ + id: null, + username: '', + email: '', + avatar: '', + level: 1, + experience: 0, + totalGames: 0, + winRate: 0, + ranking: null, + bestStreak: 0, + joinDate: null + }) + + // 计算属性 + const isAuthenticated = computed(() => isLoggedIn.value && !!token.value) + + const expProgress = computed(() => { + const currentLevelExp = (userInfo.level - 1) * 1000 + const nextLevelExp = userInfo.level * 1000 + const progress = ((userInfo.experience - currentLevelExp) / (nextLevelExp - currentLevelExp)) * 100 + return Math.min(100, Math.max(0, progress)) + }) + + const nextLevelExp = computed(() => { + return userInfo.level * 1000 + }) + + // 方法 + const setToken = (newToken) => { + token.value = newToken + if (newToken) { + localStorage.setItem('token', newToken) + isLoggedIn.value = true + } else { + localStorage.removeItem('token') + isLoggedIn.value = false + } + } + + const setUserInfo = (info) => { + Object.assign(userInfo, info) + } + + const login = async (credentials) => { + try { + // 这里应该调用登录API + // const response = await authAPI.login(credentials) + // setToken(response.data.token) + // await fetchUserInfo() + // return response + } catch (error) { + throw error + } + } + + const logout = () => { + setToken('') + Object.assign(userInfo, { + id: null, + username: '', + email: '', + avatar: '', + level: 1, + experience: 0, + totalGames: 0, + winRate: 0, + ranking: null, + bestStreak: 0, + joinDate: null + }) + } + + const fetchUserInfo = async () => { + try { + const [profileRes, statsRes] = await Promise.all([ + userAPI.getUserInfo(), + userAPI.getUserStats() + ]) + + setUserInfo({ + ...profileRes.data, + ...statsRes.data + }) + + return { ...profileRes.data, ...statsRes.data } + } catch (error) { + console.error('获取用户信息失败:', error) + throw error + } + } + + const updateUserInfo = async (updateData) => { + try { + const response = await userAPI.updateUserInfo(updateData) + setUserInfo(response.data) + return response + } catch (error) { + console.error('更新用户信息失败:', error) + throw error + } + } + + const uploadAvatar = async (file) => { + try { + const formData = new FormData() + formData.append('avatar', file) + + const response = await userAPI.uploadAvatar(formData) + userInfo.avatar = response.data.url + return response + } catch (error) { + console.error('上传头像失败:', error) + throw error + } + } + + const changePassword = async (oldPassword, newPassword) => { + try { + const response = await userAPI.changePassword(oldPassword, newPassword) + return response + } catch (error) { + console.error('修改密码失败:', error) + throw error + } + } + + const updatePrivacySettings = async (settings) => { + try { + const response = await userAPI.updatePrivacySettings(settings) + return response + } catch (error) { + console.error('更新隐私设置失败:', error) + throw error + } + } + + // 初始化：如果有token，自动获取用户信息 + const init = async () => { + if (token.value) { + try { + await fetchUserInfo() + isLoggedIn.value = true + } catch (error) { + // token可能已过期，清除 + logout() + } + } + } + + return { + // 状态 + isLoggedIn, + token, + userInfo, + + // 计算属性 + isAuthenticated, + expProgress, + nextLevelExp, + + // 方法 + setToken, + setUserInfo, + login, + logout, + fetchUserInfo, + updateUserInfo, + uploadAvatar, + changePassword, + updatePrivacySettings, + init + } +}) diff --git a/frontend/src/utils/README.md b/frontend/src/utils/README.md new file mode 100644 index 0000000000000000000000000000000000000000..02ca8f711465e299c8285392ec6a5b31c82ad692 --- /dev/null +++ b/frontend/src/utils/README.md @@ -0,0 +1,3 @@ +# utils + +工具函数目录，存放通用的工具方法，如格式化、校验、转换等。 diff --git a/frontend/src/utils/notification.js b/frontend/src/utils/notification.js new file mode 100644 index 0000000000000000000000000000000000000000..11e9b57f587f4709f03c4198d6cdde97bd5ea2a0 --- /dev/null +++ b/frontend/src/utils/notification.js @@ -0,0 +1,61 @@ +import { createApp } from 'vue' +import Notification from '@/components/common/Notification.vue' + +class NotificationManager { + constructor() { + this.instance = null + this.container = null + this.init() + } + + init() { + // 创建容器 + this.container = document.createElement('div') + this.container.id = 'notification-container' + document.body.appendChild(this.container) + + // 创建Vue实例 + const app = createApp(Notification) + this.instance = app.mount(this.container) + } + + success(message, title) { + return this.instance.success(message, title) + } + + error(message, title) { + return this.instance.error(message, title) + } + + warning(message, title) { + return this.instance.warning(message, title) + } + + info(message, title) { + return this.instance.info(message, title) + } + + clear() { + return this.instance.clearAll() + } + + destroy() { + if (this.container && this.container.parentNode) { + this.container.parentNode.removeChild(this.container) + } + } +} + +// 创建全局实例 +const notificationManager = new NotificationManager() + +// 插件安装函数 +export default { + install(app) { + app.config.globalProperties.$notification = notificationManager + app.provide('notification', notificationManager) + } +} + +// 直接导出实例供非组件使用 +export { notificationManager as notification } diff --git a/frontend/src/views/auth/ForgotPassword.vue b/frontend/src/views/auth/ForgotPassword.vue new file mode 100644 index 0000000000000000000000000000000000000000..dd3121a19c9438716d29af408d517cf14c4208c1 --- /dev/null +++ b/frontend/src/views/auth/ForgotPassword.vue @@ -0,0 +1,29 @@ + + + + + diff --git a/frontend/src/views/auth/LoginPage.vue b/frontend/src/views/auth/LoginPage.vue new file mode 100644 index 0000000000000000000000000000000000000000..2333ba1a0a4d8ca9fccc82f8d9bc63a863764325 --- /dev/null +++ b/frontend/src/views/auth/LoginPage.vue @@ -0,0 +1,488 @@ + + + + + diff --git a/frontend/src/views/auth/RegisterPage.vue b/frontend/src/views/auth/RegisterPage.vue new file mode 100644 index 0000000000000000000000000000000000000000..c65219f8a8b8d9018d401d64eef5299622e22b33 --- /dev/null +++ b/frontend/src/views/auth/RegisterPage.vue @@ -0,0 +1,751 @@ + + + + + diff --git a/frontend/src/views/game/Game.vue b/frontend/src/views/game/Game.vue new file mode 100644 index 0000000000000000000000000000000000000000..41d85aa190a42957761d1f9d25b7ec5523104ee4 --- /dev/null +++ b/frontend/src/views/game/Game.vue @@ -0,0 +1,54 @@ + + + + + diff --git a/frontend/src/views/game/GameOver.vue b/frontend/src/views/game/GameOver.vue new file mode 100644 index 0000000000000000000000000000000000000000..5e9f2579cd87062ada7ea12b8ef431ef50295ef4 --- /dev/null +++ b/frontend/src/views/game/GameOver.vue @@ -0,0 +1,53 @@ + + + + + diff --git a/frontend/src/views/game/GamePage.vue b/frontend/src/views/game/GamePage.vue new file mode 100644 index 0000000000000000000000000000000000000000..9a12872716ae9523808d1f9fea2701566c4b9297 --- /dev/null +++ b/frontend/src/views/game/GamePage.vue @@ -0,0 +1,1106 @@ + + + + + diff --git a/frontend/src/views/game/GameResultPage.vue b/frontend/src/views/game/GameResultPage.vue new file mode 100644 index 0000000000000000000000000000000000000000..6856f6139ac7351503e255a6451562f3761899c2 --- /dev/null +++ b/frontend/src/views/game/GameResultPage.vue @@ -0,0 +1,1091 @@ + + + + + diff --git a/frontend/src/views/game/GameRoom.vue b/frontend/src/views/game/GameRoom.vue new file mode 100644 index 0000000000000000000000000000000000000000..6899e83fd5a89d9c35a9d9da5a4c28e48b9b217b --- /dev/null +++ b/frontend/src/views/game/GameRoom.vue @@ -0,0 +1,49 @@ + + + + + diff --git a/frontend/src/views/home/Home.vue b/frontend/src/views/home/Home.vue new file mode 100644 index 0000000000000000000000000000000000000000..20014bf8d2abb3edab89a5fe5ff924c59b3954a8 --- /dev/null +++ b/frontend/src/views/home/Home.vue @@ -0,0 +1,33 @@ + + + + + diff --git a/frontend/src/views/home/HomePage.vue b/frontend/src/views/home/HomePage.vue new file mode 100644 index 0000000000000000000000000000000000000000..51a8431eb6384c148cf310139bf368ecf0d36ca9 --- /dev/null +++ b/frontend/src/views/home/HomePage.vue @@ -0,0 +1,312 @@ + + + + + diff --git a/frontend/src/views/lobby/Lobby.vue b/frontend/src/views/lobby/Lobby.vue new file mode 100644 index 0000000000000000000000000000000000000000..cac8abce0af70bea98817873b74ab681d0f2bb19 --- /dev/null +++ b/frontend/src/views/lobby/Lobby.vue @@ -0,0 +1,43 @@ + + + + + diff --git a/frontend/src/views/lobby/LobbyPage.vue b/frontend/src/views/lobby/LobbyPage.vue new file mode 100644 index 0000000000000000000000000000000000000000..2e23c8f433e8dd7a0494b5cd986adb4976540e2b --- /dev/null +++ b/frontend/src/views/lobby/LobbyPage.vue @@ -0,0 +1,944 @@ + + + + + diff --git a/frontend/src/views/lobby/RoomPage.vue b/frontend/src/views/lobby/RoomPage.vue new file mode 100644 index 0000000000000000000000000000000000000000..b3d7d8ab63f5a60e56556e5859766b7f17700bb4 --- /dev/null +++ b/frontend/src/views/lobby/RoomPage.vue @@ -0,0 +1,806 @@ + + + + + diff --git a/frontend/src/views/profile/Profile.vue b/frontend/src/views/profile/Profile.vue new file mode 100644 index 0000000000000000000000000000000000000000..b3039690609da1eb905b445cd70f6005556cdd15 --- /dev/null +++ b/frontend/src/views/profile/Profile.vue @@ -0,0 +1,1957 @@ + + + + + diff --git a/frontend/src/views/ranking/Ranking.vue b/frontend/src/views/ranking/Ranking.vue new file mode 100644 index 0000000000000000000000000000000000000000..81c2221f23fe489f1597c7b67ab94aaf843a5029 --- /dev/null +++ b/frontend/src/views/ranking/Ranking.vue @@ -0,0 +1,1016 @@ + + + + + diff --git a/frontend/vite.config.js b/frontend/vite.config.js new file mode 100644 index 0000000000000000000000000000000000000000..4217010a3178372181948ce34c4d5045dfa18325 --- /dev/null +++ b/frontend/vite.config.js @@ -0,0 +1,18 @@ +import { fileURLToPath, URL } from 'node:url' + +import { defineConfig } from 'vite' +import vue from '@vitejs/plugin-vue' +import vueDevTools from 'vite-plugin-vue-devtools' + +// https://vite.dev/config/ +export default defineConfig({ + plugins: [ + vue(), + vueDevTools(), + ], + resolve: { + alias: { + '@': fileURLToPath(new URL('./src', import.meta.url)) + }, + }, +}) diff --git a/frontend/vitest.config.js b/frontend/vitest.config.js new file mode 100644 index 0000000000000000000000000000000000000000..c32871718f0722417a09b494da853e8f4cf1b8d2 --- /dev/null +++ b/frontend/vitest.config.js @@ -0,0 +1,14 @@ +import { fileURLToPath } from 'node:url' +import { mergeConfig, defineConfig, configDefaults } from 'vitest/config' +import viteConfig from './vite.config' + +export default mergeConfig( + viteConfig, + defineConfig({ + test: { + environment: 'jsdom', + exclude: [...configDefaults.exclude, 'e2e/**'], + root: fileURLToPath(new URL('./', import.meta.url)), + }, + }), +)