Compare commits
12 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
b9431c1a15 | ||
|
|
916b35c691 | ||
|
|
84ba2e3e64 | ||
|
|
adc1c66f47 | ||
|
|
cba50d60ab | ||
|
|
0c1e726168 | ||
|
|
86f422e8f0 | ||
|
|
c5100bce75 | ||
|
|
84fa8e4a71 | ||
|
|
001788b7fb | ||
|
|
9592efeff6 | ||
|
|
50fc90070b |
15
README.md
15
README.md
@@ -8,7 +8,7 @@
|
||||
- 설계·계획: [`docs/gemnoki-project-plan.pdf`](docs/gemnoki-project-plan.pdf), 개발 구조·인터페이스: [`docs/dev/ARCHITECTURE.md`](docs/dev/ARCHITECTURE.md)
|
||||
- 범인찾기 · 리플레이 동기화 계획서 v1.2 (결정 반영): [`docs/culprit-finder-plan.pdf`](docs/culprit-finder-plan.pdf) · 원본 · 비용 계산 · 프롬프트 초안: `docs/report/culprit/` (실제로 쓰는 프롬프트는 `site/server/prompt/`)
|
||||
- **제작 완료 보고서 (M0~M8)**: [`docs/gemnoki-final-report.pdf`](docs/gemnoki-final-report.pdf) · 단계별 테스트 기록: [`docs/dev/test-results.md`](docs/dev/test-results.md)
|
||||
- Windows 실행 파일: Gitea 릴리스 [v1.4.2](https://git.tkrmagid.kr/tkrmagid/game_voice_recorder/releases/tag/v1.4.3) (`GameVoiceRecorder-1.4.3-win-x64.zip` 권장, 단일 파일 `GameVoiceRecorder-1.4.3-portable.exe`) · 바뀐 점 보고서 [`docs/gemnoki-v1.3.7-report.pdf`](docs/gemnoki-v1.3.7-report.pdf) · 처음 버전 [v1.0.0](https://git.tkrmagid.kr/tkrmagid/game_voice_recorder/releases/tag/v1.0.0)
|
||||
- Windows 실행 파일: Gitea 릴리스 [v1.5.0](https://git.tkrmagid.kr/tkrmagid/game_voice_recorder/releases/tag/v1.5.0) (`GameVoiceRecorder-1.5.0-win-x64.zip` 권장, 단일 파일 `GameVoiceRecorder-1.5.0-portable.exe`) · 바뀐 점 보고서 [`docs/gemnoki-v1.3.7-report.pdf`](docs/gemnoki-v1.3.7-report.pdf) · 처음 버전 [v1.0.0](https://git.tkrmagid.kr/tkrmagid/game_voice_recorder/releases/tag/v1.0.0)
|
||||
|
||||
## 로그인 · 관리자 (v1.2.0~)
|
||||
|
||||
@@ -19,6 +19,19 @@
|
||||
- 앱은 시작할 때와 10분마다 등록 여부를 다시 확인한다. 등록이 해제되면 바로 잠그고 봇 · 녹음 · 사이트 연결을 멈춘다. 사이트 서버에 못 붙으면 마지막 확인 뒤 3일까지는 그대로 쓴다.
|
||||
- 서버 쪽: `site/server/src/app-auth.ts` (`/auth/app/*`, `/app/me`, `/app/admin/users`), 앱 쪽: `app/src/core/auth.ts`, 권한 목록: `app/src/core/roles.ts`. 로그인 E2E: `app/scripts/login-e2e.mts`.
|
||||
|
||||
## v1.6.0 바뀐 점
|
||||
|
||||
- **내 정보** (사이트 오른쪽 위 내 이름 누르기, `site/web/src/components/UserEdit.tsx`): 표시 이름 바꾸기 · 되돌리기(디스코드 서버 별명으로), 내 색, 라이엇 ID, 녹음 제외, 내 기록 보기 · 관리 페이지 · 로그아웃
|
||||
- 표시 이름은 사이트 서버에 저장하고(`PUT /site/profile/name`, 1~32자 · 보이지 않는 글자 금지 · 다른 사람 표시 이름과 겹치면 거절 · 10분에 10번) 게임 PC 앱에 바로 보낸다(`PUT /api/internal/names`, 예전 앱은 10분마다 받아 감)
|
||||
- 색 · 라이엇 ID · 녹음 제외는 게임 PC 앱 기록에 저장 (`PATCH /api/users/:id`, 본인 또는 관리자. 다른 사람에게 연결된 라이엇 ID 는 본인이 가져갈 수 없음)
|
||||
- **관리 페이지** `/admin` (관리자 · 최고 관리자, `site/web/src/pages/AdminPage.tsx`): 게임 PC 연결 · 앱 버전 · 새 버전 안내(Gitea 최신 릴리스), 녹음된 사람 + 앱 등록 유저 목록에서 표시 이름 · 색 · 라이엇 ID · 녹음 제외 바꾸기, 앱 등록 · 역할 · 해제(최고 관리자). 서버 `/site/admin/*` 는 앱 관리자 탭 `/app/admin/*` 와 같은 코드 (`site/server/src/app-auth.ts`). 표시 이름은 사이트에서는 관리자도 바꿀 수 있다
|
||||
|
||||
## v1.5.0 바뀐 점
|
||||
|
||||
- **3D 리플레이**: 발로란트 경력 탭에서 경기 리플레이를 내려받아 두면, 사이트 경기 화면 "3D 리플레이"를 열 때 게임 PC 앱이 `%LOCALAPPDATA%\VALORANT\Saved` 아래 `<경기 ID>.vrf` 를 찾아 변환해 보낸다 (처음 한 번 10초 안팎, 그 뒤로는 `GVR-Data/replays/<경기 ID>.json.gz` 보관본). 선수 10명이 3D 맵 위에서 움직이고 그때 대화가 같이 재생된다
|
||||
- 변환기 `resources/replay/gvr-replay.exe` (`tools/replay-extract`, .NET 단일 파일). 한 번에 하나 · 낮은 우선순위로 돌린다. 실패하면 이유를 사이트에 보여 주고, 같은 파일은 다시 내려받을 때까지 다시 하지 않는다
|
||||
- 앱 `app/src/core/replays.ts`, API `GET /api/matches/:id/replay` (gzip JSON, 변환 중 202) · `GET /api/replays` (찾은 리플레이 목록)
|
||||
|
||||
## v1.4.3 바뀐 점
|
||||
|
||||
- 상대 닉네임을 말로 적던 문제 (예: 말소리가 "QQQWWWQ"로 나옴): 그 경기 선수 이름을 모두 핫워드로 넣어서, 말을 못 알아들으면 Whisper 가 닉네임을 그대로 적었다. 이제
|
||||
|
||||
4
app/package-lock.json
generated
4
app/package-lock.json
generated
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"name": "gvr-app",
|
||||
"version": "1.4.3",
|
||||
"version": "1.6.0",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "gvr-app",
|
||||
"version": "1.4.3",
|
||||
"version": "1.6.0",
|
||||
"license": "UNLICENSED",
|
||||
"dependencies": {
|
||||
"@discordjs/voice": "^0.19.2",
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"name": "gvr-app",
|
||||
"productName": "겜녹이",
|
||||
"version": "1.4.3",
|
||||
"version": "1.6.0",
|
||||
"description": "겜녹이 (Game Voice Recorder) - 게임 연동 디스코드 음성 기록",
|
||||
"private": true,
|
||||
"main": "dist/main.cjs",
|
||||
@@ -76,6 +76,13 @@
|
||||
"from": "../worker/dist/gvr-worker",
|
||||
"to": "worker"
|
||||
},
|
||||
{
|
||||
"from": "../tools/replay-extract/out/win",
|
||||
"to": "replay",
|
||||
"filter": [
|
||||
"gvr-replay.exe"
|
||||
]
|
||||
},
|
||||
{
|
||||
"from": "../assets/app",
|
||||
"to": "brand",
|
||||
|
||||
@@ -10,6 +10,7 @@ import type { Settings } from '../settings.js';
|
||||
import { safeJson, type Timeline, type TimelineQuery } from '../timeline.js';
|
||||
import type { Bus } from '../util/events.js';
|
||||
import { BundleError, type Bundles } from '../bundles.js';
|
||||
import type { Replays } from '../replays.js';
|
||||
import { logger } from '../util/log.js';
|
||||
|
||||
const log = logger('api');
|
||||
@@ -37,6 +38,10 @@ export interface ApiDeps {
|
||||
version: string;
|
||||
/** 기록 묶음 (없으면 /api/bundles 없음) */
|
||||
bundles?: Bundles;
|
||||
/** 발로란트 리플레이 (없으면 /api/replays 없음) */
|
||||
replays?: Replays;
|
||||
/** 사이트 서버가 새 표시 이름을 보내 왔을 때 (녹음 파일 이름 다시 맞추기) */
|
||||
onNamesChanged?: () => void;
|
||||
}
|
||||
|
||||
const STOP = new Set(['그', '저', '이', '그냥', '아', '어', '음', '네', '응', '좀', '진짜', '근데', '나', '너', '저기', '이거', '그거', '뭐', '왜', '아니', '그래', '거', '것', '수', '게', '잠깐만']);
|
||||
@@ -115,6 +120,39 @@ export async function buildApi(d: ApiDeps): Promise<FastifyInstance> {
|
||||
return { user: toUser(u, store.listAccounts()), stats: { talkMs: st.ms, count: st.n, topWords }, matches };
|
||||
});
|
||||
|
||||
// 유저 설정 (v1.6.0, 사이트 "내 정보" · 관리 화면): 색 · 녹음 제외 · 라이엇 ID. 본인 또는 관리자만
|
||||
app.patch<{ Params: { id: string }; Body: { color?: string; excluded?: boolean; riotIds?: string[] } }>('/api/users/:id', async (req, reply) => {
|
||||
const u = store.getUser(req.params.id);
|
||||
if (!u) return reply.code(404).send({ error: 'not_found', message: '이 PC 기록에 없는 유저입니다 (음성채널에서 한 번 녹음되면 생깁니다)' });
|
||||
const admin = req.headers['x-gvr-role'] === 'admin' || !req.headers['x-gvr-user'];
|
||||
if (!admin && !canDelete(req, u.id)) return reply.code(403).send({ error: 'forbidden', message: '본인 또는 관리자만 바꿀 수 있습니다' });
|
||||
const b = req.body ?? {};
|
||||
if (b.color !== undefined && !/^#[0-9a-fA-F]{6}$/.test(String(b.color))) return reply.code(400).send({ error: 'bad_color', message: '색은 #rrggbb 형식입니다' });
|
||||
if (b.riotIds !== undefined && (!Array.isArray(b.riotIds) || b.riotIds.length > 5 || b.riotIds.some((r) => typeof r !== 'string' || r.length > 45)))
|
||||
return reply.code(400).send({ error: 'bad_riot_ids', message: '라이엇 ID 는 5개까지, 이름#태그 형식입니다' });
|
||||
let taken: string[] = [];
|
||||
store.db.transaction(() => {
|
||||
if (b.color !== undefined) store.setColor(u.id, String(b.color).toLowerCase());
|
||||
if (b.excluded !== undefined) store.setExcluded(u.id, !!b.excluded);
|
||||
if (b.riotIds !== undefined) taken = store.setRiotIds(u.id, b.riotIds, admin).taken;
|
||||
})();
|
||||
log.info(`유저 설정 바뀜 ${u.id}: ${Object.keys(b).join(', ')}${taken.length ? ` (이미 다른 사람에게 연결된 라이엇 ID ${taken.length}개 뺌)` : ''}`);
|
||||
d.bus.live({ type: 'users.updated', data: [] });
|
||||
return { user: toUser(store.getUser(u.id)!, store.listAccounts()), taken };
|
||||
});
|
||||
|
||||
// 표시 이름 (v1.6.0): 사이트에서 이름을 바꾸면 사이트 서버가 바로 보낸다 (예전 앱은 10분마다 받아 감)
|
||||
app.put<{ Body: { names?: Record<string, string> } }>('/api/internal/names', async (req, reply) => {
|
||||
if (req.headers['x-gvr-internal'] !== '1') return reply.code(403).send({ error: 'forbidden' });
|
||||
const names = req.body?.names;
|
||||
if (!names || typeof names !== 'object') return reply.code(400).send({ error: 'bad_names' });
|
||||
store.setDisplayNames(names);
|
||||
timeline.invalidate();
|
||||
d.onNamesChanged?.();
|
||||
d.bus.live({ type: 'users.updated', data: [] });
|
||||
return { ok: true };
|
||||
});
|
||||
|
||||
app.get<{ Querystring: Record<string, string> }>('/api/timeline', async (req) => {
|
||||
const q = req.query;
|
||||
const tq: TimelineQuery = {
|
||||
@@ -321,6 +359,31 @@ export async function buildApi(d: ApiDeps): Promise<FastifyInstance> {
|
||||
};
|
||||
});
|
||||
|
||||
// 3D 리플레이 (v1.5.0): 이 PC 에 내려받은 발로란트 리플레이(.vrf)를 변환해 보낸다 (gzip JSON).
|
||||
// 처음 열 때 변환하느라 15초 넘게 걸리면 202 converting → 사이트가 몇 초 뒤 다시 묻는다
|
||||
app.get<{ Params: { id: string } }>('/api/matches/:id/replay', async (req, reply) => {
|
||||
const m = store.getMatch(req.params.id);
|
||||
if (!m) return reply.code(404).send({ error: 'not_found' });
|
||||
if (m.game !== 'valorant' || !d.replays) return reply.code(404).send({ error: 'replay_not_found' });
|
||||
const r = await d.replays.get(m.id.replace(/^val-/, ''));
|
||||
if (r.state === 'ready')
|
||||
return reply.header('content-type', 'application/json; charset=utf-8').header('content-encoding', 'gzip').header('cache-control', 'private, max-age=3600').send(fs.readFileSync(r.file));
|
||||
if (r.state === 'converting') return reply.code(202).send({ status: 'converting' });
|
||||
if (r.state === 'missing') return reply.code(404).send({ error: 'replay_not_found' });
|
||||
if (r.state === 'no_tool') return reply.code(500).send({ error: 'replay_tool_missing', message: '리플레이 변환기가 없습니다 (앱을 다시 설치해 주세요)' });
|
||||
return reply.code(422).send({ error: 'replay_failed', message: r.error });
|
||||
});
|
||||
|
||||
// 이 PC 에서 찾은 리플레이 목록 (경기 기록이 있는지 · 변환했는지)
|
||||
app.get('/api/replays', async (_req, reply) => {
|
||||
if (!d.replays) return reply.code(404).send({ error: 'not_found' });
|
||||
const rp = d.replays;
|
||||
return rp.list().map((r) => {
|
||||
const match = store.getMatch(`val-${r.matchId}`) ?? null;
|
||||
return { matchId: r.matchId, file: path.basename(r.file), size: r.size, mtime: r.mtimeMs, match: match ? match.id : null, converted: !!rp.cached(r) };
|
||||
});
|
||||
});
|
||||
|
||||
app.patch<{ Params: { id: string }; Body: { text?: string } }>('/api/utterances/:id', async (req, reply) => {
|
||||
const u = store.getUtterance(req.params.id);
|
||||
if (!u) return reply.code(404).send({ error: 'not_found' });
|
||||
|
||||
@@ -33,6 +33,7 @@ async function main() {
|
||||
worker,
|
||||
version: process.env.npm_package_version || '1.0.0',
|
||||
apiPort: Number(process.env.GVR_API_PORT || 0),
|
||||
replayTool: process.env.GVR_REPLAY_TOOL || path.join(root, '..', 'tools', 'replay-extract', 'out', 'linux', 'gvr-replay'),
|
||||
});
|
||||
const shutdown = async () => {
|
||||
await core.stop();
|
||||
|
||||
@@ -241,6 +241,10 @@ export class Store {
|
||||
setExcluded(id: string, excluded: boolean): void {
|
||||
this.db.prepare('UPDATE users SET excluded=?, updated_at=? WHERE id=?').run(excluded ? 1 : 0, Date.now(), id);
|
||||
}
|
||||
/** 사이트 · 타임라인에서 쓰는 유저 색 (#rrggbb) */
|
||||
setColor(id: string, color: string): void {
|
||||
this.db.prepare('UPDATE users SET color=?, updated_at=? WHERE id=?').run(color, Date.now(), id);
|
||||
}
|
||||
/** 유저 평소 음량 누적 평균 (최근값에 가중치) */
|
||||
updateGainProfile(id: string, lufs: number): void {
|
||||
const u = this.getUser(id);
|
||||
@@ -252,6 +256,29 @@ export class Store {
|
||||
listAccounts(): { user_id: string; puuid: string; riot_id: string }[] {
|
||||
return this.db.prepare('SELECT * FROM game_accounts').all() as any[];
|
||||
}
|
||||
/**
|
||||
* 라이엇 ID (이름#태그) 목록으로 연결 계정을 바꾼다. 이미 연결된 것은 puuid 를 그대로 두고, 새것은 riotid: 로 두었다가
|
||||
* 경기에서 만나면 실제 puuid 로 바뀐다. 다른 사람에게 연결된 라이엇 ID 는 넣지 않고 돌려준다 (관리자는 allowTaken 으로 같이 연결)
|
||||
*/
|
||||
setRiotIds(userId: string, riotIds: string[], allowTaken = false): { taken: string[] } {
|
||||
const all = this.listAccounts();
|
||||
const cur = all.filter((a) => a.user_id === userId);
|
||||
const taken: string[] = [];
|
||||
const seen = new Set<string>();
|
||||
const next: { puuid: string; riot_id: string }[] = [];
|
||||
for (const raw of riotIds) {
|
||||
const r = raw.trim();
|
||||
if (!/^[^#]{1,32}#[^#]{1,8}$/.test(r) || seen.has(r.toLowerCase())) continue;
|
||||
seen.add(r.toLowerCase());
|
||||
if (!allowTaken && all.some((a) => a.user_id !== userId && a.riot_id.toLowerCase() === r.toLowerCase())) {
|
||||
taken.push(r);
|
||||
continue;
|
||||
}
|
||||
next.push(cur.find((a) => a.riot_id.toLowerCase() === r.toLowerCase()) ?? { puuid: `riotid:${r}`, riot_id: r });
|
||||
}
|
||||
this.setAccounts(userId, next.map((a) => ({ puuid: a.puuid, riotId: a.riot_id })));
|
||||
return { taken };
|
||||
}
|
||||
setAccounts(userId: string, accounts: { puuid: string; riotId: string }[]): void {
|
||||
const tx = this.db.transaction(() => {
|
||||
this.db.prepare('DELETE FROM game_accounts WHERE user_id=?').run(userId);
|
||||
|
||||
@@ -14,6 +14,7 @@ import { Announcer } from './discord/tts.js';
|
||||
import { GameAssets } from './games/assets.js';
|
||||
import { GameManager } from './games/manager.js';
|
||||
import { RelayClient } from './relay/client.js';
|
||||
import { defaultReplayDirs, Replays } from './replays.js';
|
||||
import { Retention } from './retention.js';
|
||||
import { SettingsStore, resolvePaths, type SecretCodec } from './settings.js';
|
||||
import { SttPipeline } from './stt/pipeline.js';
|
||||
@@ -37,6 +38,8 @@ export interface CoreOptions {
|
||||
apiPort?: number;
|
||||
/** 겜녹이 봇 중계에서 로그인 만료 · 등록 해제를 알려 왔을 때 (Electron: 바로 다시 확인해서 잠근다) */
|
||||
onBotUnauthorized?: () => void;
|
||||
/** 발로란트 리플레이 변환기 (gvr-replay.exe). 없으면 3D 리플레이를 보내지 않는다 */
|
||||
replayTool?: string | null;
|
||||
}
|
||||
|
||||
export type Core = Awaited<ReturnType<typeof startCore>>;
|
||||
@@ -91,6 +94,7 @@ export async function startCore(opts: CoreOptions) {
|
||||
});
|
||||
|
||||
const culprit = new Culprit(store, timeline, games);
|
||||
const replays = new Replays({ dirs: defaultReplayDirs, tool: opts.replayTool ?? null, cacheDir: () => path.join(opts.dataDir, 'replays'), version: opts.version });
|
||||
const api: FastifyInstance = await buildApi({
|
||||
store,
|
||||
timeline,
|
||||
@@ -101,6 +105,8 @@ export async function startCore(opts: CoreOptions) {
|
||||
settings: S,
|
||||
trainingDir: () => paths().training,
|
||||
version: opts.version,
|
||||
replays,
|
||||
onNamesChanged: () => audioNames.refreshAll(),
|
||||
bundles: new Bundles(store, games, () => paths().audio, opts.version, (ids) => ids.forEach((id) => audioNames.refresh(id))),
|
||||
overviewExtra: () => ({
|
||||
guild: bot.state.guild,
|
||||
@@ -171,6 +177,7 @@ export async function startCore(opts: CoreOptions) {
|
||||
const g = s.discord.guildId;
|
||||
if (g === watchedGuild) return;
|
||||
watchedGuild = g;
|
||||
relay.sendHello();
|
||||
if (bot.state.status !== 'ready' || !g || bot.state.guild?.id === g) return;
|
||||
log.info('녹음할 서버가 바뀌어 봇을 다시 연결합니다');
|
||||
void bot.stop().then(startBot);
|
||||
@@ -188,5 +195,5 @@ export async function startCore(opts: CoreOptions) {
|
||||
store.close();
|
||||
};
|
||||
|
||||
return { settings, store, bus, timeline, dict, worker, stt, assets, games, audioNames, recorder, bot, api, relay, retention, paths, startBot, stop, version: opts.version, resourcesDir: opts.resourcesDir };
|
||||
return { settings, store, bus, timeline, dict, worker, stt, assets, games, audioNames, recorder, bot, api, relay, retention, replays, paths, startBot, stop, version: opts.version, resourcesDir: opts.resourcesDir };
|
||||
}
|
||||
|
||||
@@ -59,6 +59,12 @@ export class RelayClient {
|
||||
this.start();
|
||||
}
|
||||
|
||||
/** 녹음할 서버를 바꾸면 사이트 서버에 다시 알린다 (사이트 로그인은 이 서버 멤버만 된다) */
|
||||
sendHello(): void {
|
||||
const c = this.cfg();
|
||||
this.send({ t: 'hello', name: c.name, version: c.version, guildId: c.guildId });
|
||||
}
|
||||
|
||||
private connect(): void {
|
||||
const c = this.cfg();
|
||||
if (!c.deviceId || !c.deviceKey) {
|
||||
@@ -155,12 +161,13 @@ export class RelayClient {
|
||||
if (req.user) headers['x-gvr-user'] = encodeURIComponent(JSON.stringify(req.user));
|
||||
const res = await this.api.inject({ method: req.method as any, url: req.path, headers, payload: bin ?? req.body ?? undefined });
|
||||
const outHeaders: Record<string, string> = {};
|
||||
for (const k of ['content-type', 'content-range', 'accept-ranges', 'cache-control', 'content-length', 'content-disposition']) {
|
||||
for (const k of ['content-type', 'content-encoding', 'content-range', 'accept-ranges', 'cache-control', 'content-length', 'content-disposition']) {
|
||||
const v = res.headers[k];
|
||||
if (v !== undefined) outHeaders[k] = String(v);
|
||||
}
|
||||
const ct = outHeaders['content-type'] || '';
|
||||
if (ct.startsWith('audio/') || ct.startsWith('application/octet-stream') || ct.startsWith('application/zip')) {
|
||||
// 압축한 본문(리플레이 gzip JSON)도 글자로 바꾸면 깨지므로 바이너리로 보낸다
|
||||
if (ct.startsWith('audio/') || ct.startsWith('application/octet-stream') || ct.startsWith('application/zip') || outHeaders['content-encoding']) {
|
||||
this.send({ t: 'res_head', id: req.id, status: res.statusCode, headers: outHeaders });
|
||||
const idBuf = Buffer.from(req.id, 'utf8');
|
||||
const head = Buffer.alloc(4);
|
||||
|
||||
203
app/src/core/replays.ts
Normal file
203
app/src/core/replays.ts
Normal file
@@ -0,0 +1,203 @@
|
||||
import { execFile } from 'node:child_process';
|
||||
import fs from 'node:fs';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import zlib from 'node:zlib';
|
||||
import { logger } from './util/log.js';
|
||||
|
||||
const log = logger('replay');
|
||||
|
||||
/** 발로란트 경기 ID (리플레이 파일 이름이 `<경기 ID>.vrf`) */
|
||||
const MATCH_ID = /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
|
||||
/** 리플레이를 찾지 않는 하위 폴더 (Saved 아래 로그 · 오류 덤프 · 설정 · 브라우저 캐시) */
|
||||
const SKIP_DIRS = new Set(['logs', 'crashes', 'config', 'webcache', 'webcache_4430', 'cefcache']);
|
||||
|
||||
export interface ReplayFileInfo {
|
||||
matchId: string;
|
||||
file: string;
|
||||
size: number;
|
||||
mtimeMs: number;
|
||||
}
|
||||
|
||||
export type ReplayState =
|
||||
| { state: 'ready'; file: string }
|
||||
| { state: 'converting' }
|
||||
| { state: 'missing' }
|
||||
| { state: 'no_tool' }
|
||||
| { state: 'failed'; error: string };
|
||||
|
||||
export interface ReplaysOptions {
|
||||
/** 리플레이(.vrf)를 찾을 폴더들 */
|
||||
dirs: () => string[];
|
||||
/** 변환기 (gvr-replay.exe). 없으면 변환하지 않는다 */
|
||||
tool: string | null;
|
||||
/** 변환 결과 보관 폴더 (<경기 ID>.json.gz) */
|
||||
cacheDir: () => string;
|
||||
/** 변환기가 바뀌면(앱 업데이트) 다시 변환한다 */
|
||||
version: string;
|
||||
/** 변환 시간 제한 (기본 3분) */
|
||||
timeoutMs?: number;
|
||||
/** 사이트 요청이 변환을 기다리는 시간 (기본 15초, 사이트 서버는 20초 뒤 시간 초과) */
|
||||
waitMs?: number;
|
||||
}
|
||||
|
||||
/** 발로란트가 리플레이를 내려받는 곳: %LOCALAPPDATA%\VALORANT\Saved (보통 Demos\<경기 ID>.vrf). GVR_REPLAY_DIRS 로 바꿀 수 있다 */
|
||||
export function defaultReplayDirs(): string[] {
|
||||
const env = process.env.GVR_REPLAY_DIRS;
|
||||
if (env) return env.split(path.delimiter).filter(Boolean);
|
||||
const local = process.env.LOCALAPPDATA;
|
||||
return local ? [path.join(local, 'VALORANT', 'Saved')] : [];
|
||||
}
|
||||
|
||||
/**
|
||||
* 발로란트 리플레이(.vrf) 찾기 · 변환 (docs/dev/replay-3d.md).
|
||||
* 사이트에서 경기의 3D 리플레이를 열면 그때 이 PC 에서 `.vrf` 를 찾아 gvr-replay 로 변환하고 gzip 으로 보관해 둔다.
|
||||
* 변환은 한 번에 하나, 낮은 우선순위로 (게임 중일 수 있다). 실패하면 같은 파일 · 같은 앱 버전으로는 다시 하지 않는다.
|
||||
*/
|
||||
export class Replays {
|
||||
private scanCache: { at: number; list: ReplayFileInfo[] } | null = null;
|
||||
private running = new Map<string, Promise<void>>();
|
||||
private failed = new Map<string, string>();
|
||||
private queue: Promise<unknown> = Promise.resolve();
|
||||
|
||||
constructor(private o: ReplaysOptions) {}
|
||||
|
||||
/** 찾은 리플레이 (새것부터). 10초 동안은 다시 훑지 않는다 */
|
||||
list(): ReplayFileInfo[] {
|
||||
if (this.scanCache && Date.now() - this.scanCache.at < 10000) return this.scanCache.list;
|
||||
const byId = new Map<string, ReplayFileInfo>();
|
||||
const walk = (dir: string, depth: number) => {
|
||||
let ents: fs.Dirent[];
|
||||
try {
|
||||
ents = fs.readdirSync(dir, { withFileTypes: true });
|
||||
} catch {
|
||||
return;
|
||||
}
|
||||
for (const e of ents) {
|
||||
const p = path.join(dir, e.name);
|
||||
if (e.isDirectory()) {
|
||||
if (depth > 0 && !SKIP_DIRS.has(e.name.toLowerCase())) walk(p, depth - 1);
|
||||
continue;
|
||||
}
|
||||
if (!(e.isFile() || e.isSymbolicLink()) || !e.name.toLowerCase().endsWith('.vrf')) continue;
|
||||
const m = MATCH_ID.exec(e.name);
|
||||
if (!m) continue;
|
||||
try {
|
||||
const st = fs.statSync(p);
|
||||
const info = { matchId: m[1].toLowerCase(), file: p, size: st.size, mtimeMs: Math.floor(st.mtimeMs) };
|
||||
const prev = byId.get(info.matchId);
|
||||
if (!prev || prev.mtimeMs < info.mtimeMs) byId.set(info.matchId, info);
|
||||
} catch {
|
||||
/* 그 사이 지워짐 */
|
||||
}
|
||||
}
|
||||
};
|
||||
for (const d of this.o.dirs()) walk(d, 3);
|
||||
const list = [...byId.values()].sort((a, b) => b.mtimeMs - a.mtimeMs);
|
||||
this.scanCache = { at: Date.now(), list };
|
||||
return list;
|
||||
}
|
||||
|
||||
find(matchId: string): ReplayFileInfo | null {
|
||||
const id = matchId.toLowerCase();
|
||||
return this.list().find((r) => r.matchId === id) ?? null;
|
||||
}
|
||||
|
||||
/** 변환 결과 파일 (원본 · 변환기가 그대로일 때만) */
|
||||
cached(r: ReplayFileInfo): string | null {
|
||||
const out = this.outFile(r.matchId);
|
||||
try {
|
||||
if (fs.readFileSync(out + '.src', 'utf8') === this.stamp(r) && fs.existsSync(out)) return out;
|
||||
} catch {
|
||||
/* 아직 없음 */
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/** 경기 리플레이 상태. 변환이 필요하면 시작하고 waitMs 까지 기다린다 (그때까지 안 끝나면 converting) */
|
||||
async get(matchId: string, waitMs = this.o.waitMs ?? 15000): Promise<ReplayState> {
|
||||
this.scanCache = null; // 사이트에서 열 때는 방금 내려받은 파일도 보이게
|
||||
const r = this.find(matchId);
|
||||
if (!r) return { state: 'missing' };
|
||||
const done = this.cached(r);
|
||||
if (done) return { state: 'ready', file: done };
|
||||
const key = this.stamp(r);
|
||||
const err = this.failed.get(key);
|
||||
if (err) return { state: 'failed', error: err };
|
||||
if (!this.o.tool || !fs.existsSync(this.o.tool)) return { state: 'no_tool' };
|
||||
let job = this.running.get(r.matchId);
|
||||
if (!job) {
|
||||
job = this.enqueue(r).finally(() => this.running.delete(r.matchId));
|
||||
this.running.set(r.matchId, job);
|
||||
}
|
||||
if (waitMs > 0) await Promise.race([job, new Promise((res) => setTimeout(res, waitMs).unref?.())]);
|
||||
if (this.running.has(r.matchId)) return { state: 'converting' };
|
||||
const out = this.cached(r);
|
||||
if (out) return { state: 'ready', file: out };
|
||||
return { state: 'failed', error: this.failed.get(key) ?? '변환 결과 없음' };
|
||||
}
|
||||
|
||||
private outFile(matchId: string): string {
|
||||
return path.join(this.o.cacheDir(), `${matchId}.json.gz`);
|
||||
}
|
||||
|
||||
private stamp(r: ReplayFileInfo): string {
|
||||
return `${r.size}:${r.mtimeMs}:${this.o.version}`;
|
||||
}
|
||||
|
||||
private enqueue(r: ReplayFileInfo): Promise<void> {
|
||||
const run = this.queue.then(() => this.convert(r));
|
||||
this.queue = run.catch(() => undefined);
|
||||
return run;
|
||||
}
|
||||
|
||||
private async convert(r: ReplayFileInfo): Promise<void> {
|
||||
const dir = this.o.cacheDir();
|
||||
fs.mkdirSync(dir, { recursive: true });
|
||||
const out = this.outFile(r.matchId);
|
||||
const tmpJson = path.join(dir, `${r.matchId}.json.tmp-${process.pid}`);
|
||||
const t0 = Date.now();
|
||||
log.info(`리플레이 변환 시작 ${r.matchId} (${(r.size / 1048576).toFixed(1)}MB)`);
|
||||
try {
|
||||
const summary = await this.run([r.file, tmpJson]);
|
||||
if (!summary?.ok) throw new Error(summary?.error || '변환기가 결과를 알리지 않음');
|
||||
const gz = zlib.gzipSync(fs.readFileSync(tmpJson), { level: 6 });
|
||||
fs.writeFileSync(out + '.tmp', gz);
|
||||
fs.renameSync(out + '.tmp', out);
|
||||
fs.writeFileSync(out + '.src', this.stamp(r));
|
||||
log.info(
|
||||
`리플레이 변환 완료 ${r.matchId}: ${summary.map ?? '?'} · 선수 ${summary.players} · 라운드 ${summary.rounds} · 킬 ${summary.kills} · ${((Date.now() - t0) / 1000).toFixed(1)}초 · ${(gz.length / 1048576).toFixed(1)}MB`,
|
||||
);
|
||||
} catch (e: any) {
|
||||
const msg = String(e?.message ?? e).slice(0, 300);
|
||||
this.failed.set(this.stamp(r), msg);
|
||||
log.warn(`리플레이 변환 실패 ${r.matchId}: ${msg}`);
|
||||
} finally {
|
||||
fs.rmSync(tmpJson, { force: true });
|
||||
}
|
||||
}
|
||||
|
||||
/** 변환기 실행. 마지막 줄 JSON 요약을 돌려준다 */
|
||||
private run(args: string[]): Promise<any> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const child = execFile(this.o.tool!, args, { timeout: this.o.timeoutMs ?? 180000, windowsHide: true, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
|
||||
const last = String(stdout).trim().split(/\r?\n/).pop() ?? '';
|
||||
let summary: any = null;
|
||||
try {
|
||||
summary = JSON.parse(last);
|
||||
} catch {
|
||||
/* JSON 아님 */
|
||||
}
|
||||
if (summary) return resolve(summary);
|
||||
if (err) return reject(new Error((err as any).killed ? '변환 시간 초과' : String(stderr).trim().split(/\r?\n/).pop() || err.message));
|
||||
reject(new Error('변환기 출력 없음'));
|
||||
});
|
||||
// 게임 중일 수 있으니 낮은 우선순위로
|
||||
try {
|
||||
if (child.pid) os.setPriority(child.pid, os.constants.priority.PRIORITY_BELOW_NORMAL);
|
||||
} catch {
|
||||
/* 권한 없음 */
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -241,12 +241,8 @@ export function registerIpc(ctx: IpcContext) {
|
||||
return core.store.listUsers().map((u) => toUser(u, acc));
|
||||
},
|
||||
setRiotIds: (userId: string, riotIds: string[]) => {
|
||||
const cur = core.store.listAccounts().filter((a) => a.user_id === userId);
|
||||
const next = riotIds
|
||||
.map((r) => r.trim())
|
||||
.filter((r) => /^.+#.+$/.test(r))
|
||||
.map((r) => cur.find((a) => a.riot_id.toLowerCase() === r.toLowerCase()) ?? { puuid: `riotid:${r}`, riot_id: r });
|
||||
core.store.setAccounts(userId, next.map((a) => ({ puuid: a.puuid, riotId: a.riot_id })));
|
||||
core.store.setRiotIds(userId, riotIds, true);
|
||||
core.bus.live({ type: 'users.updated', data: [] });
|
||||
},
|
||||
setExcluded: (userId: string, excluded: boolean) => {
|
||||
core.store.setExcluded(userId, excluded);
|
||||
|
||||
@@ -11,7 +11,7 @@ import { hardenTlsEnv, secureFetch } from '../core/util/secure-http.js';
|
||||
import { Finetuner } from './finetune.js';
|
||||
import type { AuthView } from './api-types.js';
|
||||
import { buildState, registerIpc } from './ipc.js';
|
||||
import { brandDir, rendererDir, resolveDataDir, resourcesDir, workerCommand } from './paths.js';
|
||||
import { brandDir, rendererDir, replayToolPath, resolveDataDir, resourcesDir, workerCommand } from './paths.js';
|
||||
|
||||
// 인증서 검증을 끄는 환경변수(NODE_TLS_REJECT_UNAUTHORIZED=0)는 무시한다. fuses 로 막지 못하는 변수라 가장 먼저 지운다
|
||||
hardenTlsEnv();
|
||||
@@ -217,7 +217,7 @@ async function smoke(): Promise<void> {
|
||||
const a = await new AppAuth(st, { version: app.getVersion(), openUrl: () => undefined }).check();
|
||||
out.auth = a.status;
|
||||
out.builtinBot = st.hasBuiltinBot;
|
||||
const c = await startCore({ dataDir, resourcesDir: resourcesDir(), worker: workerCommand(), version: app.getVersion(), settings: st });
|
||||
const c = await startCore({ dataDir, resourcesDir: resourcesDir(), worker: workerCommand(), version: app.getVersion(), settings: st, replayTool: replayToolPath() });
|
||||
out.codec = c.settings.codecName;
|
||||
out.botMode = c.settings.get().discord.botMode;
|
||||
const ready = await new Promise<any>((res) => {
|
||||
@@ -244,7 +244,18 @@ async function smoke(): Promise<void> {
|
||||
out.dict = c.store.listDict().length;
|
||||
out.renderer = fs.existsSync(path.join(rendererDir(), 'index.html'));
|
||||
out.tray = fs.existsSync(path.join(brandDir(), 'tray.png'));
|
||||
code = ready && botOk && out.secretRoundTrip && out.renderer && out.tray && out.siteTls === true ? 0 : 1;
|
||||
// 3D 리플레이 변환기 (v1.5.0): 배포본 안에 있어야 한다. GVR_SMOKE_VRF 가 있으면 실제로 변환해 본다
|
||||
out.replayTool = fs.existsSync(replayToolPath());
|
||||
if (process.env.GVR_SMOKE_VRF) {
|
||||
const vrf = process.env.GVR_SMOKE_VRF;
|
||||
const id = path.basename(vrf).replace(/\.vrf$/i, '');
|
||||
process.env.GVR_REPLAY_DIRS = path.dirname(vrf);
|
||||
const t0 = Date.now();
|
||||
const r = await c.replays.get(id, 170000);
|
||||
out.replayConvert = r.state === 'ready' ? { ok: true, ms: Date.now() - t0, gz: fs.statSync(r.file).size } : r;
|
||||
}
|
||||
const replayOk = out.replayTool === true && (!process.env.GVR_SMOKE_VRF || (out.replayConvert as any)?.ok === true);
|
||||
code = ready && botOk && out.secretRoundTrip && out.renderer && out.tray && out.siteTls === true && replayOk ? 0 : 1;
|
||||
await c.stop();
|
||||
} catch (e: any) {
|
||||
out.error = e.stack || e.message;
|
||||
@@ -293,7 +304,7 @@ function startApp(): Promise<void> {
|
||||
starting ??= (async () => {
|
||||
try {
|
||||
// 겜녹이 봇 중계가 로그인 만료 · 등록 해제를 알려 오면 10분을 기다리지 않고 바로 확인해서 잠근다
|
||||
const c = await startCore({ dataDir, resourcesDir: resourcesDir(), worker: workerCommand(), version: app.getVersion(), settings: settings!, onBotUnauthorized: () => void auth?.check() });
|
||||
const c = await startCore({ dataDir, resourcesDir: resourcesDir(), worker: workerCommand(), version: app.getVersion(), settings: settings!, onBotUnauthorized: () => void auth?.check(), replayTool: replayToolPath() });
|
||||
core = c;
|
||||
void syncNames();
|
||||
ft = new Finetuner(c, pushState);
|
||||
|
||||
@@ -55,3 +55,10 @@ export function workerCommand(): { cmd: string; args: string[]; cwd?: string } {
|
||||
export function finetuneScriptsDir(): string {
|
||||
return app.isPackaged ? path.join(process.resourcesPath, 'worker', '_internal', 'gvr_worker', 'finetune') : path.join(appRoot, '..', 'worker', 'gvr_worker', 'finetune');
|
||||
}
|
||||
|
||||
/** 발로란트 리플레이 변환기 (tools/replay-extract, 배포본은 resources/replay/gvr-replay.exe) */
|
||||
export function replayToolPath(): string {
|
||||
if (process.env.GVR_REPLAY_TOOL) return process.env.GVR_REPLAY_TOOL;
|
||||
if (app.isPackaged) return path.join(process.resourcesPath, 'replay', process.platform === 'win32' ? 'gvr-replay.exe' : 'gvr-replay');
|
||||
return path.join(appRoot, '..', 'tools', 'replay-extract', 'out', process.platform === 'win32' ? 'win/gvr-replay.exe' : 'linux/gvr-replay');
|
||||
}
|
||||
|
||||
184
app/test/replays.test.ts
Normal file
184
app/test/replays.test.ts
Normal file
@@ -0,0 +1,184 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import fs from 'node:fs';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import zlib from 'node:zlib';
|
||||
import WebSocket from 'ws';
|
||||
import { Store } from '../src/core/db/db.ts';
|
||||
import { buildApi } from '../src/core/api/server.ts';
|
||||
import { Timeline } from '../src/core/timeline.ts';
|
||||
import { Bus } from '../src/core/util/events.ts';
|
||||
import { Replays } from '../src/core/replays.ts';
|
||||
import { RelayClient } from '../src/core/relay/client.ts';
|
||||
|
||||
const tmp = () => fs.mkdtempSync(path.join(process.env.TMPDIR || os.tmpdir(), 'gvr-replay-'));
|
||||
const ID = '4145f041-7d83-4785-ac4b-b532154f14a4';
|
||||
const ID2 = '0e1f2a3b-0000-4000-8000-000000000002';
|
||||
|
||||
/** 가짜 변환기: 호출 횟수를 세고, 모드 파일에 따라 성공 · 실패 · 느림 */
|
||||
function fakeTool(dir: string): { tool: string; calls: () => number; mode: (m: 'ok' | 'fail' | 'slow') => void } {
|
||||
const tool = path.join(dir, 'gvr-replay');
|
||||
const count = path.join(dir, 'calls');
|
||||
const modeFile = path.join(dir, 'mode');
|
||||
fs.writeFileSync(modeFile, 'ok');
|
||||
fs.writeFileSync(
|
||||
tool,
|
||||
`#!/bin/sh
|
||||
echo x >> "${count}"
|
||||
mode=$(cat "${modeFile}")
|
||||
if [ "$mode" = fail ]; then echo '{"ok":false,"error":"InvalidDataException: bad chunk"}'; exit 1; fi
|
||||
if [ "$mode" = slow ]; then sleep 2; fi
|
||||
printf '{"format":"gvr-replay","v":1,"matchId":"%s","players":[]}' "$(basename "$1" .vrf)" > "$2"
|
||||
echo '{"ok":true,"map":"/Game/Maps/Infinity/Infinity","players":10,"rounds":20,"kills":146}'
|
||||
`,
|
||||
{ mode: 0o755 },
|
||||
);
|
||||
return { tool, calls: () => (fs.existsSync(count) ? fs.readFileSync(count, 'utf8').split('\n').filter(Boolean).length : 0), mode: (m) => fs.writeFileSync(modeFile, m) };
|
||||
}
|
||||
|
||||
function setup(waitMs = 15000) {
|
||||
const dir = tmp();
|
||||
const saved = path.join(dir, 'VALORANT', 'Saved');
|
||||
const demos = path.join(saved, 'Demos');
|
||||
fs.mkdirSync(demos, { recursive: true });
|
||||
const t = fakeTool(dir);
|
||||
const replays = new Replays({ dirs: () => [saved], tool: t.tool, cacheDir: () => path.join(dir, 'GVR-Data', 'replays'), version: '1.5.0', waitMs });
|
||||
const store = new Store(path.join(dir, 'db.sqlite'));
|
||||
store.upsertMatch({ id: `val-${ID}`, game: 'valorant', started_at: Date.now() - 3600000 });
|
||||
store.upsertMatch({ id: `val-${ID2}`, game: 'valorant', started_at: Date.now() - 7200000 });
|
||||
store.upsertMatch({ id: 'lol-KR_1', game: 'lol', started_at: Date.now() - 7200000 });
|
||||
return { dir, saved, demos, replays, store, ...t };
|
||||
}
|
||||
|
||||
const api = (s: ReturnType<typeof setup>) =>
|
||||
buildApi({
|
||||
store: s.store,
|
||||
timeline: new Timeline(s.store),
|
||||
games: {} as any,
|
||||
dict: {} as any,
|
||||
culprit: {} as any,
|
||||
bus: new Bus(),
|
||||
settings: () => ({}) as any,
|
||||
trainingDir: () => path.join(s.dir, 'training'),
|
||||
overviewExtra: () => ({ guild: null, recording: {} as any }),
|
||||
version: 'test',
|
||||
replays: s.replays,
|
||||
});
|
||||
|
||||
test('리플레이 찾기: Saved 아래 <경기 ID>.vrf (하위 폴더 포함), 로그 폴더 · 이름이 다른 파일은 무시', () => {
|
||||
const s = setup();
|
||||
fs.writeFileSync(path.join(s.demos, `${ID.toUpperCase()}.vrf`), 'a');
|
||||
fs.mkdirSync(path.join(s.demos, 'old'), { recursive: true });
|
||||
fs.writeFileSync(path.join(s.demos, 'old', `${ID2}.vrf`), 'b');
|
||||
fs.writeFileSync(path.join(s.demos, 'notes.vrf'), 'c');
|
||||
fs.mkdirSync(path.join(s.saved, 'Logs'), { recursive: true });
|
||||
fs.writeFileSync(path.join(s.saved, 'Logs', '11111111-1111-4111-8111-111111111111.vrf'), 'd');
|
||||
const ids = s.replays.list().map((r) => r.matchId);
|
||||
assert.deepEqual(ids.sort(), [ID, ID2].sort());
|
||||
assert.equal(s.replays.find(ID.toUpperCase())?.matchId, ID);
|
||||
});
|
||||
|
||||
test('3D 리플레이 API: 처음 열면 변환해서 gzip JSON, 다음부터는 보관본 (변환 한 번)', async () => {
|
||||
const s = setup();
|
||||
const app = await api(s);
|
||||
const miss = await app.inject({ url: `/api/matches/val-${ID}/replay` });
|
||||
assert.equal(miss.statusCode, 404);
|
||||
assert.equal(miss.json().error, 'replay_not_found');
|
||||
fs.writeFileSync(path.join(s.demos, `${ID}.vrf`), 'vrf');
|
||||
const r = await app.inject({ url: `/api/matches/val-${ID}/replay` });
|
||||
assert.equal(r.statusCode, 200);
|
||||
assert.equal(r.headers['content-encoding'], 'gzip');
|
||||
assert.match(String(r.headers['content-type']), /application\/json/);
|
||||
const body = JSON.parse(zlib.gunzipSync(r.rawPayload).toString('utf8'));
|
||||
assert.equal(body.format, 'gvr-replay');
|
||||
assert.equal(body.matchId, ID);
|
||||
const again = await app.inject({ url: `/api/matches/val-${ID}/replay` });
|
||||
assert.equal(again.statusCode, 200);
|
||||
assert.equal(s.calls(), 1, '두 번째는 변환하지 않는다');
|
||||
// 목록: 경기 기록과 변환 여부
|
||||
const list = (await app.inject({ url: '/api/replays' })).json();
|
||||
assert.deepEqual(list.map((x: any) => [x.matchId, x.match, x.converted]), [[ID, `val-${ID}`, true]]);
|
||||
// 롤 경기 · 없는 경기
|
||||
assert.equal((await app.inject({ url: '/api/matches/lol-KR_1/replay' })).json().error, 'replay_not_found');
|
||||
assert.equal((await app.inject({ url: '/api/matches/val-nope/replay' })).statusCode, 404);
|
||||
});
|
||||
|
||||
test('변환 실패는 422 로 이유를 알리고, 같은 파일은 다시 변환하지 않는다 (파일이 바뀌면 다시)', async () => {
|
||||
const s = setup();
|
||||
const app = await api(s);
|
||||
const vrf = path.join(s.demos, `${ID}.vrf`);
|
||||
fs.writeFileSync(vrf, 'broken');
|
||||
s.mode('fail');
|
||||
const r = await app.inject({ url: `/api/matches/val-${ID}/replay` });
|
||||
assert.equal(r.statusCode, 422);
|
||||
assert.equal(r.json().error, 'replay_failed');
|
||||
assert.match(r.json().message, /bad chunk/);
|
||||
await app.inject({ url: `/api/matches/val-${ID}/replay` });
|
||||
assert.equal(s.calls(), 1);
|
||||
// 다시 내려받음 (크기 · 시각이 바뀜) → 다시 변환
|
||||
s.mode('ok');
|
||||
fs.writeFileSync(vrf, 'fixed replay');
|
||||
fs.utimesSync(vrf, new Date(), new Date(Date.now() + 5000));
|
||||
const ok = await app.inject({ url: `/api/matches/val-${ID}/replay` });
|
||||
assert.equal(ok.statusCode, 200);
|
||||
assert.equal(s.calls(), 2);
|
||||
});
|
||||
|
||||
test('변환이 기다리는 시간보다 길면 202 converting, 끝나면 200 (같은 파일을 두 번 변환하지 않음)', async () => {
|
||||
const s = setup(300);
|
||||
const app = await api(s);
|
||||
fs.writeFileSync(path.join(s.demos, `${ID}.vrf`), 'vrf');
|
||||
s.mode('slow');
|
||||
const r1 = await app.inject({ url: `/api/matches/val-${ID}/replay` });
|
||||
assert.equal(r1.statusCode, 202);
|
||||
assert.equal(r1.json().status, 'converting');
|
||||
const r2 = await app.inject({ url: `/api/matches/val-${ID}/replay` });
|
||||
assert.equal(r2.statusCode, 202);
|
||||
let last = r2;
|
||||
for (let i = 0; i < 20 && last.statusCode === 202; i++) {
|
||||
await new Promise((res) => setTimeout(res, 300));
|
||||
last = await app.inject({ url: `/api/matches/val-${ID}/replay` });
|
||||
}
|
||||
assert.equal(last.statusCode, 200);
|
||||
assert.equal(s.calls(), 1);
|
||||
});
|
||||
|
||||
test('변환기가 없으면 500 replay_tool_missing', async () => {
|
||||
const s = setup();
|
||||
const replays = new Replays({ dirs: () => [s.saved], tool: path.join(s.dir, 'none.exe'), cacheDir: () => path.join(s.dir, 'c'), version: '1' });
|
||||
fs.writeFileSync(path.join(s.demos, `${ID}.vrf`), 'vrf');
|
||||
assert.deepEqual(await replays.get(ID), { state: 'no_tool' });
|
||||
});
|
||||
|
||||
test('중계: gzip 리플레이는 바이너리 조각 + content-encoding 으로 사이트 서버에 간다', async () => {
|
||||
const s = setup();
|
||||
const app = await api(s);
|
||||
fs.writeFileSync(path.join(s.demos, `${ID}.vrf`), 'vrf');
|
||||
const relay = new RelayClient(app, new Bus(), () => ({ serverUrl: 'https://x', deviceId: null, deviceKey: null, name: 'pc', version: 't', guildId: null }));
|
||||
const sent: any[] = [];
|
||||
(relay as any).ws = { readyState: WebSocket.OPEN, bufferedAmount: 0, send: (m: any) => sent.push(m) };
|
||||
await (relay as any).handle({ t: 'req', id: 'r1', method: 'GET', path: `/api/matches/val-${ID}/replay`, headers: {}, user: { id: 'u', name: 'u', avatar: null }, body: null });
|
||||
const head = JSON.parse(sent[0]);
|
||||
assert.equal(head.t, 'res_head');
|
||||
assert.equal(head.status, 200);
|
||||
assert.equal(head.headers['content-encoding'], 'gzip');
|
||||
const chunks = sent.slice(1, -1).map((b: Buffer) => b.subarray(4 + b.readUInt32BE(0)));
|
||||
assert.equal(JSON.parse(sent.at(-1)).t, 'res_end');
|
||||
assert.equal(JSON.parse(zlib.gunzipSync(Buffer.concat(chunks)).toString()).matchId, ID);
|
||||
});
|
||||
|
||||
test('실제 변환기 (tools/replay-extract 리눅스 빌드 + 13.08 리플레이가 있을 때만)', { skip: !fs.existsSync(path.join(os.homedir(), 'work/vrf/match.vrf')) || !fs.existsSync(path.resolve(import.meta.dirname, '../../tools/replay-extract/out/linux/gvr-replay')) }, async () => {
|
||||
if (!process.env.DOTNET_ROOT && fs.existsSync(path.join(os.homedir(), '.dotnet'))) process.env.DOTNET_ROOT = path.join(os.homedir(), '.dotnet');
|
||||
const dir = tmp();
|
||||
const demos = path.join(dir, 'Demos');
|
||||
fs.mkdirSync(demos);
|
||||
fs.symlinkSync(path.join(os.homedir(), 'work/vrf/match.vrf'), path.join(demos, `${ID}.vrf`));
|
||||
const replays = new Replays({ dirs: () => [dir], tool: path.resolve(import.meta.dirname, '../../tools/replay-extract/out/linux/gvr-replay'), cacheDir: () => path.join(dir, 'c'), version: '1' });
|
||||
const r = await replays.get(ID, 120000);
|
||||
assert.equal(r.state, 'ready');
|
||||
const j = JSON.parse(zlib.gunzipSync(fs.readFileSync((r as any).file)).toString());
|
||||
assert.equal(j.matchId, ID);
|
||||
assert.equal(j.players.length, 10);
|
||||
assert.ok(j.kills.length > 100);
|
||||
});
|
||||
82
app/test/user-settings.test.ts
Normal file
82
app/test/user-settings.test.ts
Normal file
@@ -0,0 +1,82 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import fs from 'node:fs';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import { Store } from '../src/core/db/db.ts';
|
||||
import { buildApi } from '../src/core/api/server.ts';
|
||||
import { Timeline } from '../src/core/timeline.ts';
|
||||
import { Bus } from '../src/core/util/events.ts';
|
||||
|
||||
const tmp = () => fs.mkdtempSync(path.join(process.env.TMPDIR || os.tmpdir(), 'gvr-uset-'));
|
||||
const as = (id: string, role: 'admin' | 'member' = 'member') => ({ 'x-gvr-user': encodeURIComponent(JSON.stringify({ id, name: id, avatar: null })), 'x-gvr-role': role });
|
||||
|
||||
async function setup() {
|
||||
const dir = tmp();
|
||||
const store = new Store(path.join(dir, 'db.sqlite'));
|
||||
const bus = new Bus();
|
||||
bus.usersProvider = () => store.listUsers().map((u) => ({ id: u.id, name: u.name, color: u.color, avatar: u.avatar, excluded: !!u.excluded, riot: [] }));
|
||||
const live: any[] = [];
|
||||
bus.on('live', (e) => live.push(e));
|
||||
store.upsertUser({ id: 'u1', name: '하늘', avatar: null });
|
||||
store.upsertUser({ id: 'u2', name: '민수', avatar: null });
|
||||
store.setAccounts('u2', [{ puuid: 'p2', riotId: '민수#KR1' }]);
|
||||
let renamed = 0;
|
||||
const app = await buildApi({
|
||||
store,
|
||||
timeline: new Timeline(store),
|
||||
games: {} as any,
|
||||
dict: {} as any,
|
||||
culprit: {} as any,
|
||||
bus,
|
||||
settings: () => ({}) as any,
|
||||
trainingDir: () => path.join(dir, 'training'),
|
||||
overviewExtra: () => ({ guild: null, recording: {} as any }),
|
||||
version: 'test',
|
||||
onNamesChanged: () => renamed++,
|
||||
});
|
||||
return { store, app, live, renamed: () => renamed };
|
||||
}
|
||||
|
||||
test('유저 설정: 본인은 색 · 녹음 제외 · 라이엇 ID 를 바꾸고, 바뀌면 사이트에 실시간으로 알린다', async () => {
|
||||
const s = await setup();
|
||||
const r = await s.app.inject({ method: 'PATCH', url: '/api/users/u1', headers: as('u1'), payload: { color: '#45D39A', excluded: true, riotIds: ['하늘#KR1', ' 하늘#KR1 ', '별빛#0001'] } });
|
||||
assert.equal(r.statusCode, 200);
|
||||
const u = r.json().user;
|
||||
assert.equal(u.color, '#45d39a');
|
||||
assert.equal(u.excluded, true);
|
||||
assert.deepEqual(u.riot.map((x: any) => x.riotId), ['하늘#KR1', '별빛#0001'], '같은 ID 는 한 번만');
|
||||
assert.equal(s.live.at(-1).type, 'users.updated');
|
||||
assert.ok(s.live.at(-1).data.length >= 2, '실제 유저 목록을 보낸다');
|
||||
// 이미 연결된 puuid 는 그대로 둔다
|
||||
s.store.setAccounts('u1', [{ puuid: 'p1', riotId: '하늘#KR1' }]);
|
||||
await s.app.inject({ method: 'PATCH', url: '/api/users/u1', headers: as('u1'), payload: { riotIds: ['하늘#KR1'] } });
|
||||
assert.deepEqual(s.store.listAccounts().filter((a) => a.user_id === 'u1'), [{ user_id: 'u1', puuid: 'p1', riot_id: '하늘#KR1' }]);
|
||||
});
|
||||
|
||||
test('유저 설정: 다른 사람 것은 관리자만, 남의 라이엇 ID 는 본인이 가져갈 수 없다, 형식 검사', async () => {
|
||||
const s = await setup();
|
||||
assert.equal((await s.app.inject({ method: 'PATCH', url: '/api/users/u2', headers: as('u1'), payload: { excluded: true } })).statusCode, 403);
|
||||
assert.equal(s.store.getUser('u2')!.excluded, 0);
|
||||
const taken = await s.app.inject({ method: 'PATCH', url: '/api/users/u1', headers: as('u1'), payload: { riotIds: ['민수#KR1', '하늘#KR1'] } });
|
||||
assert.deepEqual(taken.json().taken, ['민수#KR1']);
|
||||
assert.deepEqual(taken.json().user.riot.map((x: any) => x.riotId), ['하늘#KR1']);
|
||||
// 관리자는 다른 사람 설정도 바꾼다
|
||||
const adm = await s.app.inject({ method: 'PATCH', url: '/api/users/u2', headers: as('u1', 'admin'), payload: { excluded: true, color: '#ff4655' } });
|
||||
assert.equal(adm.statusCode, 200);
|
||||
assert.equal(s.store.getUser('u2')!.excluded, 1);
|
||||
assert.equal((await s.app.inject({ method: 'PATCH', url: '/api/users/u1', headers: as('u1'), payload: { color: 'red' } })).statusCode, 400);
|
||||
assert.equal((await s.app.inject({ method: 'PATCH', url: '/api/users/u1', headers: as('u1'), payload: { riotIds: ['a#1', 'b#2', 'c#3', 'd#4', 'e#5', 'f#6'] } })).statusCode, 400);
|
||||
assert.equal((await s.app.inject({ method: 'PATCH', url: '/api/users/nobody', headers: as('nobody'), payload: { excluded: true } })).statusCode, 404);
|
||||
});
|
||||
|
||||
test('표시 이름: 사이트 서버(내부 요청)만 보낼 수 있고, 받으면 이름 · 녹음 파일 이름을 맞추고 알린다', async () => {
|
||||
const s = await setup();
|
||||
const bad = await s.app.inject({ method: 'PUT', url: '/api/internal/names', headers: as('u1', 'admin'), payload: { names: { u1: '해커' } } });
|
||||
assert.equal(bad.statusCode, 403);
|
||||
const ok = await s.app.inject({ method: 'PUT', url: '/api/internal/names', headers: { ...as('server'), 'x-gvr-internal': '1' }, payload: { names: { u1: '하늘별' } } });
|
||||
assert.equal(ok.statusCode, 200);
|
||||
assert.equal(s.store.getUser('u1')!.name, '하늘별');
|
||||
assert.equal(s.renamed(), 1);
|
||||
assert.equal(s.live.at(-1).type, 'users.updated');
|
||||
});
|
||||
@@ -200,7 +200,7 @@ type TimelineItem =
|
||||
| Path | 설명 |
|
||||
|---|---|
|
||||
| `GET /auth/discord` | OAuth2 시작 (`identify guilds`) |
|
||||
| `GET /auth/discord/callback` | 코드 교환 → 봇 토큰으로 `GET /guilds/{GUILD_ID}/members/{uid}` 확인 → 세션 쿠키 |
|
||||
| `GET /auth/discord/callback` | 코드 교환 → 봇 토큰으로 `GET /guilds/{GUILD_ID}/members/{uid}` 확인 → 세션 쿠키. GUILD_ID = 게임 PC 앱에서 녹음할 서버로 고른 서버 (앱이 hello 로 알려 줌, 그 전에는 ALLOWED_GUILD_IDS). 아니면 `/?login=not_member` ("봇과 다른 서버") |
|
||||
| `POST /auth/logout` | |
|
||||
| `GET /auth/me` | `{user:{id,name,avatar}, isOwner}` 또는 401 |
|
||||
| `GET /api/status` | `{device:{registered, online, name, lastSeen, version}, server:{version}}` (로그인 필요) |
|
||||
@@ -216,6 +216,8 @@ type TimelineItem =
|
||||
| `GET /app/admin/users` | 관리자 이상 → `{users: AppUserRow[]}` (최고 관리자 고정 행 포함) |
|
||||
| `POST /app/admin/users` · `PATCH`/`DELETE /app/admin/users/:id` | 최고 관리자만: 등록(`{id, role:'admin'|'user'}`, 디스코드에서 계정 확인) · 역할 변경 · 등록 해제 |
|
||||
| `GET /game-assets/<source>/<path>` | valorant-api.com · ddragon · cdragon 이미지 캐시 프록시 |
|
||||
| `GET /auth/guild` | 로그인 화면 안내용 `{name}`: 들어올 수 있는 서버 이름 |
|
||||
| `GET /site/maps3d` · `GET /site/maps3d/:dir/:code.glb` | 로그인 필요. 발로란트 맵 3D (data/maps3d, `tools/map-extract`). glb 는 gzip 그대로 보낸다 |
|
||||
|
||||
## 8. 겜녹이 봇 중계 (v1.2.1~)
|
||||
|
||||
|
||||
49
docs/dev/replay-3d.md
Normal file
49
docs/dev/replay-3d.md
Normal file
@@ -0,0 +1,49 @@
|
||||
# 3D 리플레이 · 대화 동기화 (작업 노트, 2026-10-17)
|
||||
|
||||
## 결론 (조사)
|
||||
- 발로란트는 리플레이 재생 위치를 주는 API가 없다 (로컬 API는 "리플레이 보는 중"까지). 2026-10-17 사용자 ShooterGame.log 에도 재생 위치는 없다 (열기 · 닫기 · 매치 ID · 시간 옮길 때 선수 재생성만 남음).
|
||||
- 그래서 인게임 리플레이를 따라가지 않고, `.vrf` 를 풀어 **사이트에서 재생**한다. 대화는 사이트 플레이어 "현장 모드" 시계(sceneTs)에 묶여 재생 · 멈춤 · 이동 · 배속이 같이 움직인다.
|
||||
|
||||
## 구성
|
||||
- `tools/replay-extract/` (C#, net10): ValorantReplayParser(MIT, `fetch-parser.sh` 로 고정 커밋을 vendor/ 에 받음) → `gvr-replay` JSON v1
|
||||
- 선수 10명 이동 10Hz (x,y,z,yaw,pitch) · 라운드(구매/교전/끝) · 킬 · 사격 · 스킬/설치물(스파이크 TimedBomb_C 포함) · `recordedAt`(녹화 시작, ReplayInfo.Timestamp)
|
||||
- 13.08 실제 경기(73.8MB): 6초, JSON 5.3MB / gzip 1.4MB, 진단 0
|
||||
- 사이트 `site/web/src/lib/replay.ts` (동기화 · 보간 · 죽음 판정), `components/ReplayViewer.tsx` (three.js, 지연 로드), `ReplayPanel.tsx`
|
||||
- 동기화: `ts = recordedAt + t + offset`, offset = 같은 킬(죽인/죽은 puuid)의 경기 기록 ts − 리플레이 시각의 중앙값. 킬이 3개 미만이면 라운드 교전 시작으로.
|
||||
- 3D: 맵 3D 모양(아래 "맵 3D") 위에 선수를 실제 높이로. 맵 3D 가 없으면 미니맵 바닥
|
||||
- 목 서버: `GVR_MOCK_REPLAY=<json> GVR_MOCK_REPLAY_MAP_FILE=<어비스 png> npm run dev` → `/matches/val-replay-demo` (경기 기록 킬을 1234ms 늦게 찍어 동기화 확인)
|
||||
|
||||
## 맵 3D (2026-10-17, 모든 맵)
|
||||
- `tools/map-extract/` (C#, CUE4Parse 고정 커밋 `fetch-cue4parse.sh`): **게임 파일을 받지 않고** Riot CDN 번들에서 필요한 조각만 HTTP Range 로 읽는다 (매니페스트 RMAN 파싱 `src/Rman.cs`, 원격 임의 읽기 `src/Cdn.cs`, 메모리 캐시 1.5GB, 디스크 안 씀).
|
||||
- 맵 = 하위 레벨을 불러오는 영구 레벨 (경기 기록 맵 경로 `/Game/Maps/Ascent/Ascent` 와 같다). 하위 레벨 중 `LevelStreamingAlwaysLoaded` 이고 이름이 빛 · 소리 · 게임 규칙 · 부피 · 먼 배경 · 이벤트 장식이 아닌 것만 (`MapScene.NotVisual`).
|
||||
- StaticMesh(+인스턴스) 가장 낮은 LOD 를 월드 좌표(cm)로 구워 맵마다 glb 하나 (위치 + 삼각형만, 재질 없음). 사이트가 높이로 색칠.
|
||||
- 13.08 실측: 22개 맵(일반 13 · 팀 데스매치 5 · 스커미시 3 · 어빌리티 드래프트 1) 3.1분, 받은 양 587MB, 최대 메모리 약 1.9GB. `scripts/pack.py` → gltfpack `-cc` + gzip 으로 맵당 0.5~4.6MB (합계 52MB).
|
||||
- 사이트: 서버 `data/maps3d/index.json` + `<dir>/<code>.glb.gz`, `GET /site/maps3d*` (로그인 필요). 재생기 `lib/map3d.ts` 가 meshopt 로 풀어 리플레이와 같은 좌표 변환 행렬로 놓는다. 맵이 있으면 미니맵 바닥 · 선수 그림자는 숨긴다.
|
||||
- meshopt 는 WebAssembly 라 CSP `script-src` 에 `'wasm-unsafe-eval'` 가 필요하다 (없으면 미니맵으로 대체됨, 헤드리스 크롬으로 둘 다 확인).
|
||||
- 천장 자르기: 자동(고른 선수 · 없으면 가장 높은 산 선수 몸 중심 + 380cm 위를 자름) · 없음 · 직접(슬라이더).
|
||||
- 자동 갱신: `scripts/install.sh` 가 `~/gvr-maps` 에 설치, `gvr-maps-update.timer` 30분마다 `update.sh`: uedb 매핑(버전 · 갱신 시각) 또는 라이브 매니페스트가 바뀌면 매핑을 받아 `~/gvr-maps/mappings/` + nextcloud `claude/game-voice-recorder/valorant/mappings/` 에 보관 → 전체 추출 → .5 `data/maps3d` 에 올리고 index.json 교체 (이전 폴더 1개만 남김). 어느 단계든 실패하면 이전 맵 유지, 같은 조합은 30분 · 1 · 2 · 4 · 6시간 간격으로 재시도 (첫 실패 · 성공 때 이 방 채널에 한 줄 알림, uedb/패치 확인 자체는 6번 연속 실패 때 알림). 지금 사이트에 있는 맵이 하나라도 새 결과에 없으면 올리지 않는다 (추출기도 맵 찾기 중 레벨 읽기 실패를 실패로 친다). 강제(대기 · 누락 검사 무시): `~/gvr-maps/scripts/update.sh --force`. 시험: `scripts/test-update.sh`.
|
||||
|
||||
## 앱 (v1.5.0)
|
||||
- `app/src/core/replays.ts`: `%LOCALAPPDATA%\VALORANT\Saved` 아래(깊이 3, Logs · Crashes · Config 제외) `<경기 ID>.vrf` → 사이트가 열 때 `gvr-replay.exe <vrf> <tmp.json>` (낮은 우선순위, 한 번에 하나, 3분 제한) → gzip → `GVR-Data/replays/<경기 ID>.json.gz` + `.src`(크기:수정시각:앱 버전). 실패는 메모리에 기억 (파일이 바뀌거나 앱을 다시 켜면 다시)
|
||||
- `GET /api/matches/:id/replay`: 15초 안에 끝나면 200 (content-encoding gzip), 아니면 202 `{status:'converting'}` → 사이트가 3초마다 다시. 중계는 content-encoding 이 있으면 바이너리 조각 (`relay/client.ts`)
|
||||
- 빌드: win-ci `replay_build` 단계 (.NET 10 SDK `C:\win-ci\dotnet`, `dotnet publish -r win-x64` 단일 파일 38MB) → electron-builder extraResources `replay/`. 호스트 `~/win-ci/serve/gvr-test.vrf`(13.08 어비스 경기) 가 있으면 변환기 · 포터블 앱 smoke(`GVR_SMOKE_VRF`) 둘 다 실제 변환
|
||||
- 리눅스 실측(13.08, 73.8MB vrf): 5.5초, 최대 메모리 347MB, gzip 1.4MB
|
||||
|
||||
## 남은 일
|
||||
- 실제 경기로 동기화 오차 확인 (사이트 아래 줄 "킬 N개로 맞춤 (최대 오차 X초)")
|
||||
|
||||
## 완전 3D (맵 · 캐릭터 · 총 · 효과) 조사 (2026-10-17)
|
||||
- 게임 파일: Riot CDN 에서 바로 받을 수 있다 (게임 PC 불필요). 매니페스트는
|
||||
`https://clientconfig.rpg.riotgames.com/api/v1/config/public?namespace=keystone.products.valorant.patchlines` 의 `*.manifest`,
|
||||
받기는 Morilli/ManifestDownloader (`-b https://valorant.secure.dyn.riotcdn.net/channels/public/bundles --no-langs -f 'ShooterGame/Content/Paks/(pakchunk|global)'`), 13.08 기준 34GB · 10분.
|
||||
- 열기: CUE4Parse (`EGame.GAME_Valorant`, 공개 AES 키, 리눅스 Oodle 자동 다운로드) → 파일 396,466개, `Maps/Infinity/*.umap` 확인.
|
||||
- 매핑: 13.08 부터 패키지가 unversioned → `.usmap` 필요. **공개 배포처가 있다**: `https://uedb.dev/svc/api/v1/valorant/mappings` (패치별 JSON → Brotli/ZStandard usmap URL, 13.08 은 2026-10-16 갱신), AES 는 `.../valorant/aes`. 출처: sinnafuls/cue4parse-mcp `games.example.json`.
|
||||
- 이전에 시도한 다른 게임 매핑(Remnant2 등)은 틀린 매핑이라 배열 길이를 잘못 읽어 메모리가 폭주했다 (17.6GB). 올바른 매핑으로는 어비스 전체 읽기 최대 1.3GB · 9초.
|
||||
- Uiana-MapImporter(djhaled) 는 UE4 시절(2023, 매핑 불필요) 코드라 그대로는 안 됨 (발로란트 UE5.3 전환은 11.02).
|
||||
- 어비스 결과 (2026-10-17): `Maps/Infinity/Infinity_Art_*.umap` 17개 → StaticMesh 컴포넌트 2,237 + ISM 인스턴스 1,833 = 배치 3,632, 고유 메시 991 (전부 pakchunk0/1 안, 받기 11GB · 3분), 삼각형 136만 (최저 LOD). glb 146MB.
|
||||
- 좌표: 리플레이 선수 x,y,z 와 맵 월드 좌표(UE cm)가 변환 없이 일치 (선수 점이 통로 위에만 찍힘). glb 는 (x,z,y)*0.01 로 저장되므로 되돌릴 때 주의.
|
||||
- 위에서 볼 때 지붕을 걸러야 한다 (Z 1500cm 이상 삼각형 제외로 미리보기 확인).
|
||||
- 추출기: `~/work/valoexp` (CUE4Parse, 명령 `where/deps/scene/export`), 합성 · 미리보기 `~/work/valomap/tools/compose.py`. CUE4Parse glTF 내보내기가 리눅스에서 `\` 경로로 파일을 쓰는 버그가 있어 옮겨야 함.
|
||||
- 보관: nextcloud `claude/game-voice-recorder/valorant/13.08/` (nextcloud 에서는 `claude/` 폴더 안만 다룬다, 사용자 규칙) (abyss-13.08.tar.gz = glb · scene.json · 미리보기 · usmap · 도구 사본, usmap 단독). 계정은 secrets `nextcloud.192.168.10.10`.
|
||||
- 실험은 반드시 `systemd-run --user --scope -p MemoryMax=6G -p MemorySwapMax=0` 안에서.
|
||||
- 디스크: .9 는 150GB 이상 비워 둔다 (사용자 요청). 게임 파일은 다시 받을 수 있으므로 지웠다. 큰 결과물은 nextcloud(.10:8080)로 (로그인 정보 필요).
|
||||
@@ -271,3 +271,11 @@ VOICE E2E PASS
|
||||
- 고침: 선수 이름은 한글이 들어간 것만 핫워드로. 결과가 선수 이름(조각)뿐이면 워커가 이름을 빼고 다시 변환. 예전 발화는 한 번만 다시 변환(파일 없으면 숨김, 고친 발화 제외)
|
||||
- 테스트: 워커 `test_hotword_echo.py` 이름 되풀이 3개, 앱 `name-echo.test.ts` 3개(판정 · 핫워드에 영문 닉네임 빠짐 · 예전 발화 다시 보기 한 번만)
|
||||
- 실제 모델(faster-whisper small, CPU): 실제 말소리 · 키보드 · 잡음 파일에 영문 닉네임 핫워드를 넣어도 정상, 결과 전체를 선수 이름으로 준 경우 되풀이로 잡고 이름 없이 다시 변환해 실제 말을 돌려줌
|
||||
- 배포: Windows CI (010d247, full) 7개 모두 PASS · 앱 버전 1.4.3 → Gitea 릴리스 v1.4.3 (v1.4.2 에 새 버전 안내). 사이트 서버는 바뀐 것 없음
|
||||
|
||||
## v1.5.0 — 3D 리플레이: 앱이 리플레이를 찾아 변환 (2026-10-17)
|
||||
|
||||
- 앱 `replays.ts`: `%LOCALAPPDATA%\VALORANT\Saved` 아래 `<경기 ID>.vrf` → 사이트가 열 때 `gvr-replay.exe` 로 변환 → `GVR-Data/replays/<경기 ID>.json.gz`. API `GET /api/matches/:id/replay` (gzip, 변환 중 202, 실패 422) · `GET /api/replays`
|
||||
- 테스트: 앱 73(새 `replays.test.ts` 7개: 찾기 · 변환 후 보관본 · 실패 기억과 다시 내려받으면 다시 · 202 → 200 · 변환기 없음 · 중계 gzip 바이너리 · 실제 리눅스 변환기로 13.08 리플레이) · 사이트 서버 27 통과, 타입 검사 · 화면 빌드 통과
|
||||
- Windows CI (adc1c66, full) 8개 모두 PASS: 새 `replay_build` (.NET 10.0.402, gvr-replay.exe 36.3MB, 13.08 어비스 리플레이 6.8초 변환), `app_smoke` 에서 포터블 앱 안 변환기로 같은 리플레이 9.1초 변환(gzip 1.39MB)
|
||||
- 배포: 사이트 서버 다시 배포 (화면 번들에 '변환하는 중' 확인), 앱 버전 1.5.0 → Gitea 릴리스 v1.5.0 (v1.4.3 에 새 버전 안내)
|
||||
|
||||
@@ -28,7 +28,17 @@ const sha = (s: string) => crypto.createHash('sha256').update(s).digest();
|
||||
|
||||
export function registerAppAuth(
|
||||
app: FastifyInstance,
|
||||
deps: { cfg: Config; store: ServerStore; discord: DiscordApi; secure: boolean; onRevoke?: (by: { userId?: string; token?: string }) => void },
|
||||
deps: {
|
||||
cfg: Config;
|
||||
store: ServerStore;
|
||||
discord: DiscordApi;
|
||||
secure: boolean;
|
||||
onRevoke?: (by: { userId?: string; token?: string }) => void;
|
||||
/** 사이트 로그인 세션 (사이트 관리 화면 /site/admin/*). app.ts 가 나중에 넣는다 */
|
||||
siteSession?: (req: FastifyRequest, reply: FastifyReply) => Promise<{ user: { id: string } } | null>;
|
||||
/** 표시 이름이 바뀌었을 때 (게임 PC 앱에 바로 보낸다) */
|
||||
onNamesChanged?: (id: string, name: string | null) => void;
|
||||
},
|
||||
) {
|
||||
const { cfg, store, discord, secure } = deps;
|
||||
const revoke = (by: { userId?: string; token?: string }) => deps.onRevoke?.(by);
|
||||
@@ -186,64 +196,109 @@ export function registerAppAuth(
|
||||
if (!(await auth(req, reply))) return;
|
||||
return { names: store.displayNames() };
|
||||
});
|
||||
app.put<{ Body: { id?: string; name?: string | null } }>('/app/admin/names', async (req, reply) => {
|
||||
const a = await need(req, reply, 'superadmin');
|
||||
if (!a) return;
|
||||
const id = String(req.body?.id ?? '').trim();
|
||||
const name = String(req.body?.name ?? '').trim().slice(0, 32);
|
||||
if (!SNOWFLAKE.test(id)) return reply.code(400).send({ error: 'bad_id', message: '디스코드 아이디는 17~20자리 숫자입니다' });
|
||||
store.setDisplayName(id, name || null);
|
||||
req.log.info({ by: a.id, user: id, set: !!name }, '표시 이름 변경');
|
||||
return { names: store.displayNames() };
|
||||
});
|
||||
|
||||
app.get('/app/admin/users', async (req, reply) => {
|
||||
if (!(await need(req, reply, 'admin'))) return;
|
||||
return { users: rows() };
|
||||
});
|
||||
|
||||
app.post<{ Body: { id?: string; role?: string } }>('/app/admin/users', async (req, reply) => {
|
||||
const a = await need(req, reply, 'superadmin');
|
||||
if (!a) return;
|
||||
const id = String(req.body?.id ?? '').trim();
|
||||
const r = role(req.body?.role ?? 'user');
|
||||
if (!SNOWFLAKE.test(id)) return reply.code(400).send({ error: 'bad_id', message: '디스코드 아이디는 17~20자리 숫자입니다' });
|
||||
if (!r) return reply.code(400).send({ error: 'bad_role', message: '역할은 관리자 또는 유저입니다' });
|
||||
if (cfg.superAdmins.includes(id)) return reply.code(400).send({ error: 'fixed', message: '최고 관리자는 이미 등록되어 있습니다' });
|
||||
let du: DiscordUser | null;
|
||||
try {
|
||||
du = await fetchDiscordUser(cfg, id);
|
||||
} catch (e) {
|
||||
req.log.warn(e, '디스코드 계정 조회 실패');
|
||||
return reply.code(502).send({ error: 'discord_error', message: '디스코드에서 계정을 확인하지 못했습니다. 잠시 뒤 다시 시도해 주세요' });
|
||||
// 관리 API 는 두 곳에서 부른다: 앱 관리자 탭(/app/admin/*, 앱 토큰) · 사이트 관리 화면(/site/admin/*, 사이트 로그인 v1.6.0~)
|
||||
const siteNeed = async (req: FastifyRequest, reply: FastifyReply, level: 'admin' | 'superadmin') => {
|
||||
const s = deps.siteSession ? await deps.siteSession(req, reply) : null;
|
||||
if (!s) {
|
||||
if (!reply.sent) reply.code(401).send({ error: 'unauthorized' });
|
||||
return null;
|
||||
}
|
||||
if (!du) return reply.code(404).send({ error: 'unknown_user', message: '디스코드에 없는 아이디입니다' });
|
||||
if ((du as any).bot) return reply.code(400).send({ error: 'bot', message: '봇 계정은 등록할 수 없습니다' });
|
||||
store.upsertAppUser({ id, name: du.global_name || du.username, avatar: avatarUrl(du), role: r, addedBy: a.id });
|
||||
req.log.info({ by: a.id, user: id, role: r }, '앱 유저 등록');
|
||||
return { users: rows() };
|
||||
});
|
||||
// 쓰기 요청은 같은 사이트에서 온 것만 (CSRF)
|
||||
const origin = String(req.headers.origin || '');
|
||||
if (req.method !== 'GET' && origin && origin !== cfg.publicUrl) {
|
||||
reply.code(403).send({ error: 'bad_origin' });
|
||||
return null;
|
||||
}
|
||||
const r = siteRole(s.user.id);
|
||||
const ok = r && (level === 'superadmin' ? r === 'superadmin' : r !== 'user');
|
||||
if (!ok) {
|
||||
reply.code(403).send({ error: 'forbidden', message: level === 'superadmin' ? '유저 등록 · 역할 바꾸기는 최고 관리자만 할 수 있습니다' : '관리자만 볼 수 있습니다' });
|
||||
return null;
|
||||
}
|
||||
return { id: s.user.id, role: r };
|
||||
};
|
||||
for (const [prefix, who] of [
|
||||
['/app/admin', need],
|
||||
['/site/admin', siteNeed],
|
||||
] as const) {
|
||||
// 표시 이름: 앱에서는 최고 관리자만 (v1.2~), 사이트 관리 화면에서는 관리자도 (v1.6.0)
|
||||
app.put<{ Body: { id?: string; name?: string | null } }>(`${prefix}/names`, async (req, reply) => {
|
||||
const a = await who(req, reply, prefix === '/app/admin' ? 'superadmin' : 'admin');
|
||||
if (!a) return;
|
||||
const id = String(req.body?.id ?? '').trim();
|
||||
if (!SNOWFLAKE.test(id)) return reply.code(400).send({ error: 'bad_id', message: '디스코드 아이디는 17~20자리 숫자입니다' });
|
||||
const v = checkName(req.body?.name, id);
|
||||
if ('error' in v) return reply.code(400).send({ error: 'bad_name', message: v.error });
|
||||
store.setDisplayName(id, v.name);
|
||||
req.log.info({ by: a.id, user: id, set: !!v.name }, '표시 이름 변경');
|
||||
deps.onNamesChanged?.(id, v.name);
|
||||
return { names: store.displayNames() };
|
||||
});
|
||||
|
||||
app.patch<{ Params: { id: string }; Body: { role?: string } }>('/app/admin/users/:id', async (req, reply) => {
|
||||
const a = await need(req, reply, 'superadmin');
|
||||
if (!a) return;
|
||||
const r = role(req.body?.role);
|
||||
if (!r) return reply.code(400).send({ error: 'bad_role', message: '역할은 관리자 또는 유저입니다' });
|
||||
if (cfg.superAdmins.includes(req.params.id)) return reply.code(400).send({ error: 'fixed', message: '최고 관리자는 바꿀 수 없습니다' });
|
||||
if (!store.setAppUserRole(req.params.id, r)) return reply.code(404).send({ error: 'not_found', message: '등록되지 않은 아이디입니다' });
|
||||
req.log.info({ by: a.id, user: req.params.id, role: r }, '앱 유저 역할 변경');
|
||||
return { users: rows() };
|
||||
});
|
||||
app.get(`${prefix}/users`, async (req, reply) => {
|
||||
if (!(await who(req, reply, 'admin'))) return;
|
||||
return { users: rows(), names: store.displayNames() };
|
||||
});
|
||||
|
||||
app.delete<{ Params: { id: string } }>('/app/admin/users/:id', async (req, reply) => {
|
||||
const a = await need(req, reply, 'superadmin');
|
||||
if (!a) return;
|
||||
if (cfg.superAdmins.includes(req.params.id)) return reply.code(400).send({ error: 'fixed', message: '최고 관리자는 지울 수 없습니다' });
|
||||
if (!store.removeAppUser(req.params.id)) return reply.code(404).send({ error: 'not_found', message: '등록되지 않은 아이디입니다' });
|
||||
revoke({ userId: req.params.id });
|
||||
req.log.info({ by: a.id, user: req.params.id }, '앱 유저 등록 해제');
|
||||
return { users: rows() };
|
||||
});
|
||||
app.post<{ Body: { id?: string; role?: string } }>(`${prefix}/users`, async (req, reply) => {
|
||||
const a = await who(req, reply, 'superadmin');
|
||||
if (!a) return;
|
||||
const id = String(req.body?.id ?? '').trim();
|
||||
const r = role(req.body?.role ?? 'user');
|
||||
if (!SNOWFLAKE.test(id)) return reply.code(400).send({ error: 'bad_id', message: '디스코드 아이디는 17~20자리 숫자입니다' });
|
||||
if (!r) return reply.code(400).send({ error: 'bad_role', message: '역할은 관리자 또는 유저입니다' });
|
||||
if (cfg.superAdmins.includes(id)) return reply.code(400).send({ error: 'fixed', message: '최고 관리자는 이미 등록되어 있습니다' });
|
||||
let du: DiscordUser | null;
|
||||
try {
|
||||
du = await fetchDiscordUser(cfg, id);
|
||||
} catch (e) {
|
||||
req.log.warn(e, '디스코드 계정 조회 실패');
|
||||
return reply.code(502).send({ error: 'discord_error', message: '디스코드에서 계정을 확인하지 못했습니다. 잠시 뒤 다시 시도해 주세요' });
|
||||
}
|
||||
if (!du) return reply.code(404).send({ error: 'unknown_user', message: '디스코드에 없는 아이디입니다' });
|
||||
if ((du as any).bot) return reply.code(400).send({ error: 'bot', message: '봇 계정은 등록할 수 없습니다' });
|
||||
store.upsertAppUser({ id, name: store.nameOf(id, du.global_name || du.username), avatar: avatarUrl(du), role: r, addedBy: a.id });
|
||||
req.log.info({ by: a.id, user: id, role: r }, '앱 유저 등록');
|
||||
return { users: rows() };
|
||||
});
|
||||
|
||||
app.patch<{ Params: { id: string }; Body: { role?: string } }>(`${prefix}/users/:id`, async (req, reply) => {
|
||||
const a = await who(req, reply, 'superadmin');
|
||||
if (!a) return;
|
||||
const r = role(req.body?.role);
|
||||
if (!r) return reply.code(400).send({ error: 'bad_role', message: '역할은 관리자 또는 유저입니다' });
|
||||
if (cfg.superAdmins.includes(req.params.id)) return reply.code(400).send({ error: 'fixed', message: '최고 관리자는 바꿀 수 없습니다' });
|
||||
if (!store.setAppUserRole(req.params.id, r)) return reply.code(404).send({ error: 'not_found', message: '등록되지 않은 아이디입니다' });
|
||||
req.log.info({ by: a.id, user: req.params.id, role: r }, '앱 유저 역할 변경');
|
||||
return { users: rows() };
|
||||
});
|
||||
|
||||
app.delete<{ Params: { id: string } }>(`${prefix}/users/:id`, async (req, reply) => {
|
||||
const a = await who(req, reply, 'superadmin');
|
||||
if (!a) return;
|
||||
if (cfg.superAdmins.includes(req.params.id)) return reply.code(400).send({ error: 'fixed', message: '최고 관리자는 지울 수 없습니다' });
|
||||
if (!store.removeAppUser(req.params.id)) return reply.code(404).send({ error: 'not_found', message: '등록되지 않은 아이디입니다' });
|
||||
revoke({ userId: req.params.id });
|
||||
req.log.info({ by: a.id, user: req.params.id }, '앱 유저 등록 해제');
|
||||
return { users: rows() };
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* 표시 이름 확인: 빈 값이면 지우기(디스코드 이름으로), 아니면 1~32자 · 제어 문자 없음 · 다른 사람의 표시 이름과 겹치지 않음
|
||||
* (같은 이름이 둘이면 기록 · 범인 분석에서 누가 누군지 알 수 없다)
|
||||
*/
|
||||
function checkName(raw: unknown, id: string): { name: string | null } | { error: string } {
|
||||
if (raw === null || raw === undefined) return { name: null };
|
||||
const name = String(raw).normalize('NFC').replace(/\s+/g, ' ').trim();
|
||||
if (!name) return { name: null };
|
||||
if ([...name].length > 32) return { error: '이름은 32자까지입니다' };
|
||||
if (/[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u2028-\u202e\u2066-\u2069\ufeff]/.test(name)) return { error: '이름에 쓸 수 없는 글자가 있습니다' };
|
||||
const key = name.toLowerCase();
|
||||
for (const [other, n] of Object.entries(store.displayNames())) if (other !== id && n.toLowerCase() === key) return { error: '다른 사람이 이미 쓰는 이름입니다' };
|
||||
return { name };
|
||||
}
|
||||
const siteRole = (id: string): AppRole | null => roleOf(id) ?? (cfg.owners.includes(id) ? 'admin' : null);
|
||||
|
||||
/** 겜녹이 봇 중계 연결 확인: 살아 있는 앱 토큰 + 등록된 아이디 */
|
||||
const verifyToken = (token: string): { userId: string; role: AppRole } | null => {
|
||||
@@ -252,7 +307,7 @@ export function registerAppAuth(
|
||||
return s && r ? { userId: s.userId, role: r } : null;
|
||||
};
|
||||
|
||||
return { completeLogin, verifyToken, roleOf };
|
||||
return { completeLogin, verifyToken, roleOf, siteRole, checkName };
|
||||
}
|
||||
|
||||
const esc = (s: string) => s.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
|
||||
|
||||
@@ -9,7 +9,8 @@ import { registerAppAuth } from './app-auth.js';
|
||||
import { BotBroker, type BotSource } from './bot-broker.js';
|
||||
import { registerCulprit, type ModelCall } from './culprit.js';
|
||||
import type { KnowledgeAuto } from './culprit-prompt.js';
|
||||
import { avatarUrl, DiscordApi } from './discord.js';
|
||||
import { avatarUrl, DiscordApi, fetchDiscordUser } from './discord.js';
|
||||
import { registerMaps3d } from './maps3d.js';
|
||||
import { RateLimiter } from './rate-limit.js';
|
||||
import { RelayHub } from './relay.js';
|
||||
import { SiteLog } from './site-log.js';
|
||||
@@ -21,7 +22,7 @@ const RECHECK_MS = 10 * 60000;
|
||||
/** botSource: 겜녹이 봇 디스코드 연결 (main.ts 가 discord.js 로 만든다. 없으면 /app/bot/ws 는 503) */
|
||||
export async function buildServer(
|
||||
cfg: Config,
|
||||
opts: { botSource?: BotSource; botRecheckMs?: number; culpritCall?: ModelCall; culpritKnowledge?: KnowledgeAuto; logEcho?: boolean } = {},
|
||||
opts: { botSource?: BotSource; botRecheckMs?: number; culpritCall?: ModelCall; culpritKnowledge?: KnowledgeAuto; logEcho?: boolean; browserRecheckMs?: number } = {},
|
||||
) {
|
||||
// 사이트 로그: 날짜별 파일(data/logs/site-날짜.log)로 남기고 관리자가 사이트에서 본다. 게임 PC 가 꺼져 있어도 볼 수 있다
|
||||
const siteLog = new SiteLog(path.join(cfg.dataDir, 'logs'), { echo: opts.logEcho ?? true });
|
||||
@@ -45,15 +46,24 @@ export async function buildServer(
|
||||
await app.register(cookie, { secret: cfg.sessionSecret });
|
||||
const secure = cfg.publicUrl.startsWith('https://');
|
||||
let broker: BotBroker | null = null;
|
||||
const appAuth = registerAppAuth(app, { cfg, store, discord, secure, onRevoke: (by) => broker?.kick(by) });
|
||||
const appAuth = registerAppAuth(app, {
|
||||
cfg,
|
||||
store,
|
||||
discord,
|
||||
secure,
|
||||
onRevoke: (by) => broker?.kick(by),
|
||||
siteSession: (req, reply) => requireSession(req, reply),
|
||||
onNamesChanged: (id, name) => (name ? pushNames() : void restoreName(id).then(pushNames)),
|
||||
});
|
||||
if (opts.botSource) broker = new BotBroker(opts.botSource, appAuth.verifyToken, app.log.child({ area: 'bot' }), opts.botRecheckMs);
|
||||
|
||||
// 보안 헤더. HSTS · X-Frame-Options · Referrer-Policy 는 앞단 프록시(NPMplus)가 붙인다 (http → https 이동도 프록시)
|
||||
// CSP: 이 사이트의 스크립트만 실행, 접속은 이 사이트로만 (XSS 가 생겨도 기록을 바깥으로 보내지 못하게)
|
||||
// 'wasm-unsafe-eval': 맵 3D 압축 풀기(meshopt, WebAssembly)만 허용. 자바스크립트 eval 은 여전히 막힌다
|
||||
const wsOrigin = cfg.publicUrl.replace(/^http/, 'ws');
|
||||
const csp = [
|
||||
"default-src 'self'",
|
||||
"script-src 'self'",
|
||||
"script-src 'self' 'wasm-unsafe-eval'",
|
||||
"style-src 'self' 'unsafe-inline'",
|
||||
"img-src 'self' data: blob: https://cdn.discordapp.com",
|
||||
"media-src 'self' blob: data:",
|
||||
@@ -71,11 +81,11 @@ export async function buildServer(
|
||||
return payload;
|
||||
});
|
||||
|
||||
/** 사이트에 들어올 수 있는 서버: 게임 PC 앱에서 녹음할 서버로 고른 곳 하나.
|
||||
* 앱이 아직 한 번도 알려 주지 않았을 때만 ALLOWED_GUILD_IDS 를 쓴다 */
|
||||
const allowedGuilds = (): string[] => {
|
||||
const g = new Set(cfg.allowedGuilds);
|
||||
const dg = store.device()?.guildId;
|
||||
if (dg) g.add(dg);
|
||||
return [...g];
|
||||
return dg ? [dg] : cfg.allowedGuilds;
|
||||
};
|
||||
|
||||
/** 세션 확인. 10분마다 서버 멤버인지 다시 확인 (서버에서 나가면 바로 막힘) */
|
||||
@@ -191,11 +201,20 @@ export async function buildServer(
|
||||
}
|
||||
});
|
||||
|
||||
/** 로그인 화면: 들어올 수 있는 서버 이름 (봇과 같은 서버) */
|
||||
app.get('/auth/guild', async () => {
|
||||
const g = allowedGuilds()[0];
|
||||
return { name: g ? await discord.guildName(g) : null };
|
||||
});
|
||||
|
||||
app.post('/auth/logout', async (req, reply) => {
|
||||
const raw = req.cookies[SID];
|
||||
const un = raw ? req.unsignCookie(raw) : null;
|
||||
const s = un?.valid && un.value ? store.session(un.value) : null;
|
||||
if (s) store.deleteSession(s.id);
|
||||
if (s) {
|
||||
store.deleteSession(s.id);
|
||||
hub.closeSession(s.id);
|
||||
}
|
||||
reply.clearCookie(SID, { path: '/' });
|
||||
return { ok: true };
|
||||
});
|
||||
@@ -203,7 +222,78 @@ export async function buildServer(
|
||||
app.get('/auth/me', async (req, reply) => {
|
||||
const s = await requireSession(req, reply);
|
||||
if (!s) return;
|
||||
return { user: s.user, isOwner: cfg.owners.includes(s.user.id), canViewLogs: canViewLogs(s.user.id) };
|
||||
return { user: s.user, isOwner: cfg.owners.includes(s.user.id), canViewLogs: canViewLogs(s.user.id), role: appAuth.siteRole(s.user.id) };
|
||||
});
|
||||
|
||||
// ------------------------------------------------------------------ 내 정보 · 표시 이름 (v1.6.0)
|
||||
/** 표시 이름을 게임 PC 앱에 바로 보낸다 (v1.6.0 앱. 예전 앱은 10분마다 받아 간다) */
|
||||
function pushNames(): void {
|
||||
if (!hub.status().online) return;
|
||||
hub
|
||||
.request('PUT', '/api/internal/names', { 'x-gvr-internal': '1', 'content-type': 'application/json', accept: 'application/json' }, { id: 'server', name: '사이트 서버', avatar: null }, JSON.stringify({ names: store.displayNames() }), 10000)
|
||||
.then((r) => r.status >= 400 && app.log.info({ area: 'names', status: r.status }, '게임 PC 앱이 표시 이름을 바로 받지 못함 (예전 앱은 10분 안에 받아 감)'))
|
||||
.catch(() => undefined);
|
||||
}
|
||||
/** 표시 이름을 지우면 디스코드 이름(서버 별명 → 전역 이름 → 아이디)으로 되돌린다 */
|
||||
async function restoreName(id: string): Promise<void> {
|
||||
try {
|
||||
let nick: string | null = null;
|
||||
for (const g of allowedGuilds()) {
|
||||
const m = await discord.memberOf(g, id);
|
||||
if (m?.nick) nick = m.nick;
|
||||
if (m) break;
|
||||
}
|
||||
const u = nick ? null : await fetchDiscordUser(cfg, id);
|
||||
const name = nick || u?.global_name || u?.username;
|
||||
if (name) store.restoreDiscordName(id, name);
|
||||
} catch (e) {
|
||||
app.log.warn({ area: 'names', err: String(e) }, '디스코드 이름 다시 받기 실패');
|
||||
}
|
||||
}
|
||||
// 관리 화면 머리: 게임 PC 상태 + 최신 앱 릴리스 (Gitea, 1시간 보관). 새 버전이 있으면 관리자에게 알린다
|
||||
let latest: { at: number; v: { version: string; url: string; publishedAt: string | null } | null } = { at: 0, v: null };
|
||||
async function latestRelease() {
|
||||
if (!cfg.releasesApi || Date.now() - latest.at < 3600000) return latest.v;
|
||||
latest.at = Date.now();
|
||||
try {
|
||||
const r = await fetch(cfg.releasesApi, { signal: AbortSignal.timeout(5000), headers: { accept: 'application/json' } });
|
||||
if (r.ok) {
|
||||
const j: any = await r.json();
|
||||
if (typeof j.tag_name === 'string') latest.v = { version: j.tag_name.replace(/^v/, ''), url: String(j.html_url ?? ''), publishedAt: j.published_at ?? null };
|
||||
}
|
||||
} catch {
|
||||
/* 다음에 다시 */
|
||||
latest.at = Date.now() - 3300000;
|
||||
}
|
||||
return latest.v;
|
||||
}
|
||||
app.get('/site/admin/overview', async (req, reply) => {
|
||||
const s = await requireSession(req, reply);
|
||||
if (!s) return;
|
||||
const r = appAuth.siteRole(s.user.id);
|
||||
if (!r || r === 'user') return reply.code(403).send({ error: 'forbidden', message: '관리자만 볼 수 있습니다' });
|
||||
const dev = store.device();
|
||||
return { device: { ...hub.status(), guildId: dev?.guildId ?? null }, latest: await latestRelease(), role: r, serverVersion: cfg.version };
|
||||
});
|
||||
const nameLimit = new RateLimiter(10, 10 * 60000);
|
||||
app.get('/site/profile', async (req, reply) => {
|
||||
const s = await requireSession(req, reply);
|
||||
if (!s) return;
|
||||
return { user: s.user, customName: store.displayNames()[s.user.id] ?? null, role: appAuth.siteRole(s.user.id) };
|
||||
});
|
||||
app.put<{ Body: { name?: string | null } }>('/site/profile/name', async (req, reply) => {
|
||||
const s = await requireSession(req, reply);
|
||||
if (!s) return;
|
||||
const origin = String(req.headers.origin || '');
|
||||
if (origin && origin !== cfg.publicUrl) return reply.code(403).send({ error: 'bad_origin' });
|
||||
if (!nameLimit.hit(s.user.id)) return reply.code(429).send({ error: 'rate_limited', message: '이름을 너무 자주 바꿨습니다. 10분 뒤 다시 해 주세요' });
|
||||
const v = appAuth.checkName(req.body?.name, s.user.id);
|
||||
if ('error' in v) return reply.code(400).send({ error: 'bad_name', message: v.error });
|
||||
store.setDisplayName(s.user.id, v.name);
|
||||
if (!v.name) await restoreName(s.user.id);
|
||||
req.log.info({ user: s.user.id, set: !!v.name }, '내 표시 이름 변경');
|
||||
pushNames();
|
||||
return { user: s.user, customName: v.name };
|
||||
});
|
||||
|
||||
// ------------------------------------------------------------------ 상태 · 관리
|
||||
@@ -290,6 +380,9 @@ export async function buildServer(
|
||||
return reply.send(buf);
|
||||
});
|
||||
|
||||
// ------------------------------------------------------------------ 발로란트 맵 3D (로그인 필요)
|
||||
registerMaps3d(app, cfg.dataDir, requireSession);
|
||||
|
||||
app.get('/healthz', async () => 'ok\n');
|
||||
|
||||
// ------------------------------------------------------------------ 사이트 화면
|
||||
@@ -341,7 +434,8 @@ export async function buildServer(
|
||||
socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
|
||||
return socket.destroy();
|
||||
}
|
||||
hub.browserWss.handleUpgrade(req, socket, head, (ws) => hub.attachBrowser(ws));
|
||||
// 연결한 뒤에도 세션 삭제 · 로그아웃 · 서버 탈퇴(getSession 이 10분마다 확인)면 끊는다
|
||||
hub.browserWss.handleUpgrade(req, socket, head, (ws) => hub.attachBrowser(ws, s.id, async () => !!(await getSession(fakeReq)), opts.browserRecheckMs));
|
||||
return;
|
||||
}
|
||||
socket.destroy();
|
||||
|
||||
@@ -20,6 +20,8 @@ export interface Config {
|
||||
/** 테스트용: 디스코드 API 주소 바꾸기 */
|
||||
discordApi: string;
|
||||
assetUpstream: Record<string, string>;
|
||||
/** 최신 앱 릴리스 (Gitea API, 관리 화면에서 새 버전 안내) */
|
||||
releasesApi?: string;
|
||||
/** 범인찾기 (Claude API). apiKey 가 없으면 꺼진다 (없으면 CULPRIT_DEFAULTS) */
|
||||
culprit?: {
|
||||
apiKey: string | null;
|
||||
@@ -59,6 +61,7 @@ export function loadConfig(env = process.env): Config {
|
||||
webDir: env.WEB_DIR || path.resolve('../web/dist'),
|
||||
version: env.GVR_VERSION || '1.0.0',
|
||||
discordApi: env.DISCORD_API || 'https://discord.com/api/v10',
|
||||
releasesApi: env.RELEASES_API || 'https://git.tkrmagid.kr/api/v1/repos/tkrmagid/game_voice_recorder/releases/latest',
|
||||
assetUpstream: {
|
||||
valmedia: 'https://media.valorant-api.com/',
|
||||
ddragon: 'https://ddragon.leagueoflegends.com/',
|
||||
|
||||
@@ -52,6 +52,22 @@ export class DiscordApi {
|
||||
const m: any = await r.json();
|
||||
return { nick: m.nick ?? null, avatar: m.avatar ?? null };
|
||||
}
|
||||
|
||||
private guildNames = new Map<string, { name: string | null; at: number }>();
|
||||
/** 서버 이름 (로그인 화면 안내용, 10분 캐시). 모르면 null */
|
||||
async guildName(guildId: string): Promise<string | null> {
|
||||
const c = this.guildNames.get(guildId);
|
||||
if (c && Date.now() - c.at < 600_000) return c.name;
|
||||
let name: string | null = null;
|
||||
try {
|
||||
const r = await fetch(`${this.cfg.discordApi}/guilds/${guildId}`, { headers: { authorization: `Bot ${this.cfg.botToken}` } });
|
||||
if (r.ok) name = ((await r.json()) as { name?: string }).name ?? null;
|
||||
} catch {
|
||||
/* 디스코드 장애면 이름 없이 안내 */
|
||||
}
|
||||
this.guildNames.set(guildId, { name, at: Date.now() });
|
||||
return name;
|
||||
}
|
||||
}
|
||||
|
||||
/** 봇 토큰으로 디스코드 계정 조회 (유저 등록 때 이름 확인). 없는 아이디면 null */
|
||||
|
||||
63
site/server/src/maps3d.ts
Normal file
63
site/server/src/maps3d.ts
Normal file
@@ -0,0 +1,63 @@
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import zlib from 'node:zlib';
|
||||
import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
|
||||
|
||||
/**
|
||||
* 발로란트 맵 3D 모양 (tools/map-extract 가 Riot CDN 에서 뽑아 tools/map-extract/scripts/update.sh 가 올린다).
|
||||
* 게임 파일에서 나온 것이라 로그인한 사람(봇과 같은 서버 멤버)에게만 준다.
|
||||
*
|
||||
* <dataDir>/maps3d/index.json {version, dir, updatedAt, maps:{<맵 경로>:{code,file,bytes,triangles}}}
|
||||
* <dataDir>/maps3d/<dir>/<code>.glb.gz meshopt 압축 glb 를 gzip 한 것. 위치는 UE 월드 좌표(cm)
|
||||
*
|
||||
* GET /site/maps3d → index.json (없으면 {maps:{}})
|
||||
* GET /site/maps3d/:dir/:f → glb (content-encoding gzip). 폴더 이름이 패치마다 바뀌므로 오래 캐시한다
|
||||
*/
|
||||
export interface Maps3dIndex {
|
||||
version: string;
|
||||
dir: string;
|
||||
updatedAt: string;
|
||||
maps: Record<string, { code: string; file: string; bytes: number; triangles: number }>;
|
||||
}
|
||||
|
||||
export function registerMaps3d(app: FastifyInstance, dataDir: string, requireSession: (req: FastifyRequest, reply: FastifyReply) => Promise<unknown>) {
|
||||
const root = path.join(dataDir, 'maps3d');
|
||||
let cache: { mtime: number; data: Maps3dIndex | null } = { mtime: -1, data: null };
|
||||
const index = (): Maps3dIndex | null => {
|
||||
const f = path.join(root, 'index.json');
|
||||
let st: fs.Stats;
|
||||
try {
|
||||
st = fs.statSync(f);
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
if (st.mtimeMs !== cache.mtime) {
|
||||
try {
|
||||
cache = { mtime: st.mtimeMs, data: JSON.parse(fs.readFileSync(f, 'utf8')) as Maps3dIndex };
|
||||
} catch {
|
||||
cache = { mtime: st.mtimeMs, data: null };
|
||||
}
|
||||
}
|
||||
return cache.data;
|
||||
};
|
||||
|
||||
app.get('/site/maps3d', async (req, reply) => {
|
||||
if (!(await requireSession(req, reply))) return;
|
||||
reply.header('cache-control', 'private, no-cache');
|
||||
return index() ?? { version: null, dir: null, maps: {} };
|
||||
});
|
||||
|
||||
app.get<{ Params: { dir: string; file: string } }>('/site/maps3d/:dir/:file', async (req, reply) => {
|
||||
if (!(await requireSession(req, reply))) return;
|
||||
const { dir, file } = req.params;
|
||||
if (!/^[\w.-]+$/.test(dir) || !/^[\w.-]+\.glb$/.test(file) || dir.includes('..')) return reply.code(404).send({ error: 'not_found' });
|
||||
const gz = path.join(root, dir, file + '.gz');
|
||||
if (!fs.existsSync(gz)) return reply.code(404).send({ error: 'not_found' });
|
||||
reply.header('cache-control', 'private, max-age=31536000, immutable').type('model/gltf-binary');
|
||||
if (/\bgzip\b/.test(String(req.headers['accept-encoding'] ?? ''))) {
|
||||
reply.header('content-encoding', 'gzip').header('content-length', fs.statSync(gz).size);
|
||||
return reply.send(fs.createReadStream(gz));
|
||||
}
|
||||
return reply.send(fs.createReadStream(gz).pipe(zlib.createGunzip()));
|
||||
});
|
||||
}
|
||||
@@ -30,6 +30,7 @@ export interface RelayResponse {
|
||||
export class RelayHub {
|
||||
private device: { ws: WebSocket; id: string; name: string; version: string | null; lastMsg: number } | null = null;
|
||||
private browsers = new Set<WebSocket>();
|
||||
private browserSessions = new Map<WebSocket, string>();
|
||||
private pending = new Map<string, Pending>();
|
||||
readonly deviceWss = new WebSocketServer({ noServer: true, maxPayload: 16 * 1024 * 1024 });
|
||||
readonly browserWss = new WebSocketServer({ noServer: true, maxPayload: 64 * 1024 });
|
||||
@@ -224,17 +225,38 @@ export class RelayHub {
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------ 브라우저
|
||||
attachBrowser(ws: WebSocket): void {
|
||||
/**
|
||||
* sessionId: 로그아웃하면 바로 끊는다 (closeSession).
|
||||
* stillAllowed: 주기적으로(기본 30초) 세션이 살아 있고 봇과 같은 서버 멤버인지 다시 확인해, 아니면 4401 로 끊는다
|
||||
*/
|
||||
attachBrowser(ws: WebSocket, sessionId?: string, stillAllowed?: () => Promise<boolean>, recheckMs = 30000): void {
|
||||
this.browsers.add(ws);
|
||||
if (sessionId) this.browserSessions.set(ws, sessionId);
|
||||
ws.send(JSON.stringify({ type: 'status', data: { device: this.status() } } satisfies BrowserMessage));
|
||||
const ping = setInterval(() => ws.readyState === WebSocket.OPEN && ws.ping(), 25000);
|
||||
const recheck = stillAllowed
|
||||
? setInterval(() => {
|
||||
void stillAllowed()
|
||||
.catch(() => true) // 확인 자체가 실패하면(디스코드 장애) 유지
|
||||
.then((ok) => {
|
||||
if (!ok && ws.readyState === WebSocket.OPEN) ws.close(4401, 'unauthorized');
|
||||
});
|
||||
}, recheckMs)
|
||||
: null;
|
||||
ws.on('close', () => {
|
||||
clearInterval(ping);
|
||||
if (recheck) clearInterval(recheck);
|
||||
this.browsers.delete(ws);
|
||||
this.browserSessions.delete(ws);
|
||||
});
|
||||
ws.on('message', () => undefined);
|
||||
}
|
||||
|
||||
/** 로그아웃: 그 세션의 실시간 연결을 끊는다 */
|
||||
closeSession(sessionId: string): void {
|
||||
for (const [ws, sid] of this.browserSessions) if (sid === sessionId) ws.close(4401, 'logged_out');
|
||||
}
|
||||
|
||||
/** 로그아웃·세션 만료 시 해당 브라우저 연결 끊기용 */
|
||||
get browserCount(): number {
|
||||
return this.browsers.size;
|
||||
|
||||
@@ -212,6 +212,15 @@ export class ServerStore {
|
||||
} else delete this.d.displayNames[id];
|
||||
this.save(true);
|
||||
}
|
||||
/** 표시 이름을 지운 뒤 디스코드에서 다시 받은 이름으로 세션 · 앱 유저 이름을 되돌린다 (예전 표시 이름이 남지 않게) */
|
||||
restoreDiscordName(id: string, name: string): void {
|
||||
if (this.d.displayNames[id]) return;
|
||||
for (const s of this.d.sessions) if (s.user.id === id) s.user.name = name;
|
||||
const u = this.appUser(id);
|
||||
if (u) u.name = name;
|
||||
if (this.d.appSeen[id]) this.d.appSeen[id].name = name;
|
||||
this.save(true);
|
||||
}
|
||||
|
||||
// ---- 앱 유저 등록 · 앱 로그인 토큰
|
||||
appUsers(): AppUser[] {
|
||||
|
||||
71
site/server/test/login-guild.test.ts
Normal file
71
site/server/test/login-guild.test.ts
Normal file
@@ -0,0 +1,71 @@
|
||||
// 사이트 로그인: 게임 PC 앱에서 녹음할 서버로 고른 서버의 멤버만 들어온다.
|
||||
// 앱이 서버를 알려 주기 전에만 ALLOWED_GUILD_IDS 를 쓴다.
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import fs from 'node:fs';
|
||||
import http from 'node:http';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import { buildServer } from '../src/app.ts';
|
||||
import type { Config } from '../src/config.ts';
|
||||
|
||||
const tmp = () => fs.mkdtempSync(path.join(process.env.TMPDIR || os.tmpdir(), 'gvr-guild-'));
|
||||
|
||||
// member1 은 111 서버에만 있다. 222 서버 이름은 "앱 서버"
|
||||
async function fakeDiscord() {
|
||||
const srv = http.createServer((req, res) => {
|
||||
const u = new URL(req.url!, 'http://x');
|
||||
res.setHeader('content-type', 'application/json');
|
||||
if (u.pathname === '/oauth2/token') return res.end(JSON.stringify({ access_token: 'at' }));
|
||||
if (u.pathname === '/users/@me') return res.end(JSON.stringify({ id: 'member1', username: 'm', global_name: '멤버', avatar: null }));
|
||||
if (u.pathname === '/guilds/111/members/member1') return res.end(JSON.stringify({ nick: '멤버', avatar: null }));
|
||||
if (u.pathname === '/guilds/222') return res.end(JSON.stringify({ id: '222', name: '앱 서버' }));
|
||||
res.statusCode = 404;
|
||||
res.end('{}');
|
||||
});
|
||||
await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
|
||||
return { url: `http://127.0.0.1:${(srv.address() as any).port}`, close: () => srv.close() };
|
||||
}
|
||||
|
||||
async function stack() {
|
||||
const dc = await fakeDiscord();
|
||||
const cfg: Config = {
|
||||
port: 0, host: '127.0.0.1', publicUrl: 'https://gvr.example', clientId: 'cid', clientSecret: 's', botToken: 'bot',
|
||||
allowedGuilds: ['111'], owners: [], superAdmins: [], sessionSecret: 'x'.repeat(32), dataDir: tmp(), webDir: '/nonexistent',
|
||||
version: 'test', discordApi: dc.url, assetUpstream: {},
|
||||
};
|
||||
const { app, store } = await buildServer(cfg);
|
||||
await app.listen({ host: '127.0.0.1', port: 0 });
|
||||
const base = `http://127.0.0.1:${(app.server.address() as any).port}`;
|
||||
const login = async () => {
|
||||
const start = await fetch(base + '/auth/discord', { redirect: 'manual' });
|
||||
const state = new URL(start.headers.get('location')!).searchParams.get('state')!;
|
||||
const cb = await fetch(`${base}/auth/discord/callback?code=c&state=${state}`, { headers: { cookie: start.headers.getSetCookie()[0]!.split(';')[0]! }, redirect: 'manual' });
|
||||
return cb.headers.get('location');
|
||||
};
|
||||
return { base, store, login, close: async () => (await app.close(), dc.close()) };
|
||||
}
|
||||
|
||||
test('로그인: 앱이 서버를 알려 주기 전에는 ALLOWED_GUILD_IDS 멤버가 들어온다', async () => {
|
||||
const s = await stack();
|
||||
try {
|
||||
assert.equal(await s.login(), '/');
|
||||
} finally {
|
||||
await s.close();
|
||||
}
|
||||
});
|
||||
|
||||
test('로그인: 앱에서 고른 서버의 멤버가 아니면 (ALLOWED_GUILD_IDS 멤버라도) 봇과 다른 서버라 막는다', async () => {
|
||||
const s = await stack();
|
||||
try {
|
||||
const { code } = s.store.createCode('owner');
|
||||
const dev = s.store.redeem(code, 'PC')!;
|
||||
s.store.touchDevice(dev.deviceId, { guildId: '222' });
|
||||
assert.equal(await s.login(), '/?login=not_member');
|
||||
// 로그인 화면은 그 서버 이름으로 안내한다
|
||||
const g = await (await fetch(s.base + '/auth/guild')).json();
|
||||
assert.deepEqual(g, { name: '앱 서버' });
|
||||
} finally {
|
||||
await s.close();
|
||||
}
|
||||
});
|
||||
80
site/server/test/maps3d.test.ts
Normal file
80
site/server/test/maps3d.test.ts
Normal file
@@ -0,0 +1,80 @@
|
||||
// 맵 3D (/site/maps3d): 로그인한 사람에게만, gzip 그대로 보낸다
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import fs from 'node:fs';
|
||||
import http from 'node:http';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import zlib from 'node:zlib';
|
||||
import { buildServer } from '../src/app.ts';
|
||||
import type { Config } from '../src/config.ts';
|
||||
|
||||
const tmp = () => fs.mkdtempSync(path.join(process.env.TMPDIR || os.tmpdir(), 'gvr-maps3d-'));
|
||||
|
||||
// member1 은 111 서버에만 있다. 222 서버 이름은 "앱 서버"
|
||||
async function fakeDiscord() {
|
||||
const srv = http.createServer((req, res) => {
|
||||
const u = new URL(req.url!, 'http://x');
|
||||
res.setHeader('content-type', 'application/json');
|
||||
if (u.pathname === '/oauth2/token') return res.end(JSON.stringify({ access_token: 'at' }));
|
||||
if (u.pathname === '/users/@me') return res.end(JSON.stringify({ id: 'member1', username: 'm', global_name: '멤버', avatar: null }));
|
||||
if (u.pathname === '/guilds/111/members/member1') return res.end(JSON.stringify({ nick: '멤버', avatar: null }));
|
||||
if (u.pathname === '/guilds/222') return res.end(JSON.stringify({ id: '222', name: '앱 서버' }));
|
||||
res.statusCode = 404;
|
||||
res.end('{}');
|
||||
});
|
||||
await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
|
||||
return { url: `http://127.0.0.1:${(srv.address() as any).port}`, close: () => srv.close() };
|
||||
}
|
||||
|
||||
async function stack() {
|
||||
const dc = await fakeDiscord();
|
||||
const cfg: Config = {
|
||||
port: 0, host: '127.0.0.1', publicUrl: 'https://gvr.example', clientId: 'cid', clientSecret: 's', botToken: 'bot',
|
||||
allowedGuilds: ['111'], owners: [], superAdmins: [], sessionSecret: 'x'.repeat(32), dataDir: tmp(), webDir: '/nonexistent',
|
||||
version: 'test', discordApi: dc.url, assetUpstream: {},
|
||||
};
|
||||
// 올려 둔 맵 3D (update.sh 가 만드는 모양)
|
||||
const dir = path.join(cfg.dataDir, 'maps3d', 'V1-1');
|
||||
fs.mkdirSync(dir, { recursive: true });
|
||||
fs.writeFileSync(path.join(dir, 'Ascent.glb.gz'), zlib.gzipSync(Buffer.from('glTF-test')));
|
||||
fs.writeFileSync(path.join(cfg.dataDir, 'maps3d', 'index.json'), JSON.stringify({ version: 'V1', dir: 'V1-1', updatedAt: 'x', maps: { '/Game/Maps/Ascent/Ascent': { code: 'Ascent', file: 'Ascent.glb', bytes: 1, triangles: 1 } } }));
|
||||
const { app, store } = await buildServer(cfg);
|
||||
await app.listen({ host: '127.0.0.1', port: 0 });
|
||||
const base = `http://127.0.0.1:${(app.server.address() as any).port}`;
|
||||
const login = async () => {
|
||||
const start = await fetch(base + '/auth/discord', { redirect: 'manual' });
|
||||
const state = new URL(start.headers.get('location')!).searchParams.get('state')!;
|
||||
const cb = await fetch(`${base}/auth/discord/callback?code=c&state=${state}`, { headers: { cookie: start.headers.getSetCookie()[0]!.split(';')[0]! }, redirect: 'manual' });
|
||||
return cb.headers.getSetCookie().find((c) => c.startsWith('gvr_sid='))!.split(';')[0]!;
|
||||
};
|
||||
return { base, store, login, close: async () => (await app.close(), dc.close()) };
|
||||
}
|
||||
|
||||
test('맵 3D: 로그인 안 하면 목록 · 파일 모두 401', async () => {
|
||||
const s = await stack();
|
||||
try {
|
||||
assert.equal((await fetch(s.base + '/site/maps3d')).status, 401);
|
||||
assert.equal((await fetch(s.base + '/site/maps3d/V1-1/Ascent.glb')).status, 401);
|
||||
} finally {
|
||||
await s.close();
|
||||
}
|
||||
});
|
||||
|
||||
test('맵 3D: 로그인하면 목록과 glb 를 받는다 (gzip), 이상한 경로는 404', async () => {
|
||||
const s = await stack();
|
||||
try {
|
||||
const cookie = await s.login();
|
||||
const idx = (await (await fetch(s.base + '/site/maps3d', { headers: { cookie } })).json()) as any;
|
||||
assert.equal(idx.dir, 'V1-1');
|
||||
assert.ok(idx.maps['/Game/Maps/Ascent/Ascent']);
|
||||
const r = await fetch(s.base + '/site/maps3d/V1-1/Ascent.glb', { headers: { cookie, 'accept-encoding': 'gzip' } });
|
||||
assert.equal(r.status, 200);
|
||||
assert.equal(r.headers.get('content-encoding'), 'gzip');
|
||||
assert.equal(await r.text(), 'glTF-test'); // fetch 가 gzip 을 풀어 준다
|
||||
assert.equal((await fetch(s.base + '/site/maps3d/V1-1/..%2Findex.json', { headers: { cookie } })).status, 404);
|
||||
assert.equal((await fetch(s.base + '/site/maps3d/V1-1/Nope.glb', { headers: { cookie } })).status, 404);
|
||||
} finally {
|
||||
await s.close();
|
||||
}
|
||||
});
|
||||
132
site/server/test/profile-admin.test.ts
Normal file
132
site/server/test/profile-admin.test.ts
Normal file
@@ -0,0 +1,132 @@
|
||||
// 사이트 "내 정보" (표시 이름) · 관리 화면 API (v1.6.0)
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import fs from 'node:fs';
|
||||
import http from 'node:http';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import { buildServer } from '../src/app.ts';
|
||||
import type { Config } from '../src/config.ts';
|
||||
|
||||
const SUPER = '293719842274541579';
|
||||
const ADMIN = '111111111111111111';
|
||||
const MEMBER = '222222222222222222';
|
||||
const OTHER = '333333333333333333';
|
||||
const tmp = () => fs.mkdtempSync(path.join(process.env.TMPDIR || os.tmpdir(), 'gvr-profile-'));
|
||||
const NICK: Record<string, string> = { [SUPER]: '사금향', [ADMIN]: '관리', [MEMBER]: '멤버닉', [OTHER]: '다른' };
|
||||
|
||||
async function fakeDiscord() {
|
||||
const srv = http.createServer((req, res) => {
|
||||
const u = new URL(req.url!, 'http://x');
|
||||
res.setHeader('content-type', 'application/json');
|
||||
const m = /^\/guilds\/111\/members\/(\d+)$/.exec(u.pathname);
|
||||
if (m && NICK[m[1]!]) return res.end(JSON.stringify({ nick: NICK[m[1]!], avatar: null }));
|
||||
const usr = /^\/users\/(\d+)$/.exec(u.pathname);
|
||||
if (usr && NICK[usr[1]!]) return res.end(JSON.stringify({ id: usr[1], username: 'u' + usr[1], global_name: NICK[usr[1]!], avatar: null }));
|
||||
if (u.pathname === '/releases/latest') return res.end(JSON.stringify({ tag_name: 'v1.6.0', html_url: 'https://git.example/releases/tag/v1.6.0', published_at: '2026-10-17T00:00:00Z' }));
|
||||
res.statusCode = 404;
|
||||
res.end('{}');
|
||||
});
|
||||
await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
|
||||
return { url: `http://127.0.0.1:${(srv.address() as any).port}`, close: () => srv.close() };
|
||||
}
|
||||
|
||||
async function stack() {
|
||||
const dc = await fakeDiscord();
|
||||
const cfg: Config = {
|
||||
port: 0, host: '127.0.0.1', publicUrl: 'https://gvr.example', clientId: 'cid', clientSecret: 's', botToken: 'bot',
|
||||
allowedGuilds: ['111'], owners: [SUPER], superAdmins: [SUPER], sessionSecret: 'x'.repeat(32), dataDir: tmp(), webDir: '/nonexistent',
|
||||
version: 'test', discordApi: dc.url, assetUpstream: {}, releasesApi: `${dc.url}/releases/latest`,
|
||||
};
|
||||
const { app, store } = await buildServer(cfg);
|
||||
store.upsertAppUser({ id: ADMIN, name: '관리', avatar: null, role: 'admin', addedBy: SUPER });
|
||||
await app.listen({ host: '127.0.0.1', port: 0 });
|
||||
const base = `http://127.0.0.1:${(app.server.address() as any).port}`;
|
||||
const cookieOf = (id: string) => {
|
||||
const s = store.createSession({ id, name: NICK[id]!, avatar: null });
|
||||
return `gvr_sid=${app.signCookie(s.token)}`;
|
||||
};
|
||||
const as = (id: string) => {
|
||||
const cookie = cookieOf(id);
|
||||
const call = async (method: string, p: string, body?: unknown, origin = 'https://gvr.example') => {
|
||||
const r = await fetch(base + p, { method, headers: { cookie, ...(body !== undefined ? { 'content-type': 'application/json', origin } : {}) }, body: body === undefined ? undefined : JSON.stringify(body) });
|
||||
return { status: r.status, json: (await r.json().catch(() => null)) as any };
|
||||
};
|
||||
return { get: (p: string) => call('GET', p), put: (p: string, b: unknown, o?: string) => call('PUT', p, b, o), post: (p: string, b: unknown) => call('POST', p, b), patch: (p: string, b: unknown) => call('PATCH', p, b), del: (p: string) => call('DELETE', p, {}) };
|
||||
};
|
||||
return { store, as, close: async () => (await app.close(), dc.close()) };
|
||||
}
|
||||
|
||||
test('내 정보: 누구나 자기 표시 이름을 바꾸고, 지우면 디스코드 별명으로 돌아간다', async () => {
|
||||
const s = await stack();
|
||||
try {
|
||||
const me = s.as(MEMBER);
|
||||
assert.deepEqual((await me.get('/site/profile')).json, { user: { id: MEMBER, name: '멤버닉', avatar: null }, customName: null, role: null });
|
||||
const r = await me.put('/site/profile/name', { name: ' 하늘 별 ' });
|
||||
assert.equal(r.status, 200);
|
||||
assert.equal(r.json.user.name, '하늘 별');
|
||||
assert.equal((await me.get('/auth/me')).json.user.name, '하늘 별');
|
||||
assert.equal(s.store.displayNames()[MEMBER], '하늘 별');
|
||||
// 지우기 → 디스코드 서버 별명
|
||||
const back = await me.put('/site/profile/name', { name: '' });
|
||||
assert.equal(back.status, 200);
|
||||
assert.equal(back.json.customName, null);
|
||||
assert.equal((await me.get('/auth/me')).json.user.name, '멤버닉');
|
||||
assert.equal(s.store.displayNames()[MEMBER], undefined);
|
||||
} finally {
|
||||
await s.close();
|
||||
}
|
||||
});
|
||||
|
||||
test('내 정보: 다른 사람 이름 · 너무 긴 이름 · 보이지 않는 글자 · 다른 사이트에서 온 요청은 막는다', async () => {
|
||||
const s = await stack();
|
||||
try {
|
||||
assert.equal((await s.as(OTHER).put('/site/profile/name', { name: '하늘' })).status, 200);
|
||||
const me = s.as(MEMBER);
|
||||
const dup = await me.put('/site/profile/name', { name: '하늘' });
|
||||
assert.equal(dup.status, 400);
|
||||
assert.match(dup.json.message, /이미 쓰는 이름/);
|
||||
assert.equal((await me.put('/site/profile/name', { name: '가'.repeat(33) })).status, 400);
|
||||
assert.equal((await me.put('/site/profile/name', { name: '하늘' })).status, 400);
|
||||
assert.equal((await me.put('/site/profile/name', { name: '별' }, 'https://evil.example')).status, 403);
|
||||
assert.equal(s.store.displayNames()[MEMBER], undefined);
|
||||
} finally {
|
||||
await s.close();
|
||||
}
|
||||
});
|
||||
|
||||
test('관리 화면: 관리자는 목록 · 남의 표시 이름, 등록 · 역할 · 해제는 최고 관리자만, 일반 멤버는 못 들어온다', async () => {
|
||||
const s = await stack();
|
||||
try {
|
||||
const member = s.as(MEMBER);
|
||||
const admin = s.as(ADMIN);
|
||||
const sup = s.as(SUPER);
|
||||
assert.equal((await member.get('/site/admin/users')).status, 403);
|
||||
assert.equal((await member.get('/site/admin/overview')).status, 403);
|
||||
assert.equal((await member.put('/site/admin/names', { id: OTHER, name: 'x' })).status, 403);
|
||||
|
||||
const list = await admin.get('/site/admin/users');
|
||||
assert.equal(list.status, 200);
|
||||
assert.deepEqual(list.json.users.map((u: any) => [u.id, u.role]), [[SUPER, 'superadmin'], [ADMIN, 'admin']]);
|
||||
const ov = await admin.get('/site/admin/overview');
|
||||
assert.equal(ov.json.role, 'admin');
|
||||
assert.equal(ov.json.latest.version, '1.6.0');
|
||||
assert.equal(ov.json.device.registered, false);
|
||||
|
||||
const named = await admin.put('/site/admin/names', { id: MEMBER, name: '지호' });
|
||||
assert.equal(named.status, 200);
|
||||
assert.equal(named.json.names[MEMBER], '지호');
|
||||
assert.equal((await member.get('/auth/me')).json.user.name, '지호', '로그인해 있는 세션 이름도 바뀐다');
|
||||
|
||||
assert.equal((await admin.post('/site/admin/users', { id: MEMBER, role: 'user' })).status, 403);
|
||||
const added = await sup.post('/site/admin/users', { id: MEMBER, role: 'user' });
|
||||
assert.equal(added.status, 200);
|
||||
assert.equal(added.json.users.find((u: any) => u.id === MEMBER).name, '지호', '등록할 때도 표시 이름으로');
|
||||
assert.equal((await sup.patch(`/site/admin/users/${MEMBER}`, { role: 'admin' })).json.users.find((u: any) => u.id === MEMBER).role, 'admin');
|
||||
assert.equal((await sup.patch(`/site/admin/users/${SUPER}`, { role: 'user' })).status, 400);
|
||||
assert.equal((await sup.del(`/site/admin/users/${MEMBER}`)).status, 200);
|
||||
assert.equal((await member.get('/site/admin/users')).status, 403);
|
||||
} finally {
|
||||
await s.close();
|
||||
}
|
||||
});
|
||||
59
site/server/test/replay-sync.test.ts
Normal file
59
site/server/test/replay-sync.test.ts
Normal file
@@ -0,0 +1,59 @@
|
||||
// 사이트 3D 리플레이: 리플레이 시간 ↔ 기록 시각 맞추기 · 위치 보간 · 죽음 판정 (site/web/src/lib/replay.ts)
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { computeSync, isDead, samplePlayer, type ReplayFile } from '../../web/src/lib/replay.ts';
|
||||
|
||||
const track = (pts: [number, number][]) => ({ t: pts.map((p) => p[0]), x: pts.map((p) => p[1]), y: pts.map(() => 0), z: pts.map(() => 100), yaw: pts.map(() => 350), pitch: pts.map(() => 0) });
|
||||
function replay(): ReplayFile {
|
||||
return {
|
||||
format: 'gvr-replay', v: 1, matchId: 'm1', map: null, build: null, recordedAt: 1_000_000, durationMs: 200_000, sampleMs: 100,
|
||||
players: [
|
||||
{ puuid: 'a', character: null, track: track([[0, 0], [10_000, 1000], [50_000, 1000]]) },
|
||||
{ puuid: 'b', character: null, track: track([[0, 0], [40_000, 500]]) },
|
||||
{ puuid: 'c', character: null, track: track([[0, 0], [90_000, 0]]) },
|
||||
],
|
||||
rounds: [{ num: 1, buy: 0, combat: 30_000, end: 80_000 }, { num: 2, buy: 100_000, combat: 130_000, end: -1 }],
|
||||
phases: [], shots: [], objects: [], objectKinds: [],
|
||||
kills: [[40_000, 0, 1], [60_000, 2, 0], [140_000, 0, 2]],
|
||||
};
|
||||
}
|
||||
const kill = (id: string, ts: number, killer: string, victim: string) => ({ kind: 'event', id, ts, type: 'kill', data: { killer: { puuid: killer, name: killer }, victim: { puuid: victim, name: victim }, assists: [], weapon: null } });
|
||||
|
||||
test('킬 시각 차이의 중앙값으로 맞추고, 킬별 오차를 낸다', () => {
|
||||
const r = replay();
|
||||
// 경기 기록이 리플레이보다 2.5초 늦게 찍혔고, 한 킬은 0.2초 더 늦다
|
||||
const m: any = { startedAt: 0, rounds: [], events: [kill('k1', 1_000_000 + 40_000 + 2500, 'a', 'b'), kill('k2', 1_000_000 + 60_000 + 2500, 'c', 'a'), kill('k3', 1_000_000 + 140_000 + 2700, 'a', 'c')] };
|
||||
const s = computeSync(m, r);
|
||||
assert.equal(s.matched, 3);
|
||||
assert.equal(s.offset, 2500);
|
||||
assert.equal(s.spreadMs, 200);
|
||||
});
|
||||
|
||||
test('킬을 못 맞추면 라운드 교전 시작(앱이 저장한 라운드 시작 + 30초)으로 맞춘다', () => {
|
||||
const r = replay();
|
||||
const m: any = { startedAt: 0, events: [], rounds: [{ num: 1, startedAt: 1_000_000 + 30_000 - 30_000 + 4000 }, { num: 2, startedAt: 1_000_000 + 130_000 - 30_000 + 4000 }] };
|
||||
const s = computeSync(m, r);
|
||||
assert.equal(s.matched, 0);
|
||||
assert.equal(s.offset, 4000);
|
||||
assert.equal(s.spreadMs, null);
|
||||
});
|
||||
|
||||
test('위치는 앞뒤 표본 사이를 보간하고, 방향은 짧은 쪽으로 돈다', () => {
|
||||
const tr = track([[0, 0], [100, 100]]);
|
||||
tr.yaw = [350, 10];
|
||||
const p = samplePlayer(tr, 50, 600)!;
|
||||
assert.equal(p.x, 50);
|
||||
assert.equal(p.yaw, 360);
|
||||
assert.equal(samplePlayer(tr, -1000, 600), null);
|
||||
});
|
||||
|
||||
test('죽음: 이 라운드에서 죽은 뒤 다시 움직이지 않으면 죽은 상태, 다음 라운드엔 살아남', () => {
|
||||
const r = replay();
|
||||
assert.equal(isDead(r, 1, 39_000), false);
|
||||
assert.equal(isDead(r, 1, 45_000), true);
|
||||
// a 는 60초에 죽었지만 기록은 50초까지뿐 → 죽음. 다음 라운드(100초~)에는 다시 산다
|
||||
assert.equal(isDead(r, 0, 70_000), true);
|
||||
assert.equal(isDead(r, 0, 110_000), false);
|
||||
// c 는 60초 킬 뒤에도 90초까지 움직였으므로 140초 킬 전까지 살아 있음
|
||||
assert.equal(isDead(r, 2, 120_000), false);
|
||||
});
|
||||
@@ -26,7 +26,7 @@ async function fakeDiscord() {
|
||||
return { url: `http://127.0.0.1:${(srv.address() as any).port}`, close: () => srv.close() };
|
||||
}
|
||||
|
||||
async function stack(dataDir = tmp()) {
|
||||
async function stack(dataDir = tmp(), opts: { browserRecheckMs?: number } = {}) {
|
||||
const dc = await fakeDiscord();
|
||||
const cfg: Config = {
|
||||
port: 0, host: '127.0.0.1', publicUrl: 'https://gvr.example', clientId: 'cid', clientSecret: 's', botToken: 'bot',
|
||||
@@ -34,7 +34,7 @@ async function stack(dataDir = tmp()) {
|
||||
version: 'test', discordApi: dc.url, assetUpstream: {},
|
||||
};
|
||||
const lines: string[] = [];
|
||||
const { app, store } = await buildServer(cfg);
|
||||
const { app, store } = await buildServer(cfg, opts);
|
||||
// 서버 로그를 모아 둔다 (비밀값이 남는지 본다)
|
||||
const orig = process.stdout.write.bind(process.stdout);
|
||||
(process.stdout as any).write = (chunk: any, ...rest: any[]) => (lines.push(String(chunk)), orig(chunk, ...rest));
|
||||
@@ -62,7 +62,7 @@ test('보안 헤더: CSP 는 이 사이트 스크립트 · 접속만 허용하
|
||||
const r = await fetch(s.base + '/healthz');
|
||||
const csp = r.headers.get('content-security-policy') ?? '';
|
||||
assert.match(csp, /default-src 'self'/);
|
||||
assert.match(csp, /script-src 'self'(;|$)/);
|
||||
assert.match(csp, /script-src 'self' 'wasm-unsafe-eval'(;|$)/); // WebAssembly(맵 3D 압축 풀기)만, eval 은 안 됨
|
||||
assert.match(csp, /connect-src 'self' wss:\/\/gvr\.example/);
|
||||
assert.match(csp, /frame-ancestors 'none'/);
|
||||
assert.equal(r.headers.get('x-content-type-options'), 'nosniff');
|
||||
@@ -89,6 +89,28 @@ test('실시간 WebSocket: 다른 사이트에서 로그인 쿠키로 붙으면
|
||||
}
|
||||
});
|
||||
|
||||
test('실시간 WebSocket: 세션이 지워지거나(서버 탈퇴 등) 로그아웃하면 이미 열린 연결도 끊는다', async () => {
|
||||
const s = await stack(tmp(), { browserRecheckMs: 50 });
|
||||
try {
|
||||
const connect = async (sid: string) => {
|
||||
const ws = new WebSocket(s.base.replace('http', 'ws') + '/ws', { headers: { cookie: sid, origin: 'https://gvr.example' } });
|
||||
await new Promise((r) => ws.on('open', r));
|
||||
return { ws, closed: new Promise<number>((r) => ws.on('close', (code) => r(code))) };
|
||||
};
|
||||
// 1) 세션 삭제 (getSession 의 서버 멤버 재확인이 실패하면 이렇게 지운다) → 다음 확인 때 끊김
|
||||
const a = await connect(await s.login());
|
||||
for (const x of [...(s.store as any).d.sessions]) s.store.deleteSession(x.id);
|
||||
assert.equal(await a.closed, 4401);
|
||||
// 2) 로그아웃 → 바로 끊김
|
||||
const sid = await s.login();
|
||||
const b = await connect(sid);
|
||||
await fetch(s.base + '/auth/logout', { method: 'POST', headers: { cookie: sid } });
|
||||
assert.equal(await b.closed, 4401);
|
||||
} finally {
|
||||
await s.close();
|
||||
}
|
||||
});
|
||||
|
||||
test('세션: 서버 파일에는 세션 토큰 대신 해시만 남고, 예전 파일의 세션도 그대로 이어진다', async () => {
|
||||
const s = await stack();
|
||||
try {
|
||||
|
||||
@@ -2,6 +2,8 @@
|
||||
// 롤 1판(19:40 무렵) → 발로란트 바인드(패) → 발로란트 어센트(13:9 승) → 경기 후 잡담.
|
||||
// 이미지 URL 은 실제 사이트 서버 캐시 경로 형식(/game-assets/...)을 흉내 낸 /game-assets/mock/...
|
||||
|
||||
import fs from 'node:fs';
|
||||
|
||||
export const A = (p) => `/game-assets/mock/${p}`;
|
||||
|
||||
function mulberry32(a) {
|
||||
@@ -505,6 +507,79 @@ post.forEach(([u, text, status], i) => {
|
||||
addUtt({ user: u, ts, text, status, time: realLabel(ts) });
|
||||
});
|
||||
|
||||
// ── 3D 리플레이 데모 (선택) ─────────────────────────────
|
||||
// GVR_MOCK_REPLAY=<gvr-replay JSON 경로> (+ GVR_MOCK_REPLAY_MAP_FILE=<어비스 미니맵 png>) 를 주면 그 리플레이로 경기 하나를 만든다 (실제 리플레이는 저장소에 넣지 않는다).
|
||||
// 경기 기록(킬 시각)은 리플레이보다 MOCK_SYNC_OFFSET 만큼 늦게 찍어, 사이트가 그 차이를 맞추는지 본다.
|
||||
export const MOCK_SYNC_OFFSET = 1234;
|
||||
function genReplayDemo(file) {
|
||||
const r = JSON.parse(fs.readFileSync(file, 'utf8'));
|
||||
const id = 'val-replay-demo';
|
||||
const base = r.recordedAt + MOCK_SYNC_OFFSET;
|
||||
// 팀: 같은 팀끼리는 (거의) 안 죽이므로 킬 관계로 두 편을 나눈다 (실제 사이트는 경기 기록의 팀을 쓴다)
|
||||
const adj = r.players.map(() => new Set());
|
||||
for (const [, k, v] of r.kills) if (k >= 0 && v >= 0 && k !== v) (adj[k].add(v), adj[v].add(k));
|
||||
const side = new Map([[0, 0]]);
|
||||
const stack = [0];
|
||||
while (stack.length) {
|
||||
const x = stack.pop();
|
||||
for (const y of adj[x]) if (!side.has(y)) (side.set(y, 1 - side.get(x)), stack.push(y));
|
||||
}
|
||||
const allyIdx = new Set(r.players.map((_, i) => i).filter((i) => side.get(i) === 0));
|
||||
const AGK = { Wushu_PC_C: AG.jett, Hunter_PC_C: AG.sova, Thorne_PC_C: AG.sage, Wraith_PC_C: AG.omen, Killjoy_PC_C: AG.killjoy, Clay_PC_C: AG.raze, Vampire_PC_C: AG.reyna };
|
||||
let si = 0;
|
||||
let an = 0;
|
||||
let en = 0;
|
||||
const players = r.players.map((p, i) => {
|
||||
const ally = allyIdx.has(i);
|
||||
const user = ally && si < SPEAKERS.length ? SPEAKERS[si++] : null;
|
||||
const name = user ? user.name : ally ? `아군${++an}` : `상대${++en}`;
|
||||
const cls = (p.character ?? '').replace(/_PC_C$/, '');
|
||||
return { puuid: p.puuid, name, tag: 'KR1', team: ally ? 'Blue' : 'Red', ally, character: AGK[p.character] ?? { id: cls, name: cls, icon: null }, userId: user?.id, kills: 0, deaths: 0, assists: 0, score: 0, rank: null };
|
||||
});
|
||||
const ref = (i) => (i >= 0 ? { puuid: players[i].puuid, name: players[i].name, team: players[i].team, character: players[i].character, userId: players[i].userId } : null);
|
||||
const mEvents = [];
|
||||
const mUtts = [];
|
||||
const rounds = [];
|
||||
let score = { ally: 0, enemy: 0 };
|
||||
r.rounds.forEach((rd, k) => {
|
||||
const next = r.rounds[k + 1];
|
||||
const startedAt = base + (rd.combat >= 0 ? rd.combat - 30000 : rd.buy);
|
||||
const endedAt = base + (next ? (next.combat >= 0 ? next.combat - 30000 : next.buy) : r.durationMs);
|
||||
const kills = r.kills.filter(([t]) => t >= rd.buy && (!next || t < next.buy));
|
||||
const allyDead = kills.filter(([, , v]) => allyIdx.has(v)).length;
|
||||
const enemyDead = kills.filter(([, , v]) => !allyIdx.has(v)).length;
|
||||
const win = enemyDead >= allyDead;
|
||||
win ? score.ally++ : score.enemy++;
|
||||
rounds.push({ num: rd.num, startedAt, endedAt, win, result: 'Elimination', score: { ...score }, economy: {}, players: {} });
|
||||
const label = (ts) => {
|
||||
const inRound = ts - startedAt;
|
||||
return { primary: inRound < 30000 ? `R${rd.num} · 구매` : `R${rd.num} · ${fmtClock(inRound - 30000)}`, secondary: fmtClock(ts - base), real: ts };
|
||||
};
|
||||
for (const [t, ki, vi] of kills) {
|
||||
const ts = base + t;
|
||||
if (ki >= 0) players[ki].kills++;
|
||||
if (vi >= 0) players[vi].deaths++;
|
||||
mEvents.push({ kind: 'event', id: nid('ev_'), ts, game: 'valorant', matchId: id, type: 'kill', round: rd.num, data: { killer: ref(ki), victim: ref(vi), assists: [], weapon: null, location: null, ally: ki >= 0 && allyIdx.has(ki) }, time: label(ts) });
|
||||
}
|
||||
mEvents.push({ kind: 'event', id: nid('ev_'), ts: endedAt - 1, game: 'valorant', matchId: id, type: 'round_end', round: rd.num, data: { round: rd.num, win, result: 'Elimination', score: { ...score } }, time: label(endedAt - 1) });
|
||||
// 대화: 라운드마다 3~5개
|
||||
const n = irange(3, 5);
|
||||
for (let j = 0; j < n; j++) {
|
||||
const ts = startedAt + irange(5, Math.max(6, Math.floor((endedAt - startedAt) / 1000) - 3)) * 1000;
|
||||
mUtts.push(addUtt({ user: pick(SPEAKERS), ts, text: pick(VAL_LINES), game: { type: 'valorant', matchId: id, round: rd.num }, time: label(ts) }));
|
||||
}
|
||||
});
|
||||
const endedAt = base + r.durationMs;
|
||||
events.push(...mEvents);
|
||||
const T = { xMultiplier: 8.1e-5, yMultiplier: -8.1e-5, xScalarToAdd: 0.5, yScalarToAdd: 0.5 };
|
||||
const summary = {
|
||||
id, game: 'valorant', startedAt: base, endedAt, map: { id: '/Game/Maps/Infinity/Infinity', name: '어비스', image: process.env.GVR_MOCK_REPLAY_MAP_FILE ? A('replay-map.png') : null },
|
||||
mode: '경쟁전', win: score.ally > score.enemy, score, status: 'complete', participants: SPEAKERS.map((u) => u.id),
|
||||
};
|
||||
matches.push({ ...summary, players, rounds, events: mEvents, utterances: mUtts, mapTransform: { valorant: T }, replayPath: file });
|
||||
}
|
||||
if (process.env.GVR_MOCK_REPLAY) genReplayDemo(process.env.GVR_MOCK_REPLAY);
|
||||
|
||||
// ── 내보내기 ─────────────────────────────────────────
|
||||
export const db = {
|
||||
users: USERS,
|
||||
|
||||
@@ -21,7 +21,21 @@ const here = path.dirname(fileURLToPath(import.meta.url));
|
||||
const ASSET_DIR = path.resolve(here, '../../../docs/report/mock/assets');
|
||||
const ME = { id: '310482915522101248', name: '하늘', avatar: null };
|
||||
|
||||
let m0;
|
||||
/** 표시 이름: 목에서는 유저 목록 이름도 같이 바꾼다 (실제로는 게임 PC 앱이 받아서 바꿈) */
|
||||
function setName(id, n) {
|
||||
const u = db.users.find((x) => x.id === id);
|
||||
if (u) u._orig ??= u.name;
|
||||
if (n) state.names[id] = n;
|
||||
else delete state.names[id];
|
||||
if (u) u.name = n || u._orig;
|
||||
broadcast({ type: 'users.updated', data: db.users });
|
||||
}
|
||||
const state = {
|
||||
names: {},
|
||||
regs: [
|
||||
{ id: ME.id, name: ME.name, avatar: null, role: 'superadmin', fixed: true, addedBy: null, addedAt: null, lastSeenAt: Date.now() - 3600000, lastVersion: '1.5.0' },
|
||||
],
|
||||
device: { registered: true, online: process.env.MOCK_OFFLINE !== '1', name: '하늘의 게임 PC', lastSeen: Date.now(), version: '1.0.0' },
|
||||
live: process.env.MOCK_LIVE !== '0',
|
||||
liveInterval: Number(process.env.MOCK_LIVE_INTERVAL ?? 15000),
|
||||
@@ -181,7 +195,24 @@ async function handle(req, res) {
|
||||
return json(res, 200, { user: u, utterance: it.id });
|
||||
}
|
||||
|
||||
// 맵 3D (GVR_MOCK_MAPS3D=<사이트 서버 data/maps3d 와 같은 구조의 폴더>: index.json + <dir>/<code>.glb.gz)
|
||||
if (p === '/site/maps3d' || p.startsWith('/site/maps3d/')) {
|
||||
const root = process.env.GVR_MOCK_MAPS3D;
|
||||
if (!root) return p === '/site/maps3d' ? json(res, 200, { version: null, dir: null, maps: {} }) : json(res, 404, { error: 'not_found' });
|
||||
if (p === '/site/maps3d') return json(res, 200, JSON.parse(fs.readFileSync(path.join(root, 'index.json'), 'utf8')));
|
||||
const [dir, file] = p.slice('/site/maps3d/'.length).split('/').map(decodeURIComponent);
|
||||
const f = path.join(root, dir ?? '', (file ?? '') + '.gz');
|
||||
if (!/^[\w.-]+$/.test(dir ?? '') || !/^[\w.-]+\.glb$/.test(file ?? '') || !fs.existsSync(f)) return json(res, 404, { error: 'not_found' });
|
||||
res.writeHead(200, { 'content-type': 'model/gltf-binary', 'content-encoding': 'gzip', 'content-length': fs.statSync(f).size });
|
||||
return fs.createReadStream(f).pipe(res);
|
||||
}
|
||||
|
||||
// 게임 이미지 (목: docs/report/mock/assets)
|
||||
// 3D 리플레이 데모 바닥 미니맵 (GVR_MOCK_REPLAY_MAP_FILE, 데이터 생성은 data.mjs genReplayDemo)
|
||||
if (p === '/game-assets/mock/replay-map.png' && process.env.GVR_MOCK_REPLAY_MAP_FILE) {
|
||||
res.writeHead(200, { 'content-type': 'image/png' });
|
||||
return fs.createReadStream(process.env.GVR_MOCK_REPLAY_MAP_FILE).pipe(res);
|
||||
}
|
||||
if (p.startsWith('/game-assets/mock/')) {
|
||||
const f = path.resolve(ASSET_DIR, decodeURIComponent(p.slice('/game-assets/mock/'.length)));
|
||||
if (!f.startsWith(ASSET_DIR) || !fs.existsSync(f)) return json(res, 404, { error: 'not_found' });
|
||||
@@ -224,7 +255,35 @@ async function handle(req, res) {
|
||||
if (p === '/auth/me') {
|
||||
if (!sess) return json(res, 401, { error: 'unauthorized' });
|
||||
if (sess === 'nm') return json(res, 403, { error: 'not_member' });
|
||||
return json(res, 200, { user: ME, isOwner: true, canViewLogs: true });
|
||||
return json(res, 200, { user: { ...ME, name: state.names[ME.id] ?? ME.name }, isOwner: true, canViewLogs: true, role: 'superadmin' });
|
||||
}
|
||||
// 내 정보 · 관리 화면 (v1.6.0)
|
||||
if (p === '/site/profile') return json(res, 200, { user: { ...ME, name: state.names[ME.id] ?? ME.name }, customName: state.names[ME.id] ?? null, role: 'superadmin' });
|
||||
if (p === '/site/profile/name' && req.method === 'PUT') {
|
||||
const b = JSON.parse((await readBody(req)) || '{}');
|
||||
const n = String(b.name ?? '').trim();
|
||||
if (n && Object.entries(state.names).some(([id, x]) => id !== ME.id && x === n)) return json(res, 400, { error: 'bad_name', message: '다른 사람이 이미 쓰는 이름입니다' });
|
||||
setName(ME.id, n);
|
||||
return json(res, 200, { user: { ...ME, name: state.names[ME.id] ?? ME.name }, customName: state.names[ME.id] ?? null });
|
||||
}
|
||||
if (p === '/site/admin/overview') return json(res, 200, { device: { ...deviceStatus(), guildId: '1200000000000000000' }, latest: { version: '1.6.0', url: 'https://git.tkrmagid.kr/tkrmagid/game_voice_recorder/releases/tag/v1.6.0', publishedAt: null }, role: 'superadmin', serverVersion: '1.0.0' });
|
||||
if (p === '/site/admin/users' && req.method === 'GET') return json(res, 200, { users: state.regs, names: state.names });
|
||||
if (p === '/site/admin/names' && req.method === 'PUT') {
|
||||
const b = JSON.parse((await readBody(req)) || '{}');
|
||||
setName(String(b.id), String(b.name ?? '').trim());
|
||||
return json(res, 200, { names: state.names });
|
||||
}
|
||||
if (p === '/site/admin/users' && req.method === 'POST') {
|
||||
const b = JSON.parse((await readBody(req)) || '{}');
|
||||
const u = db.users.find((x) => x.id === b.id);
|
||||
state.regs.push({ id: b.id, name: u?.name ?? b.id, avatar: null, role: b.role, fixed: false, addedBy: ME.id, addedAt: Date.now(), lastSeenAt: null, lastVersion: null });
|
||||
return json(res, 200, { users: state.regs });
|
||||
}
|
||||
if ((m0 = p.match(/^\/site\/admin\/users\/(\d+)$/))) {
|
||||
const b = req.method === 'PATCH' ? JSON.parse((await readBody(req)) || '{}') : {};
|
||||
if (req.method === 'PATCH') state.regs = state.regs.map((r) => (r.id === m0[1] ? { ...r, role: b.role } : r));
|
||||
if (req.method === 'DELETE') state.regs = state.regs.filter((r) => r.id !== m0[1]);
|
||||
return json(res, 200, { users: state.regs });
|
||||
}
|
||||
|
||||
if (p.startsWith('/api/')) {
|
||||
@@ -256,6 +315,16 @@ async function handle(req, res) {
|
||||
return json(res, 200, db.users);
|
||||
}
|
||||
let m;
|
||||
if ((m = p.match(/^\/api\/users\/([^/]+)$/)) && req.method === 'PATCH') {
|
||||
const u = db.users.find((x) => x.id === decodeURIComponent(m[1]));
|
||||
if (!u) return json(res, 404, { error: 'not_found', message: '이 PC 기록에 없는 유저입니다' });
|
||||
const b = JSON.parse((await readBody(req)) || '{}');
|
||||
if (b.color) u.color = b.color;
|
||||
if (b.excluded !== undefined) u.excluded = !!b.excluded;
|
||||
if (b.riotIds) u.riot = b.riotIds.map((r) => ({ puuid: `riotid:${r}`, riotId: r }));
|
||||
broadcast({ type: 'users.updated', data: db.users });
|
||||
return json(res, 200, { user: u, taken: [] });
|
||||
}
|
||||
if ((m = p.match(/^\/api\/users\/([^/]+)$/))) {
|
||||
const prof = userProfile(decodeURIComponent(m[1]));
|
||||
return prof ? json(res, 200, prof) : json(res, 404, { error: 'not_found' });
|
||||
@@ -270,7 +339,16 @@ async function handle(req, res) {
|
||||
}
|
||||
if ((m = p.match(/^\/api\/matches\/([^/]+)$/))) {
|
||||
const mt = db.matches.find((x) => x.id === decodeURIComponent(m[1]));
|
||||
return mt ? json(res, 200, mt) : json(res, 404, { error: 'not_found' });
|
||||
if (!mt) return json(res, 404, { error: 'not_found' });
|
||||
const { replayPath, ...rest } = mt;
|
||||
return json(res, 200, rest);
|
||||
}
|
||||
if ((m = p.match(/^\/api\/matches\/([^/]+)\/replay$/))) {
|
||||
const mt = db.matches.find((x) => x.id === decodeURIComponent(m[1]));
|
||||
if (!mt) return json(res, 404, { error: 'not_found' });
|
||||
if (!mt.replayPath) return json(res, 404, { error: 'replay_not_found' });
|
||||
res.writeHead(200, { 'content-type': 'application/json' });
|
||||
return fs.createReadStream(mt.replayPath).pipe(res);
|
||||
}
|
||||
if ((m = p.match(/^\/api\/utterances\/([^/]+)$/)) && req.method === 'PATCH') {
|
||||
const it = db.utterances.find((u) => u.id === decodeURIComponent(m[1]));
|
||||
|
||||
64
site/web/package-lock.json
generated
64
site/web/package-lock.json
generated
@@ -12,12 +12,14 @@
|
||||
"react": "^19.3.0",
|
||||
"react-dom": "^19.3.0",
|
||||
"react-router": "^7.18.4",
|
||||
"three": "^0.180.0",
|
||||
"wavesurfer.js": "^7.12.12"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "^22.20.5",
|
||||
"@types/react": "^19.3.0",
|
||||
"@types/react-dom": "^19.2.0",
|
||||
"@types/three": "^0.180.0",
|
||||
"@vitejs/plugin-react": "^5.2.0",
|
||||
"typescript": "~5.9.3",
|
||||
"vite": "^7.3.7",
|
||||
@@ -287,6 +289,12 @@
|
||||
"node": ">=6.9.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@dimforge/rapier3d-compat": {
|
||||
"version": "0.12.0",
|
||||
"resolved": "https://registry.npmjs.org/@dimforge/rapier3d-compat/-/rapier3d-compat-0.12.0.tgz",
|
||||
"integrity": "sha512-uekIGetywIgopfD97oDL5PfeezkFpNhwlzlaEYNOA0N6ghdsOvh/HYjSMek5Q2O1PYvRSDFcqFVJl4r4ZBwOow==",
|
||||
"dev": true
|
||||
},
|
||||
"node_modules/@esbuild/aix-ppc64": {
|
||||
"version": "0.28.2",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.2.tgz",
|
||||
@@ -1095,6 +1103,12 @@
|
||||
"win32"
|
||||
]
|
||||
},
|
||||
"node_modules/@tweenjs/tween.js": {
|
||||
"version": "23.1.3",
|
||||
"resolved": "https://registry.npmjs.org/@tweenjs/tween.js/-/tween.js-23.1.3.tgz",
|
||||
"integrity": "sha512-vJmvvwFxYuGnF2axRtPYocag6Clbb5YS7kLL+SO/TeVFzHqDIWrNKYtcsPMibjDx9O+bu+psAy9NKfWklassUA==",
|
||||
"dev": true
|
||||
},
|
||||
"node_modules/@types/babel__core": {
|
||||
"version": "7.20.5",
|
||||
"resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
|
||||
@@ -1169,6 +1183,33 @@
|
||||
"@types/react": "^19.3.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@types/stats.js": {
|
||||
"version": "0.17.4",
|
||||
"resolved": "https://registry.npmjs.org/@types/stats.js/-/stats.js-0.17.4.tgz",
|
||||
"integrity": "sha512-jIBvWWShCvlBqBNIZt0KAshWpvSjhkwkEu4ZUcASoAvhmrgAUI2t1dXrjSL4xXVLB4FznPrIsX3nKXFl/Dt4vA==",
|
||||
"dev": true
|
||||
},
|
||||
"node_modules/@types/three": {
|
||||
"version": "0.180.0",
|
||||
"resolved": "https://registry.npmjs.org/@types/three/-/three-0.180.0.tgz",
|
||||
"integrity": "sha512-ykFtgCqNnY0IPvDro7h+9ZeLY+qjgUWv+qEvUt84grhenO60Hqd4hScHE7VTB9nOQ/3QM8lkbNE+4vKjEpUxKg==",
|
||||
"dev": true,
|
||||
"dependencies": {
|
||||
"@dimforge/rapier3d-compat": "~0.12.0",
|
||||
"@tweenjs/tween.js": "~23.1.3",
|
||||
"@types/stats.js": "*",
|
||||
"@types/webxr": "*",
|
||||
"@webgpu/types": "*",
|
||||
"fflate": "~0.8.2",
|
||||
"meshoptimizer": "~0.22.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@types/webxr": {
|
||||
"version": "0.5.24",
|
||||
"resolved": "https://registry.npmjs.org/@types/webxr/-/webxr-0.5.24.tgz",
|
||||
"integrity": "sha512-h8fgEd/DpoS9CBrjEQXR+dIDraopAEfu4wYVNY2tEPwk60stPWhvZMf4Foo5FakuQ7HFZoa8WceaWFervK2Ovg==",
|
||||
"dev": true
|
||||
},
|
||||
"node_modules/@vitejs/plugin-react": {
|
||||
"version": "5.2.0",
|
||||
"resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-5.2.0.tgz",
|
||||
@@ -1189,6 +1230,12 @@
|
||||
"vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@webgpu/types": {
|
||||
"version": "0.1.74",
|
||||
"resolved": "https://registry.npmjs.org/@webgpu/types/-/types-0.1.74.tgz",
|
||||
"integrity": "sha512-lgiI4hbuLcI9unnm2cL/tvCaQU45dp0xcLWJh5uB/9MBGvIA4F8XIk7nSiBeg+K4xWGYwgZKn80LmERI5CxoTA==",
|
||||
"dev": true
|
||||
},
|
||||
"node_modules/baseline-browser-mapping": {
|
||||
"version": "2.11.28",
|
||||
"resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.28.tgz",
|
||||
@@ -1368,6 +1415,12 @@
|
||||
}
|
||||
}
|
||||
},
|
||||
"node_modules/fflate": {
|
||||
"version": "0.8.3",
|
||||
"resolved": "https://registry.npmjs.org/fflate/-/fflate-0.8.3.tgz",
|
||||
"integrity": "sha512-tbZNuJrLwGUp3zshBtdy4W+ORxZuIh8a5ilyIEQDC5rY1f3U20JMry0Ll3WBzU58EZKsEuJFXhb5gwv8CsPvgA==",
|
||||
"dev": true
|
||||
},
|
||||
"node_modules/framer-motion": {
|
||||
"version": "12.43.0",
|
||||
"resolved": "https://registry.npmjs.org/framer-motion/-/framer-motion-12.43.0.tgz",
|
||||
@@ -1456,6 +1509,12 @@
|
||||
"yallist": "^3.0.2"
|
||||
}
|
||||
},
|
||||
"node_modules/meshoptimizer": {
|
||||
"version": "0.22.0",
|
||||
"resolved": "https://registry.npmjs.org/meshoptimizer/-/meshoptimizer-0.22.0.tgz",
|
||||
"integrity": "sha512-IebiK79sqIy+E4EgOr+CAw+Ke8hAspXKzBd0JdgEmPHiAwmvEj2S4h1rfvo+o/BnfEYd/jAOg5IeeIjzlzSnDg==",
|
||||
"dev": true
|
||||
},
|
||||
"node_modules/motion-dom": {
|
||||
"version": "12.43.0",
|
||||
"resolved": "https://registry.npmjs.org/motion-dom/-/motion-dom-12.43.0.tgz",
|
||||
@@ -1670,6 +1729,11 @@
|
||||
"node": ">=0.10.0"
|
||||
}
|
||||
},
|
||||
"node_modules/three": {
|
||||
"version": "0.180.0",
|
||||
"resolved": "https://registry.npmjs.org/three/-/three-0.180.0.tgz",
|
||||
"integrity": "sha512-o+qycAMZrh+TsE01GqWUxUIKR1AL0S8pq7zDkYOQw8GqfX8b8VoCKYUoHbhiX5j+7hr8XsuHDVU6+gkQJQKg9w=="
|
||||
},
|
||||
"node_modules/tinyglobby": {
|
||||
"version": "0.2.17",
|
||||
"resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
|
||||
|
||||
@@ -16,12 +16,14 @@
|
||||
"react": "^19.3.0",
|
||||
"react-dom": "^19.3.0",
|
||||
"react-router": "^7.18.4",
|
||||
"three": "^0.180.0",
|
||||
"wavesurfer.js": "^7.12.12"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "^22.20.5",
|
||||
"@types/react": "^19.3.0",
|
||||
"@types/react-dom": "^19.2.0",
|
||||
"@types/three": "^0.180.0",
|
||||
"@vitejs/plugin-react": "^5.2.0",
|
||||
"typescript": "~5.9.3",
|
||||
"vite": "^7.3.7",
|
||||
|
||||
@@ -18,6 +18,7 @@ import { CulpritPage } from './pages/CulpritPage';
|
||||
import { MatchesPage, UserPage, UsersPage } from './pages/UserPages';
|
||||
import { LogsPage } from './pages/LogsPage';
|
||||
import { RecordsPage } from './pages/RecordsPage';
|
||||
import { AdminPage } from './pages/AdminPage';
|
||||
import { installErrorReporting } from './lib/report';
|
||||
import { useLocation } from 'react-router';
|
||||
|
||||
@@ -75,6 +76,7 @@ function Shell() {
|
||||
<Route path="/dictionary" element={<DictionaryPage />} />
|
||||
<Route path="/culprit" element={<CulpritPage />} />
|
||||
<Route path="/culprit/:id" element={<CulpritPage />} />
|
||||
<Route path="/admin" element={<AdminPage />} />
|
||||
<Route path="*" element={<Navigate to="/" replace />} />
|
||||
</Routes>
|
||||
</div>
|
||||
|
||||
@@ -6,7 +6,8 @@ import { settings, useSettings, type SfxKind } from '../store/settings';
|
||||
import { sfx, SFX_LABEL } from '../lib/sfx';
|
||||
import { resumeAudio } from '../lib/audio';
|
||||
import { Avatar, Brand } from './common';
|
||||
import { IGear, ILogout, ISearch } from './Icons';
|
||||
import { IGear, ISearch } from './Icons';
|
||||
import { ProfilePopover } from './UserEdit';
|
||||
import { GAME_NAME, liveGameLine, liveGameRows } from '@gvr/shared';
|
||||
|
||||
function SettingsPopover({ onClose }: { onClose: () => void }) {
|
||||
@@ -165,10 +166,11 @@ export function SearchBox() {
|
||||
}
|
||||
|
||||
export function Header() {
|
||||
const { auth, logout } = useAuth();
|
||||
const { overview } = useData();
|
||||
const { auth } = useAuth();
|
||||
const { overview, userById } = useData();
|
||||
const { device, locked, conn } = useStatus();
|
||||
const [open, setOpen] = useState(false);
|
||||
const [profile, setProfile] = useState(false);
|
||||
const me = auth.status === 'ok' ? auth.me.user : null;
|
||||
const rec = overview?.recording;
|
||||
const nav = [
|
||||
@@ -178,6 +180,7 @@ export function Header() {
|
||||
['/users', '유저'],
|
||||
['/dictionary', '단어사전'],
|
||||
['/culprit', '🔍 범인찾기'],
|
||||
...(auth.status === 'ok' && auth.me.canViewLogs ? ([['/admin', '🛡️ 관리']] as const) : []),
|
||||
] as const;
|
||||
return (
|
||||
<header className="topbar">
|
||||
@@ -211,14 +214,13 @@ export function Header() {
|
||||
</button>
|
||||
<AnimatePresence>{open && <SettingsPopover onClose={() => setOpen(false)} />}</AnimatePresence>
|
||||
{me && (
|
||||
<div className="me">
|
||||
<Avatar name={me.name} src={me.avatar} color="#5865f2" size={26} />
|
||||
<button className="me me-btn" onClick={() => setProfile((o) => !o)} aria-expanded={profile} title="내 정보 · 표시 이름 · 색 · 로그아웃">
|
||||
<Avatar name={me.name} src={me.avatar} color={userById(me.id)?.color ?? '#5865f2'} size={26} />
|
||||
<span className="me-nm">{me.name}</span>
|
||||
<button className="icon-btn" onClick={logout} title="로그아웃" aria-label="로그아웃">
|
||||
<ILogout width={16} height={16} />
|
||||
</button>
|
||||
</div>
|
||||
<span className="me-caret">▾</span>
|
||||
</button>
|
||||
)}
|
||||
<AnimatePresence>{profile && <ProfilePopover onClose={() => setProfile(false)} />}</AnimatePresence>
|
||||
</div>
|
||||
</header>
|
||||
);
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
import { useEffect, useState } from 'react';
|
||||
import { motion } from 'framer-motion';
|
||||
import { IDiscord } from './Icons';
|
||||
|
||||
@@ -31,6 +32,15 @@ function FakeBackdrop() {
|
||||
}
|
||||
|
||||
export function LoginPage({ notMember = false, error }: { notMember?: boolean; error?: string }) {
|
||||
// 들어올 수 있는 서버 = 게임 PC 앱에서 녹음할 서버로 고른 곳 (겜녹이 봇이 있는 서버)
|
||||
const [guild, setGuild] = useState<string | null>(null);
|
||||
useEffect(() => {
|
||||
fetch('/auth/guild')
|
||||
.then((r) => (r.ok ? r.json() : null))
|
||||
.then((d: { name?: string | null } | null) => setGuild(d?.name ?? null))
|
||||
.catch(() => undefined);
|
||||
}, []);
|
||||
const g = guild ? `(${guild})` : '';
|
||||
return (
|
||||
<div className="login">
|
||||
<FakeBackdrop />
|
||||
@@ -43,9 +53,9 @@ export function LoginPage({ notMember = false, error }: { notMember?: boolean; e
|
||||
<div className="in">
|
||||
{notMember ? (
|
||||
<>
|
||||
<div className="t h">들어올 수 없는 계정입니다</div>
|
||||
<div className="nm-warn">M&L 서버 멤버만 들어올 수 있습니다</div>
|
||||
<div className="d">겜녹이 봇이 있는 디스코드 서버(M&L)에 참여한 계정으로 다시 로그인해 주세요.</div>
|
||||
<div className="t h">로그인할 수 없습니다</div>
|
||||
<div className="nm-warn">봇과 다른 서버에 있는 계정입니다</div>
|
||||
<div className="d">겜녹이 봇이 있는 디스코드 서버{g}에 참여한 계정만 들어올 수 있습니다. 그 서버에 참여한 계정으로 다시 로그인해 주세요.</div>
|
||||
<a className="dc" href="/auth/discord">
|
||||
<IDiscord />
|
||||
다른 계정으로 로그인
|
||||
@@ -56,7 +66,7 @@ export function LoginPage({ notMember = false, error }: { notMember?: boolean; e
|
||||
<div className="t h">디스코드 계정으로 로그인</div>
|
||||
{error && <div className="nm-warn">{error}</div>}
|
||||
<div className="d">
|
||||
겜녹이 봇이 있는 디스코드 서버(M&L)의 멤버만 들어올 수 있어요.
|
||||
겜녹이 봇이 있는 디스코드 서버{g}의 멤버만 들어올 수 있어요.
|
||||
<br />
|
||||
로그인하면 녹음된 대화와 경기 기록을 볼 수 있습니다.
|
||||
</div>
|
||||
|
||||
88
site/web/src/components/ReplayPanel.tsx
Normal file
88
site/web/src/components/ReplayPanel.tsx
Normal file
@@ -0,0 +1,88 @@
|
||||
import { lazy, Suspense, useEffect, useMemo, useState } from 'react';
|
||||
import type { MatchDetail } from '@gvr/shared';
|
||||
import { api, ApiError } from '../lib/api';
|
||||
import { computeSync, type ReplayFile } from '../lib/replay';
|
||||
import { reportClient } from '../lib/report';
|
||||
import { Panel, Spinner } from './common';
|
||||
|
||||
// three.js 는 크므로 3D 리플레이를 열 때만 받는다
|
||||
const ReplayViewer = lazy(() => import('./ReplayViewer'));
|
||||
|
||||
/** 경기 화면의 "3D 리플레이" 칸. 열면 게임 PC 에서 리플레이 데이터를 받아 온다 */
|
||||
export function ReplayPanel({ m }: { m: MatchDetail }) {
|
||||
const [open, setOpen] = useState(false);
|
||||
const [replay, setReplay] = useState<ReplayFile | null>(null);
|
||||
const [err, setErr] = useState<unknown>(null);
|
||||
const [converting, setConverting] = useState(false);
|
||||
useEffect(() => {
|
||||
if (!open || replay) return;
|
||||
let alive = true;
|
||||
let timer: ReturnType<typeof setTimeout> | undefined;
|
||||
setErr(null);
|
||||
// 처음 열면 게임 PC 가 리플레이를 변환한다 (보통 10초 안팎). 변환 중(202)이면 3초 뒤 다시 묻는다 (5분까지)
|
||||
const ask = (tries: number) =>
|
||||
api
|
||||
.replay(m.id)
|
||||
.then((r) => {
|
||||
if (!alive) return;
|
||||
if ('status' in r && r.status === 'converting') {
|
||||
setConverting(true);
|
||||
if (tries >= 100) setErr(new Error('게임 PC 가 리플레이 변환을 끝내지 못했습니다'));
|
||||
else timer = setTimeout(() => ask(tries + 1), 3000);
|
||||
return;
|
||||
}
|
||||
setConverting(false);
|
||||
setReplay(r as ReplayFile);
|
||||
})
|
||||
.catch((e) => {
|
||||
if (!alive) return;
|
||||
setConverting(false);
|
||||
setErr(e);
|
||||
// 변환 실패 이유는 게임 PC 에만 남으므로 사이트 로그에도 남긴다
|
||||
if (e instanceof ApiError && e.status === 422) reportClient('warn', `리플레이 변환 실패 ${m.id}: ${e.detail ?? e.code}`);
|
||||
});
|
||||
void ask(0);
|
||||
return () => {
|
||||
alive = false;
|
||||
if (timer) clearTimeout(timer);
|
||||
};
|
||||
}, [open, m.id, replay]);
|
||||
const sync = useMemo(() => (replay ? computeSync(m, replay) : null), [m, replay]);
|
||||
// replay_not_found: 앱이 리플레이를 못 찾음. 다른 404: 이 앱 버전에는 리플레이 기능이 아직 없음
|
||||
const missing = err instanceof ApiError && err.status === 404 && err.code === 'replay_not_found';
|
||||
const appTooOld = err instanceof ApiError && err.status === 404 && err.code === 'Not Found'; // Fastify 기본 404 (경로 없음)
|
||||
const failed = err instanceof ApiError && err.status === 422 && err.code === 'replay_failed';
|
||||
return (
|
||||
<Panel
|
||||
className={`replay-panel${open ? ' open' : ''}`}
|
||||
title="3D 리플레이 · 대화 동기화"
|
||||
right={
|
||||
<button className="mini-btn" onClick={() => setOpen((o) => !o)} aria-expanded={open}>
|
||||
{open ? '닫기' : '열기'}
|
||||
</button>
|
||||
}
|
||||
>
|
||||
{!open ? (
|
||||
<div className="dim small">
|
||||
발로란트에서 이 경기 리플레이를 내려받으면 선수 10명의 움직임을 3D로 보면서 그때 나눈 대화를 같이 들을 수 있습니다.
|
||||
</div>
|
||||
) : missing ? (
|
||||
<div className="dim small">
|
||||
이 경기 리플레이가 아직 없습니다. 발로란트 경력 탭에서 이 경기의 리플레이를 내려받으면 게임 PC 앱이 찾아서 변환합니다 (몇 초 걸림).
|
||||
</div>
|
||||
) : appTooOld ? (
|
||||
<div className="dim small">지금 게임 PC 앱 버전은 아직 리플레이를 보내지 않습니다. 리플레이 자동 변환이 들어간 앱으로 업데이트하면 볼 수 있습니다.</div>
|
||||
) : failed ? (
|
||||
<div className="dim small">게임 PC 가 이 경기 리플레이를 변환하지 못했습니다. 발로란트 패치로 리플레이 형식이 바뀌었을 수 있습니다. ({(err as ApiError).detail ?? '이유 모름'})</div>
|
||||
) : err ? (
|
||||
<div className="dim small">리플레이를 불러오지 못했습니다: {err instanceof Error ? err.message : String(err)}</div>
|
||||
) : !replay || !sync ? (
|
||||
<Spinner label={converting ? '게임 PC 가 리플레이를 변환하는 중 (처음 한 번, 10초 안팎)' : '리플레이 불러오는 중'} />
|
||||
) : (
|
||||
<Suspense fallback={<Spinner label="3D 화면 준비 중" />}>
|
||||
<ReplayViewer m={m} replay={replay} sync={sync} />
|
||||
</Suspense>
|
||||
)}
|
||||
</Panel>
|
||||
);
|
||||
}
|
||||
600
site/web/src/components/ReplayViewer.tsx
Normal file
600
site/web/src/components/ReplayViewer.tsx
Normal file
@@ -0,0 +1,600 @@
|
||||
import { useEffect, useMemo, useRef, useState } from 'react';
|
||||
import * as THREE from 'three';
|
||||
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
|
||||
import type { MatchDetail, MatchPlayer } from '@gvr/shared';
|
||||
import { player } from '../store/player';
|
||||
import { settings, useSettings } from '../store/settings';
|
||||
import { useData } from '../store/app';
|
||||
import { fmtClock } from '../lib/format';
|
||||
import { isDead, roundAt, samplePlayer, type ReplayFile, type ReplaySync } from '../lib/replay';
|
||||
import { findMap3d, loadMap3d, mapMaterial, worldMatrix } from '../lib/map3d';
|
||||
|
||||
/**
|
||||
* 3D 리플레이 (발로란트 .vrf → tools/replay-extract → gvr-replay JSON).
|
||||
* 맵은 게임 파일에서 뽑은 3D 모양(tools/map-extract, 사이트 서버 /site/maps3d)을 쓰고, 없으면 미니맵 바닥만 깐다.
|
||||
* 위에서 내려다볼 수 있게 천장 높이 위는 잘라 낸다 (자동: 고른 선수 · 가장 높은 선수 머리 위).
|
||||
* 시계는 플레이어 "현장 모드"(대화를 실제 시각대로 겹쳐 재생)와 같은 값을 쓴다:
|
||||
* 기록 시각 ts = recordedAt + t + sync.offset
|
||||
* 그래서 재생 · 멈춤 · 시간 옮기기 · 배속이 대화와 같이 움직인다.
|
||||
*/
|
||||
export const REPLAY_SCENE_LABEL = '3D 리플레이';
|
||||
const S = 100; // 미니맵 한 변 (3D 단위)
|
||||
const VEX = 1; // 높이 배율 (1 = 실제 비율)
|
||||
const ALLY = 0x3fb6ff;
|
||||
const ENEMY = 0xff4d5e;
|
||||
const RATES = [0.5, 1, 1.5, 2];
|
||||
/** 자동 천장: 선수(몸 중심) 위로 이만큼(cm) 남기고 자른다 */
|
||||
const CEIL_ABOVE = 380;
|
||||
|
||||
type MapState = { state: 'none' | 'loading' | 'ready' | 'error'; progress?: number };
|
||||
/** 천장 자르기: 자동 · 끔 · 직접(가장 낮은 층에서 cm) */
|
||||
type Ceil = { mode: 'auto' } | { mode: 'off' } | { mode: 'manual'; cm: number };
|
||||
|
||||
type T4 = { xMultiplier: number; yMultiplier: number; xScalarToAdd: number; yScalarToAdd: number };
|
||||
|
||||
interface Props {
|
||||
m: MatchDetail;
|
||||
replay: ReplayFile;
|
||||
sync: ReplaySync;
|
||||
}
|
||||
|
||||
function labelSprite(text: string, color: string) {
|
||||
const c = document.createElement('canvas');
|
||||
const ctx = c.getContext('2d')!;
|
||||
const font = '600 44px Pretendard, "Noto Sans KR", sans-serif';
|
||||
ctx.font = font;
|
||||
const w = Math.ceil(ctx.measureText(text).width) + 36;
|
||||
c.width = w;
|
||||
c.height = 68;
|
||||
ctx.font = font;
|
||||
ctx.fillStyle = 'rgba(8,14,20,0.78)';
|
||||
ctx.beginPath();
|
||||
ctx.roundRect(0, 0, w, 68, 18);
|
||||
ctx.fill();
|
||||
ctx.fillStyle = color;
|
||||
ctx.textBaseline = 'middle';
|
||||
ctx.fillText(text, 18, 36);
|
||||
const tex = new THREE.CanvasTexture(c);
|
||||
tex.colorSpace = THREE.SRGBColorSpace;
|
||||
const sp = new THREE.Sprite(new THREE.SpriteMaterial({ map: tex, depthTest: false, transparent: true }));
|
||||
sp.scale.set((w / 68) * 2.2, 2.2, 1);
|
||||
sp.renderOrder = 10;
|
||||
return sp;
|
||||
}
|
||||
|
||||
interface PlayerView {
|
||||
idx: number;
|
||||
info: MatchPlayer | null;
|
||||
name: string;
|
||||
ally: boolean;
|
||||
group: THREE.Group;
|
||||
body: THREE.Mesh;
|
||||
cone: THREE.Mesh;
|
||||
label: THREE.Sprite;
|
||||
voice: THREE.Sprite;
|
||||
ring: THREE.Mesh;
|
||||
/** 바닥(미니맵)까지 내린 선과 그림자 점: 높이가 있어도 평면 위치가 보이게 */
|
||||
drop: THREE.Line;
|
||||
shadow: THREE.Mesh;
|
||||
}
|
||||
|
||||
export default function ReplayViewer({ m, replay, sync }: Props) {
|
||||
const mountRef = useRef<HTMLDivElement>(null);
|
||||
const cfg = useSettings();
|
||||
const { userById } = useData();
|
||||
const base = replay.recordedAt + sync.offset;
|
||||
const firstCombat = replay.rounds.find((r) => r.combat >= 0)?.combat ?? 0;
|
||||
const localT = useRef(firstCombat);
|
||||
const [ui, setUi] = useState({ t: firstCombat, playing: false });
|
||||
const [sel, setSel] = useState<number | null>(null);
|
||||
const [follow, setFollow] = useState(false);
|
||||
const selRef = useRef(sel);
|
||||
const followRef = useRef(follow);
|
||||
selRef.current = sel;
|
||||
followRef.current = follow;
|
||||
const resetCam = useRef<() => void>(() => {});
|
||||
const [map3d, setMap3d] = useState<MapState>({ state: 'none' });
|
||||
const [ceil, setCeil] = useState<Ceil>({ mode: 'auto' });
|
||||
const ceilRef = useRef(ceil);
|
||||
ceilRef.current = ceil;
|
||||
/** 지금 자르는 높이 (가장 낮은 층에서 cm, 화면 표시용) */
|
||||
const [ceilNow, setCeilNow] = useState<number | null>(null);
|
||||
|
||||
// 바닥(미니맵) 높이: 선수 높이의 하위 5% (떨어져 죽은 기록은 뺀다)
|
||||
const zBase = useMemo(() => {
|
||||
const zs: number[] = [];
|
||||
for (const p of replay.players) for (let i = 0; i < p.track.z.length; i += 40) if (p.track.z[i] > -1500) zs.push(p.track.z[i]);
|
||||
zs.sort((a, b) => a - b);
|
||||
return zs.length ? zs[Math.floor(zs.length * 0.05)] : 0;
|
||||
}, [replay]);
|
||||
// 선수가 간 가장 높은 곳 (천장 직접 조절 범위)
|
||||
const zTop = useMemo(() => {
|
||||
let top = zBase;
|
||||
for (const p of replay.players) for (let i = 0; i < p.track.z.length; i += 20) if (p.track.z[i] > top) top = p.track.z[i];
|
||||
return top;
|
||||
}, [replay, zBase]);
|
||||
const T = (m.mapTransform && 'valorant' in m.mapTransform ? m.mapTransform.valorant : null) as T4 | null;
|
||||
|
||||
// 리플레이 선수 ↔ 경기 기록 선수 (puuid)
|
||||
const roster = useMemo(
|
||||
() =>
|
||||
replay.players.map((p, idx) => {
|
||||
const info = m.players.find((x) => x.puuid === p.puuid) ?? null;
|
||||
return { idx, info, name: info?.name ?? p.character?.replace(/_PC_C$/, '') ?? `선수 ${idx + 1}`, ally: info?.ally ?? false };
|
||||
}),
|
||||
[m, replay],
|
||||
);
|
||||
// 디스코드 유저 → 리플레이 선수 (말하는 사람 표시)
|
||||
const playerByUser = useMemo(() => {
|
||||
const map = new Map<string, number>();
|
||||
for (const r of roster) if (r.info?.userId) map.set(r.info.userId, r.idx);
|
||||
return map;
|
||||
}, [roster]);
|
||||
|
||||
useEffect(() => {
|
||||
const mount = mountRef.current;
|
||||
if (!mount || !T) return;
|
||||
const toWorld = (x: number, y: number, z: number, zBase: number) =>
|
||||
new THREE.Vector3((y * T.xMultiplier + T.xScalarToAdd - 0.5) * S, (z - zBase) * Math.abs(T.xMultiplier) * S * VEX, (x * T.yMultiplier + T.yScalarToAdd - 0.5) * S);
|
||||
const dirOf = (yaw: number) => {
|
||||
const a = (yaw * Math.PI) / 180;
|
||||
return new THREE.Vector3(Math.sin(a) * Math.sign(T.xMultiplier), 0, Math.cos(a) * Math.sign(T.yMultiplier)).normalize();
|
||||
};
|
||||
|
||||
const renderer = new THREE.WebGLRenderer({ antialias: true, alpha: false });
|
||||
renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
|
||||
renderer.setClearColor(0x0b141c);
|
||||
renderer.outputColorSpace = THREE.SRGBColorSpace;
|
||||
mount.appendChild(renderer.domElement);
|
||||
const scene = new THREE.Scene();
|
||||
const camera = new THREE.PerspectiveCamera(45, 1, 0.5, 2000);
|
||||
const controls = new OrbitControls(camera, renderer.domElement);
|
||||
controls.enableDamping = true;
|
||||
controls.maxPolarAngle = Math.PI * 0.49;
|
||||
controls.minDistance = 8;
|
||||
controls.maxDistance = 260;
|
||||
resetCam.current = () => {
|
||||
camera.position.set(0, 122, 34);
|
||||
controls.target.set(0, 0, 0);
|
||||
controls.update();
|
||||
};
|
||||
resetCam.current();
|
||||
scene.add(new THREE.HemisphereLight(0xffffff, 0x223344, 1.6));
|
||||
const sun = new THREE.DirectionalLight(0xffffff, 1.2);
|
||||
sun.position.set(30, 80, 20);
|
||||
scene.add(sun);
|
||||
|
||||
// 바닥 미니맵
|
||||
const floorMat = new THREE.MeshBasicMaterial({ color: 0x5a6b7a, transparent: true });
|
||||
const floor = new THREE.Mesh(new THREE.PlaneGeometry(S, S), floorMat);
|
||||
floor.rotation.x = -Math.PI / 2;
|
||||
scene.add(floor);
|
||||
if (m.map.image) {
|
||||
const loader = new THREE.TextureLoader();
|
||||
loader.setCrossOrigin('anonymous');
|
||||
loader.load(m.map.image, (tex) => {
|
||||
tex.colorSpace = THREE.SRGBColorSpace;
|
||||
tex.anisotropy = renderer.capabilities.getMaxAnisotropy();
|
||||
floorMat.map = tex;
|
||||
floorMat.color.set(0xffffff);
|
||||
floorMat.needsUpdate = true;
|
||||
});
|
||||
}
|
||||
const grid = new THREE.GridHelper(S, 20, 0x1d2c3a, 0x15212c);
|
||||
grid.position.y = -0.05;
|
||||
scene.add(grid);
|
||||
|
||||
// 맵 3D 모양: 받으면 미니맵 바닥 · 선수 그림자를 숨긴다. 천장 위는 잘라 낸다
|
||||
renderer.localClippingEnabled = true;
|
||||
const hPerCm = Math.abs(T.xMultiplier) * S * VEX;
|
||||
const clip = new THREE.Plane(new THREE.Vector3(0, -1, 0), 1e6);
|
||||
let clipY = 1e6;
|
||||
let mapReady = false;
|
||||
const mapGroup = new THREE.Group();
|
||||
mapGroup.matrixAutoUpdate = false;
|
||||
mapGroup.matrix.copy(worldMatrix(T, S, zBase, VEX));
|
||||
scene.add(mapGroup);
|
||||
let disposed = false;
|
||||
setMap3d({ state: 'loading', progress: 0 });
|
||||
void findMap3d(m.map.id)
|
||||
.then((info) => {
|
||||
if (disposed) return;
|
||||
if (!info) return setMap3d({ state: 'none' });
|
||||
const mat = mapMaterial(clip, { lo: 0, hi: Math.max(8, (zTop - zBase + 600) * hPerCm) });
|
||||
return loadMap3d(info.url, mat, (p) => !disposed && setMap3d({ state: 'loading', progress: p })).then((obj) => {
|
||||
if (disposed) return;
|
||||
mapGroup.add(obj);
|
||||
mapGroup.updateMatrixWorld(true);
|
||||
mapReady = true;
|
||||
floor.visible = false;
|
||||
grid.visible = false;
|
||||
setMap3d({ state: 'ready' });
|
||||
});
|
||||
})
|
||||
.catch(() => !disposed && setMap3d({ state: 'error' }));
|
||||
|
||||
// 선수
|
||||
const views: PlayerView[] = roster.map((r) => {
|
||||
const color = r.ally ? ALLY : ENEMY;
|
||||
const group = new THREE.Group();
|
||||
const body = new THREE.Mesh(new THREE.CylinderGeometry(0.9, 0.9, 2.4, 20), new THREE.MeshStandardMaterial({ color, roughness: 0.5, transparent: true }));
|
||||
body.position.y = 1.2;
|
||||
body.userData.idx = r.idx;
|
||||
const cone = new THREE.Mesh(new THREE.ConeGeometry(0.55, 3.2, 12), new THREE.MeshStandardMaterial({ color: 0xffffff, transparent: true, opacity: 0.85 }));
|
||||
cone.geometry.rotateX(Math.PI / 2);
|
||||
cone.geometry.translate(0, 0, 2.2);
|
||||
cone.position.y = 1.9;
|
||||
const label = labelSprite(r.info?.character?.name ? `${r.name} · ${r.info.character.name}` : r.name, r.ally ? '#8fd8ff' : '#ff9aa5');
|
||||
label.position.y = 4.4;
|
||||
label.userData.idx = r.idx;
|
||||
const voice = labelSprite('🔊 말하는 중', '#ffe08a');
|
||||
voice.position.y = 6.6;
|
||||
voice.visible = false;
|
||||
const ring = new THREE.Mesh(new THREE.RingGeometry(1.4, 1.8, 32), new THREE.MeshBasicMaterial({ color: 0xffe08a, side: THREE.DoubleSide }));
|
||||
ring.rotation.x = -Math.PI / 2;
|
||||
ring.position.y = 0.05;
|
||||
ring.visible = false;
|
||||
group.add(body, cone, label, voice, ring);
|
||||
scene.add(group);
|
||||
const dropGeo = new THREE.BufferGeometry().setFromPoints([new THREE.Vector3(), new THREE.Vector3()]);
|
||||
const drop = new THREE.Line(dropGeo, new THREE.LineBasicMaterial({ color, transparent: true, opacity: 0.7 }));
|
||||
drop.frustumCulled = false;
|
||||
const shadow = new THREE.Mesh(new THREE.CircleGeometry(0.75, 20), new THREE.MeshBasicMaterial({ color, transparent: true, opacity: 0.85 }));
|
||||
shadow.rotation.x = -Math.PI / 2;
|
||||
scene.add(drop, shadow);
|
||||
return { idx: r.idx, info: r.info, name: r.name, ally: r.ally, group, body, cone, label, voice, ring, drop, shadow };
|
||||
});
|
||||
|
||||
// 선택한 선수 이동 경로 (최근 6초)
|
||||
const trailGeo = new THREE.BufferGeometry();
|
||||
trailGeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(3 * 80), 3));
|
||||
const trail = new THREE.Line(trailGeo, new THREE.LineBasicMaterial({ color: 0xffe08a }));
|
||||
trail.frustumCulled = false;
|
||||
scene.add(trail);
|
||||
|
||||
// 사격 궤적 (최근 150ms)
|
||||
const MAX_SHOTS = 48;
|
||||
const shotGeo = new THREE.BufferGeometry();
|
||||
shotGeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(MAX_SHOTS * 6), 3));
|
||||
const shots = new THREE.LineSegments(shotGeo, new THREE.LineBasicMaterial({ color: 0xfff1a8, transparent: true, opacity: 0.9 }));
|
||||
shots.frustumCulled = false;
|
||||
scene.add(shots);
|
||||
|
||||
// 킬 표시 (죽은 자리 X)
|
||||
const killGroup = new THREE.Group();
|
||||
scene.add(killGroup);
|
||||
const xGeo = new THREE.TorusGeometry(1.1, 0.22, 6, 4);
|
||||
const killMarks = replay.kills.map(([kt, ki, vi]) => {
|
||||
const v = replay.players[vi];
|
||||
const p = v ? samplePlayer(v.track, kt, 1500) : null;
|
||||
const ally = roster[vi]?.ally ?? false;
|
||||
const mk = new THREE.Mesh(xGeo, new THREE.MeshBasicMaterial({ color: ally ? ALLY : ENEMY, transparent: true }));
|
||||
mk.rotation.x = -Math.PI / 2;
|
||||
mk.rotation.z = Math.PI / 4;
|
||||
if (p) mk.position.copy(toWorld(p.x, p.y, Math.max(p.z, zBase), zBase)).add(new THREE.Vector3(0, 0.2, 0));
|
||||
mk.visible = false;
|
||||
killGroup.add(mk);
|
||||
return { t: kt, killer: ki, victim: vi, mk };
|
||||
});
|
||||
|
||||
// 스킬 · 설치물
|
||||
const objMeshes = new Map<number, THREE.Mesh>();
|
||||
const objMesh = (i: number) => {
|
||||
let mesh = objMeshes.get(i);
|
||||
if (mesh) return mesh;
|
||||
const [, , kind, x, y, z] = replay.objects[i];
|
||||
const name = replay.objectKinds[kind] ?? '';
|
||||
const smoke = /Smoke/i.test(name) && !/Projectile/.test(name);
|
||||
const spike = name === 'TimedBomb_C';
|
||||
const geo = smoke ? new THREE.SphereGeometry(3.6, 20, 14) : spike ? new THREE.OctahedronGeometry(1.2) : new THREE.SphereGeometry(0.45, 10, 8);
|
||||
const color = spike ? 0xff2d3d : smoke ? 0xb9c4cf : /Patch|Molotov|Fire/i.test(name) ? 0xff8a3d : /Trap|Wire|Tether/i.test(name) ? 0xc58bff : 0x9fffe0;
|
||||
mesh = new THREE.Mesh(geo, new THREE.MeshStandardMaterial({ color, transparent: true, opacity: smoke ? 0.38 : 0.9, depthWrite: !smoke }));
|
||||
mesh.position.copy(toWorld(x, y, z, zBase));
|
||||
if (smoke) mesh.position.y += 1.5;
|
||||
scene.add(mesh);
|
||||
objMeshes.set(i, mesh);
|
||||
return mesh;
|
||||
};
|
||||
|
||||
// 크기
|
||||
const resize = () => {
|
||||
const w = mount.clientWidth;
|
||||
const h = mount.clientHeight;
|
||||
renderer.setSize(w, h, false);
|
||||
camera.aspect = w / Math.max(1, h);
|
||||
camera.updateProjectionMatrix();
|
||||
};
|
||||
const ro = new ResizeObserver(resize);
|
||||
ro.observe(mount);
|
||||
resize();
|
||||
|
||||
// 선수 눌러서 고르기
|
||||
const ray = new THREE.Raycaster();
|
||||
const down = { x: 0, y: 0 };
|
||||
const onDown = (e: PointerEvent) => {
|
||||
down.x = e.clientX;
|
||||
down.y = e.clientY;
|
||||
};
|
||||
const onUp = (e: PointerEvent) => {
|
||||
if (Math.hypot(e.clientX - down.x, e.clientY - down.y) > 5) return; // 끌기(회전)는 고르기 아님
|
||||
const r = renderer.domElement.getBoundingClientRect();
|
||||
ray.setFromCamera(new THREE.Vector2(((e.clientX - r.left) / r.width) * 2 - 1, -((e.clientY - r.top) / r.height) * 2 + 1), camera);
|
||||
// 몸통은 위에서 보면 작아서 이름표를 눌러도 고른다
|
||||
const hit = ray.intersectObjects(views.flatMap((v) => (v.group.visible ? [v.body, v.label] : [])))[0];
|
||||
setSel(hit ? (hit.object.userData.idx as number) : null);
|
||||
};
|
||||
renderer.domElement.addEventListener('pointerdown', onDown);
|
||||
renderer.domElement.addEventListener('pointerup', onUp);
|
||||
|
||||
let raf = 0;
|
||||
let lastUi = 0;
|
||||
const tmp = new THREE.Vector3();
|
||||
const frame = (now: number) => {
|
||||
raf = requestAnimationFrame(frame);
|
||||
const ps = player.state;
|
||||
const inScene = ps.mode === 'scene' && ps.scene?.label === REPLAY_SCENE_LABEL && ps.sceneTs != null;
|
||||
const t = inScene ? ps.sceneTs! - base : localT.current;
|
||||
if (!inScene) localT.current = t;
|
||||
const ts = base + t;
|
||||
// 지금 말하는 사람
|
||||
const speaking = new Set<number>();
|
||||
for (const u of m.utterances) if (u.ts <= ts && ts <= u.endTs && !u.noise) {
|
||||
const i = playerByUser.get(u.userId);
|
||||
if (i != null) speaking.add(i);
|
||||
}
|
||||
const selIdx = selRef.current;
|
||||
for (const v of views) {
|
||||
const tr = replay.players[v.idx].track;
|
||||
const p = samplePlayer(tr, t, replay.sampleMs * 6);
|
||||
if (!p) {
|
||||
v.group.visible = v.drop.visible = v.shadow.visible = false;
|
||||
continue;
|
||||
}
|
||||
v.group.visible = true;
|
||||
v.drop.visible = v.shadow.visible = !mapReady;
|
||||
v.group.position.copy(toWorld(p.x, p.y, Math.max(p.z, zBase - 400), zBase));
|
||||
v.shadow.position.set(v.group.position.x, 0.04, v.group.position.z);
|
||||
const dp = v.drop.geometry.getAttribute('position') as THREE.BufferAttribute;
|
||||
dp.setXYZ(0, v.group.position.x, v.group.position.y, v.group.position.z);
|
||||
dp.setXYZ(1, v.group.position.x, 0.04, v.group.position.z);
|
||||
dp.needsUpdate = true;
|
||||
const d = dirOf(p.yaw);
|
||||
v.cone.rotation.y = Math.atan2(d.x, d.z);
|
||||
const dead = isDead(replay, v.idx, t);
|
||||
const op = dead ? 0.22 : 1;
|
||||
(v.body.material as THREE.MeshStandardMaterial).opacity = op;
|
||||
(v.cone.material as THREE.MeshStandardMaterial).opacity = dead ? 0 : 0.85;
|
||||
v.label.material.opacity = dead ? 0.35 : 1;
|
||||
(v.shadow.material as THREE.MeshBasicMaterial).opacity = dead ? 0.25 : 0.85;
|
||||
v.voice.visible = speaking.has(v.idx) && !dead;
|
||||
v.ring.visible = v.idx === selIdx;
|
||||
}
|
||||
// 천장 자르기
|
||||
const cm = ceilRef.current;
|
||||
let want = 1e6;
|
||||
if (mapReady && cm.mode === 'manual') want = cm.cm * hPerCm;
|
||||
else if (mapReady && cm.mode === 'auto') {
|
||||
const sv = selIdx != null ? views[selIdx] : null;
|
||||
let top = -Infinity;
|
||||
if (sv?.group.visible) top = sv.group.position.y;
|
||||
else for (const v of views) if (v.group.visible && !isDead(replay, v.idx, t)) top = Math.max(top, v.group.position.y);
|
||||
if (top > -Infinity) want = top + CEIL_ABOVE * hPerCm;
|
||||
}
|
||||
clipY = clipY > 1e5 || want > 1e5 ? want : clipY + (want - clipY) * 0.12;
|
||||
clip.constant = clipY;
|
||||
// 경로
|
||||
if (selIdx != null) {
|
||||
const tr = replay.players[selIdx].track;
|
||||
const pos = trailGeo.getAttribute('position') as THREE.BufferAttribute;
|
||||
let n = 0;
|
||||
for (let k = 0; k < 80; k++) {
|
||||
const p = samplePlayer(tr, t - 6000 + (6000 * k) / 79, replay.sampleMs * 6);
|
||||
if (!p) continue;
|
||||
tmp.copy(toWorld(p.x, p.y, Math.max(p.z, zBase - 400), zBase));
|
||||
pos.setXYZ(n++, tmp.x, tmp.y + 0.3, tmp.z);
|
||||
}
|
||||
trailGeo.setDrawRange(0, n);
|
||||
pos.needsUpdate = true;
|
||||
trail.visible = n > 1;
|
||||
if (followRef.current && views[selIdx].group.visible) {
|
||||
const target = views[selIdx].group.position;
|
||||
tmp.copy(target).sub(controls.target);
|
||||
controls.target.add(tmp.multiplyScalar(0.15));
|
||||
camera.position.add(tmp);
|
||||
}
|
||||
} else trail.visible = false;
|
||||
// 사격
|
||||
const sp = shotGeo.getAttribute('position') as THREE.BufferAttribute;
|
||||
let ns = 0;
|
||||
for (let i = lowerBound(replay.shots, t - 150); i < replay.shots.length && replay.shots[i][0] <= t && ns < MAX_SHOTS; i++) {
|
||||
const [, , x, y, z, yaw, pitch] = replay.shots[i];
|
||||
const a = toWorld(x, y, z, zBase);
|
||||
const d = dirOf(yaw);
|
||||
const len = 26;
|
||||
const b = a.clone().add(d.multiplyScalar(len * Math.cos((pitch * Math.PI) / 180))).add(new THREE.Vector3(0, len * Math.sin((pitch * Math.PI) / 180) * 0.3, 0));
|
||||
sp.setXYZ(ns * 2, a.x, a.y + 1.6, a.z);
|
||||
sp.setXYZ(ns * 2 + 1, b.x, b.y + 1.6, b.z);
|
||||
ns++;
|
||||
}
|
||||
shotGeo.setDrawRange(0, ns * 2);
|
||||
sp.needsUpdate = true;
|
||||
// 킬 표시: 이 라운드에서 이미 난 킬
|
||||
const rd = roundAt(replay, t);
|
||||
for (const k of killMarks) {
|
||||
const on = !!rd && k.t >= rd.buy && k.t <= t;
|
||||
k.mk.visible = on;
|
||||
if (on) {
|
||||
const age = t - k.t;
|
||||
const s = age < 600 ? 1 + (600 - age) / 300 : 1;
|
||||
k.mk.scale.setScalar(s);
|
||||
}
|
||||
}
|
||||
// 스킬 · 설치물: 생긴 뒤 사라질 때까지 (사라진 시각을 모르면 12초)
|
||||
for (let i = 0; i < replay.objects.length; i++) {
|
||||
const [t0, t1] = replay.objects[i];
|
||||
const end = t1 >= 0 ? t1 : t0 + 12000;
|
||||
const on = t >= t0 && t <= end;
|
||||
if (on) objMesh(i).visible = true;
|
||||
else {
|
||||
const mesh = objMeshes.get(i);
|
||||
if (mesh) mesh.visible = false;
|
||||
}
|
||||
}
|
||||
controls.update();
|
||||
renderer.render(scene, camera);
|
||||
if (now - lastUi > 100) {
|
||||
lastUi = now;
|
||||
setCeilNow((c) => {
|
||||
const v = clipY > 1e5 ? null : Math.round(clipY / hPerCm / 10) * 10;
|
||||
return c === v ? c : v;
|
||||
});
|
||||
setUi((u) => (Math.abs(u.t - t) < 50 && u.playing === (inScene && ps.playing) ? u : { t, playing: inScene && ps.playing }));
|
||||
}
|
||||
};
|
||||
raf = requestAnimationFrame(frame);
|
||||
return () => {
|
||||
disposed = true;
|
||||
cancelAnimationFrame(raf);
|
||||
ro.disconnect();
|
||||
renderer.domElement.removeEventListener('pointerdown', onDown);
|
||||
renderer.domElement.removeEventListener('pointerup', onUp);
|
||||
controls.dispose();
|
||||
scene.traverse((o) => {
|
||||
const mesh = o as THREE.Mesh;
|
||||
mesh.geometry?.dispose?.();
|
||||
const mat = mesh.material as THREE.Material | THREE.Material[] | undefined;
|
||||
(Array.isArray(mat) ? mat : mat ? [mat] : []).forEach((mm) => {
|
||||
(mm as THREE.MeshBasicMaterial).map?.dispose();
|
||||
mm.dispose();
|
||||
});
|
||||
});
|
||||
renderer.dispose();
|
||||
renderer.domElement.remove();
|
||||
};
|
||||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||||
}, [m, replay, base, roster, playerByUser, zBase, zTop]);
|
||||
|
||||
const inScene = () => player.state.mode === 'scene' && player.state.scene?.label === REPLAY_SCENE_LABEL;
|
||||
const seek = (t: number) => {
|
||||
const v = Math.max(0, Math.min(replay.durationMs, t));
|
||||
if (inScene()) player.seekScene(v);
|
||||
else localT.current = v;
|
||||
setUi((u) => ({ ...u, t: v }));
|
||||
};
|
||||
const togglePlay = () => {
|
||||
if (inScene()) player.toggle();
|
||||
else {
|
||||
const from = localT.current;
|
||||
player.startScene({ start: base, end: base + replay.durationMs, label: REPLAY_SCENE_LABEL, items: m.utterances });
|
||||
player.seekScene(from);
|
||||
}
|
||||
};
|
||||
|
||||
const rd = roundAt(replay, ui.t);
|
||||
const mr = rd ? m.rounds?.find((r) => r.num === rd.num) : undefined;
|
||||
const clock = !rd ? '' : rd.combat >= 0 && ui.t >= rd.combat ? fmtClock(ui.t - rd.combat) : `구매 ${fmtClock(Math.max(0, (rd.combat >= 0 ? rd.combat : rd.buy + 30000) - ui.t))}`;
|
||||
const ts = base + ui.t;
|
||||
const captions = m.utterances.filter((u) => !u.noise && u.text && u.ts <= ts && ts <= u.endTs + 1500).slice(-3);
|
||||
const feed = replay.kills.filter(([kt]) => kt <= ui.t && ui.t - kt < 6000).slice(-5);
|
||||
const selInfo = sel != null ? roster[sel] : null;
|
||||
const selPos = sel != null ? samplePlayer(replay.players[sel].track, ui.t, replay.sampleMs * 6) : null;
|
||||
const jumpRound = (dir: -1 | 1) => {
|
||||
const i = rd ? replay.rounds.indexOf(rd) : 0;
|
||||
const to = replay.rounds[Math.max(0, Math.min(replay.rounds.length - 1, i + dir))];
|
||||
if (to) seek(to.combat >= 0 ? to.combat - 3000 : to.buy);
|
||||
};
|
||||
|
||||
if (!T) return <div className="map-missing">이 경기에는 미니맵 좌표 정보가 없어 3D 리플레이를 그릴 수 없습니다</div>;
|
||||
return (
|
||||
<div className="r3d">
|
||||
<div className="r3d-stage" ref={mountRef}>
|
||||
<div className="r3d-hud tl">
|
||||
<b>{rd ? `R${rd.num}` : ''}</b> <span className="mono">{clock}</span>
|
||||
{mr && <span className="muted"> · {mr.score.ally}:{mr.score.enemy} 후 {mr.win ? '승리' : '패배'}</span>}
|
||||
{map3d.state === 'loading' && <div className="muted small">맵 3D 불러오는 중 {Math.round((map3d.progress ?? 0) * 100)}%</div>}
|
||||
{map3d.state === 'error' && <div className="muted small">맵 3D 를 불러오지 못해 미니맵으로 보여 줍니다</div>}
|
||||
</div>
|
||||
<div className="r3d-hud tr">
|
||||
{feed.map(([kt, ki, vi]) => (
|
||||
<div key={`${kt}:${vi}`} className="r3d-kill">
|
||||
<span className={roster[ki]?.ally ? 'a' : 'e'}>{roster[ki]?.name ?? '?'}</span> ✕ <span className={roster[vi]?.ally ? 'a' : 'e'}>{roster[vi]?.name ?? '?'}</span>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
{captions.length > 0 && (
|
||||
<div className="r3d-cap">
|
||||
{captions.map((u) => (
|
||||
<div key={u.id}>
|
||||
<b>{userById(u.userId)?.name ?? '알 수 없음'}</b> {u.text}
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
)}
|
||||
{selInfo && (
|
||||
<div className="r3d-hud bl">
|
||||
<b className={selInfo.ally ? 'a' : 'e'}>{selInfo.name}</b>
|
||||
{selInfo.info?.character?.name && <span className="muted"> · {selInfo.info.character.name}</span>}
|
||||
{selPos && <div className="mono muted">가장 낮은 층보다 {Math.max(0, Math.round((selPos.z - zBase) / 100))}m 위 · 보는 방향 {Math.round(((selPos.yaw % 360) + 360) % 360)}°</div>}
|
||||
<label className="r3d-follow">
|
||||
<input type="checkbox" checked={follow} onChange={(e) => setFollow(e.target.checked)} /> 따라가기
|
||||
</label>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
<div className="r3d-bar">
|
||||
<button className="chip" onClick={() => jumpRound(-1)} title="이전 라운드">⏮</button>
|
||||
<button className="chip r3d-play" onClick={togglePlay} title="대화와 같이 재생 / 멈춤">{ui.playing ? '⏸' : '▶'}</button>
|
||||
<button className="chip" onClick={() => jumpRound(1)} title="다음 라운드">⏭</button>
|
||||
<div className="r3d-scrub">
|
||||
{replay.rounds.map((r) => (
|
||||
<i key={r.num} style={{ left: `${(r.buy / replay.durationMs) * 100}%` }} data-tip={`R${r.num}`} />
|
||||
))}
|
||||
<input type="range" min={0} max={replay.durationMs} step={100} value={ui.t} onChange={(e) => seek(Number(e.target.value))} aria-label="리플레이 시간" />
|
||||
</div>
|
||||
<span className="mono muted">{fmtClock(ui.t)} / {fmtClock(replay.durationMs)}</span>
|
||||
<button className="chip mono" onClick={() => settings.set({ rate: RATES[(RATES.indexOf(cfg.rate) + 1) % RATES.length] ?? 1 })} title="재생 속도">
|
||||
{cfg.rate}x
|
||||
</button>
|
||||
{map3d.state === 'ready' && (
|
||||
<span className="r3d-ceil" title="위에서 보이게 이 높이 위(지붕 · 위층)는 잘라 냅니다">
|
||||
<button
|
||||
className={`chip${ceil.mode === 'auto' ? ' on' : ''}`}
|
||||
onClick={() => setCeil((c) => (c.mode === 'auto' ? { mode: 'off' } : { mode: 'auto' }))}
|
||||
title="자동: 고른 선수(없으면 가장 높은 선수) 머리 위까지 보이게"
|
||||
>
|
||||
천장 {ceil.mode === 'auto' ? '자동' : ceil.mode === 'off' ? '없음' : `${Math.round(ceil.cm / 100)}m`}
|
||||
</button>
|
||||
<input
|
||||
type="range"
|
||||
min={0}
|
||||
max={Math.round(zTop - zBase + 800)}
|
||||
step={50}
|
||||
value={ceil.mode === 'manual' ? ceil.cm : ceilNow ?? Math.round(zTop - zBase + 800)}
|
||||
onChange={(e) => setCeil({ mode: 'manual', cm: Number(e.target.value) })}
|
||||
aria-label="천장 높이"
|
||||
/>
|
||||
</span>
|
||||
)}
|
||||
<button className="chip" onClick={() => resetCam.current()} title="카메라 처음 위치로">전체 보기</button>
|
||||
</div>
|
||||
<div className="r3d-foot muted">
|
||||
마우스 왼쪽 끌기: 회전 · 오른쪽 끌기: 이동 · 휠: 확대 · 선수 클릭: 선택 ·{' '}
|
||||
{sync.matched >= 3
|
||||
? `대화 동기화: 킬 ${sync.matched}개로 맞춤 (최대 오차 ${((sync.spreadMs ?? 0) / 1000).toFixed(2)}초)`
|
||||
: '대화 동기화: 라운드 시작으로 대략 맞춤'}
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
function lowerBound(a: [number, ...number[]][], t: number) {
|
||||
let lo = 0;
|
||||
let hi = a.length;
|
||||
while (lo < hi) {
|
||||
const mid = (lo + hi) >> 1;
|
||||
if (a[mid][0] < t) lo = mid + 1;
|
||||
else hi = mid;
|
||||
}
|
||||
return lo;
|
||||
}
|
||||
|
||||
234
site/web/src/components/UserEdit.tsx
Normal file
234
site/web/src/components/UserEdit.tsx
Normal file
@@ -0,0 +1,234 @@
|
||||
// 유저 설정 고치기 (v1.6.0): 머리글 "내 정보" 와 관리 화면이 같이 쓴다
|
||||
// - 표시 이름: 사이트 서버에 저장 (디스코드 이름 대신 보일 이름, 게임 PC 앱에 바로 전달)
|
||||
// - 색 · 녹음 제외 · 라이엇 ID: 게임 PC 앱 기록에 저장 (앱 v1.6.0~)
|
||||
import { useEffect, useRef, useState } from 'react';
|
||||
import { Link } from 'react-router';
|
||||
import { motion } from 'framer-motion';
|
||||
import type { User } from '@gvr/shared';
|
||||
import { api, ApiError } from '../lib/api';
|
||||
import { sfx } from '../lib/sfx';
|
||||
import { useAuth, useData } from '../store/app';
|
||||
import { Avatar } from './common';
|
||||
import { ILogout } from './Icons';
|
||||
|
||||
/** 타임라인에서 잘 보이는 색들 (어두운 배경) */
|
||||
export const USER_COLORS = ['#ff4655', '#ff8a3d', '#f2b23a', '#c8e04a', '#45d39a', '#14c1b7', '#3db8ff', '#5b8cff', '#9a7bff', '#d46bff', '#ff6fb1', '#c9d1dc'];
|
||||
|
||||
/** 오류를 사람이 읽을 말로 */
|
||||
export function errText(e: unknown): string {
|
||||
if (e instanceof ApiError) {
|
||||
if (e.status === 404 && e.code === 'Not Found') return '게임 PC 앱이 아직 이 기능을 모릅니다. 앱을 v1.6.0 이상으로 업데이트해 주세요';
|
||||
if (e.status === 503 && e.code === 'device_offline') return '게임 PC 가 꺼져 있어 저장하지 못했습니다';
|
||||
if (e.status === 504) return '게임 PC 가 답하지 않습니다. 잠시 뒤 다시 해 주세요';
|
||||
if (e.detail) return e.detail;
|
||||
if (e.status === 0) return '서버에 연결하지 못했습니다';
|
||||
return `저장하지 못했습니다 (${e.status} ${e.code})`;
|
||||
}
|
||||
return e instanceof Error ? e.message : String(e);
|
||||
}
|
||||
|
||||
/** 표시 이름 입력: 저장 · 디스코드 이름으로 되돌리기 */
|
||||
export function NameEditor({ value, custom, onSave, placeholder }: { value: string; custom: boolean; onSave: (name: string) => Promise<void>; placeholder?: string }) {
|
||||
const [v, setV] = useState(value);
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [msg, setMsg] = useState<{ ok: boolean; text: string } | null>(null);
|
||||
useEffect(() => setV(value), [value]);
|
||||
const save = async (name: string) => {
|
||||
setBusy(true);
|
||||
setMsg(null);
|
||||
try {
|
||||
await onSave(name);
|
||||
setMsg({ ok: true, text: name ? '저장했습니다' : '디스코드 이름으로 되돌렸습니다' });
|
||||
sfx('click');
|
||||
} catch (e) {
|
||||
setMsg({ ok: false, text: errText(e) });
|
||||
} finally {
|
||||
setBusy(false);
|
||||
}
|
||||
};
|
||||
return (
|
||||
<div className="ue-block">
|
||||
<form
|
||||
className="ue-row"
|
||||
onSubmit={(e) => {
|
||||
e.preventDefault();
|
||||
if (v.trim() && v.trim() !== value) void save(v.trim());
|
||||
}}
|
||||
>
|
||||
<input className="ue-input" value={v} maxLength={32} placeholder={placeholder ?? '표시 이름'} onChange={(e) => setV(e.target.value)} aria-label="표시 이름" />
|
||||
<button className="btn sm primary" disabled={busy || !v.trim() || v.trim() === value}>
|
||||
저장
|
||||
</button>
|
||||
{custom && (
|
||||
<button type="button" className="btn sm" disabled={busy} onClick={() => void save('')} title="표시 이름을 지우고 디스코드 서버 별명으로 보이게">
|
||||
되돌리기
|
||||
</button>
|
||||
)}
|
||||
</form>
|
||||
{msg && <div className={`ue-msg${msg.ok ? ' ok' : ' bad'}`}>{msg.text}</div>}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
/** 색 · 녹음 제외 · 라이엇 ID (게임 PC 앱에 저장) */
|
||||
export function AppUserEditor({ user, self }: { user: User; self: boolean }) {
|
||||
const { reloadUsers } = useData();
|
||||
const [riot, setRiot] = useState(user.riot.map((r) => r.riotId).join(', '));
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [msg, setMsg] = useState<{ ok: boolean; text: string } | null>(null);
|
||||
const riotNow = user.riot.map((r) => r.riotId).join(', ');
|
||||
useEffect(() => setRiot(riotNow), [riotNow]);
|
||||
const colorRef = useRef<HTMLInputElement>(null);
|
||||
const patch = async (p: { color?: string; excluded?: boolean; riotIds?: string[] }, okText: string) => {
|
||||
setBusy(true);
|
||||
setMsg(null);
|
||||
try {
|
||||
const r = await api.updateUser(user.id, p);
|
||||
reloadUsers();
|
||||
setMsg(r.taken.length ? { ok: false, text: `다른 사람에게 연결된 라이엇 ID 는 빼고 저장했습니다: ${r.taken.join(', ')}` } : { ok: true, text: okText });
|
||||
sfx('click');
|
||||
} catch (e) {
|
||||
setMsg({ ok: false, text: errText(e) });
|
||||
} finally {
|
||||
setBusy(false);
|
||||
}
|
||||
};
|
||||
const riotIds = riot
|
||||
.split(/[,\n]/)
|
||||
.map((x) => x.trim())
|
||||
.filter(Boolean);
|
||||
const riotBad = riotIds.filter((r) => !/^[^#]{1,32}#[^#]{1,8}$/.test(r));
|
||||
return (
|
||||
<div className="ue-block">
|
||||
<div className="ue-label">색</div>
|
||||
<div className="ue-colors" role="radiogroup" aria-label="유저 색">
|
||||
{USER_COLORS.map((c) => (
|
||||
<button
|
||||
key={c}
|
||||
className={`ue-sw${user.color.toLowerCase() === c ? ' on' : ''}`}
|
||||
style={{ background: c }}
|
||||
role="radio"
|
||||
aria-checked={user.color.toLowerCase() === c}
|
||||
aria-label={c}
|
||||
disabled={busy}
|
||||
onClick={() => void patch({ color: c }, '색을 바꿨습니다')}
|
||||
/>
|
||||
))}
|
||||
<button className="ue-sw custom" title="다른 색 고르기" aria-label="다른 색 고르기" disabled={busy} onClick={() => colorRef.current?.click()}>
|
||||
+
|
||||
</button>
|
||||
<input ref={colorRef} type="color" className="ue-hidden" defaultValue={user.color} onChange={(e) => void patch({ color: e.target.value }, '색을 바꿨습니다')} />
|
||||
</div>
|
||||
|
||||
<div className="ue-label">라이엇 ID</div>
|
||||
<form
|
||||
className="ue-row"
|
||||
onSubmit={(e) => {
|
||||
e.preventDefault();
|
||||
if (!riotBad.length) void patch({ riotIds }, '라이엇 ID 를 저장했습니다');
|
||||
}}
|
||||
>
|
||||
<input className="ue-input" value={riot} placeholder="이름#태그 (여러 개는 쉼표로)" onChange={(e) => setRiot(e.target.value)} aria-label="라이엇 ID" />
|
||||
<button className="btn sm" disabled={busy || riot.trim() === riotNow || riotBad.length > 0 || riotIds.length > 5}>
|
||||
저장
|
||||
</button>
|
||||
</form>
|
||||
{riotBad.length > 0 && <div className="ue-msg bad">이름#태그 형식이 아닙니다: {riotBad.join(', ')}</div>}
|
||||
<div className="ue-hint">경기 기록의 선수와 연결됩니다. 새로 넣은 ID 는 다음 경기에서 확인됩니다.</div>
|
||||
|
||||
<label className="ue-check">
|
||||
<input type="checkbox" checked={user.excluded} disabled={busy} onChange={(e) => void patch({ excluded: e.target.checked }, e.target.checked ? '앞으로 녹음하지 않습니다' : '다시 녹음합니다')} />
|
||||
<span>
|
||||
<b>녹음 제외</b>
|
||||
<span className="ue-hint">{self ? '켜면 앞으로 내 목소리를 녹음하지 않습니다 (이미 녹음된 기록은 그대로).' : '켜면 앞으로 이 사람 목소리를 녹음하지 않습니다.'}</span>
|
||||
</span>
|
||||
</label>
|
||||
{msg && <div className={`ue-msg${msg.ok ? ' ok' : ' bad'}`}>{msg.text}</div>}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
/** 머리글 오른쪽 위 내 이름을 누르면 나오는 "내 정보" */
|
||||
export function ProfilePopover({ onClose }: { onClose: () => void }) {
|
||||
const { auth, logout, refreshMe } = useAuth();
|
||||
const { userById } = useData();
|
||||
const ref = useRef<HTMLDivElement>(null);
|
||||
const [custom, setCustom] = useState<boolean | null>(null);
|
||||
useEffect(() => {
|
||||
const down = (e: PointerEvent) => {
|
||||
if (ref.current && !ref.current.contains(e.target as Node) && !(e.target as HTMLElement).closest('.me-btn')) onClose();
|
||||
};
|
||||
const key = (e: KeyboardEvent) => e.key === 'Escape' && onClose();
|
||||
document.addEventListener('pointerdown', down);
|
||||
document.addEventListener('keydown', key);
|
||||
return () => {
|
||||
document.removeEventListener('pointerdown', down);
|
||||
document.removeEventListener('keydown', key);
|
||||
};
|
||||
}, [onClose]);
|
||||
useEffect(() => {
|
||||
let alive = true;
|
||||
fetch('/site/profile', { credentials: 'include' })
|
||||
.then((r) => (r.ok ? r.json() : null))
|
||||
.then((p) => alive && p && setCustom(!!p.customName))
|
||||
.catch(() => undefined);
|
||||
return () => {
|
||||
alive = false;
|
||||
};
|
||||
}, []);
|
||||
if (auth.status !== 'ok') return null;
|
||||
const me = auth.me.user;
|
||||
const u = userById(me.id);
|
||||
const admin = auth.me.canViewLogs;
|
||||
const roleLabel = auth.me.role === 'superadmin' ? '최고 관리자' : auth.me.role === 'admin' ? '관리자' : auth.me.role === 'user' ? '앱 유저' : admin ? '관리자' : '서버 멤버';
|
||||
return (
|
||||
<motion.div
|
||||
ref={ref}
|
||||
className="popover profile-pop"
|
||||
initial={{ opacity: 0, y: -6, scale: 0.98 }}
|
||||
animate={{ opacity: 1, y: 0, scale: 1 }}
|
||||
exit={{ opacity: 0, y: -6, scale: 0.98 }}
|
||||
transition={{ duration: 0.16 }}
|
||||
role="dialog"
|
||||
aria-label="내 정보"
|
||||
>
|
||||
<div className="pp-head">
|
||||
<Avatar name={me.name} src={me.avatar} color={u?.color ?? '#5865f2'} size={40} />
|
||||
<div>
|
||||
<b style={u ? { color: u.color } : undefined}>{me.name}</b>
|
||||
<div className="dim small">
|
||||
{roleLabel} · <span className="mono">{me.id}</span>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<h5>표시 이름</h5>
|
||||
<NameEditor
|
||||
value={me.name}
|
||||
custom={!!custom}
|
||||
onSave={async (name) => {
|
||||
const r = await api.setMyName(name);
|
||||
setCustom(!!r.customName);
|
||||
await refreshMe();
|
||||
}}
|
||||
/>
|
||||
<div className="ue-hint">사이트 · 게임 PC 기록 · 범인 분석에서 디스코드 이름 대신 보입니다.</div>
|
||||
<h5>녹음 기록 설정</h5>
|
||||
{u ? <AppUserEditor user={u} self /> : <div className="ue-hint">아직 녹음된 적이 없습니다. 음성채널에서 한 번 녹음되면 색 · 라이엇 ID · 녹음 제외를 바꿀 수 있습니다.</div>}
|
||||
<div className="pp-links">
|
||||
{u && (
|
||||
<Link to={`/users/${me.id}`} className="mini-btn" onClick={onClose}>
|
||||
내 기록 보기
|
||||
</Link>
|
||||
)}
|
||||
{admin && (
|
||||
<Link to="/admin" className="mini-btn" onClick={onClose}>
|
||||
🛡️ 관리 페이지
|
||||
</Link>
|
||||
)}
|
||||
<button className="mini-btn" onClick={logout}>
|
||||
<ILogout width={13} height={13} /> 로그아웃
|
||||
</button>
|
||||
</div>
|
||||
</motion.div>
|
||||
);
|
||||
}
|
||||
@@ -15,9 +15,12 @@ import type {
|
||||
BundleInfo,
|
||||
BundleImportResult,
|
||||
NoisePhrase,
|
||||
AppRole,
|
||||
AppUserRow,
|
||||
} from '@gvr/shared';
|
||||
|
||||
import { reportClient } from './report';
|
||||
import type { ReplayFile } from './replay';
|
||||
|
||||
/** 전역 신호: 401 → 로그인 화면, 503 device_offline → 잠금 화면 */
|
||||
type Signal = 'unauthorized' | 'not_member' | 'device_offline';
|
||||
@@ -32,6 +35,8 @@ export class ApiError extends Error {
|
||||
constructor(
|
||||
public status: number,
|
||||
public code: string,
|
||||
/** 서버가 함께 보낸 설명 (있으면) */
|
||||
public detail?: string,
|
||||
) {
|
||||
super(`${status} ${code}`);
|
||||
}
|
||||
@@ -53,8 +58,11 @@ async function request<T>(path: string, init: RequestInit = {}): Promise<T> {
|
||||
return (await res.json()) as T;
|
||||
}
|
||||
let code = 'error';
|
||||
let detail: string | undefined;
|
||||
try {
|
||||
code = ((await res.json()) as { error?: string }).error ?? code;
|
||||
const b = (await res.json()) as { error?: string; message?: string };
|
||||
code = b.error ?? code;
|
||||
if (typeof b.message === 'string') detail = b.message;
|
||||
} catch {
|
||||
/* 본문 없음 */
|
||||
}
|
||||
@@ -63,7 +71,7 @@ async function request<T>(path: string, init: RequestInit = {}): Promise<T> {
|
||||
else if (res.status === 503 && code === 'device_offline') emit('device_offline');
|
||||
// 게임 PC 쪽 오류 · 시간 초과는 사이트 로그에도 남긴다 (게임 PC 꺼짐은 서버가 이미 남김)
|
||||
else if (res.status >= 500) reportClient('error', `요청 실패 ${res.status} ${code}: ${init.method ?? 'GET'} ${path.split('?')[0]}`);
|
||||
throw new ApiError(res.status, code);
|
||||
throw new ApiError(res.status, code, detail);
|
||||
}
|
||||
|
||||
export interface Me {
|
||||
@@ -71,6 +79,16 @@ export interface Me {
|
||||
isOwner: boolean;
|
||||
/** 사이트 로그를 볼 수 있는지 (관리자 · 최고 관리자, v1.3.6~) */
|
||||
canViewLogs?: boolean;
|
||||
/** 앱 역할 (등록 안 된 멤버는 null, v1.6.0~) */
|
||||
role?: AppRole | null;
|
||||
}
|
||||
|
||||
/** 관리 화면 머리 (v1.6.0) */
|
||||
export interface AdminOverview {
|
||||
device: DeviceStatus & { guildId: string | null };
|
||||
latest: { version: string; url: string; publishedAt: string | null } | null;
|
||||
role: AppRole;
|
||||
serverVersion: string;
|
||||
}
|
||||
export interface StatusResponse {
|
||||
device: DeviceStatus;
|
||||
@@ -113,6 +131,17 @@ export const api = {
|
||||
/** 관리자(OWNER_DISCORD_IDS) 전용: 게임 PC 1회용 등록 코드 (10분) */
|
||||
registrationCode: () => request<{ code: string; expiresAt: number }>('/admin/registration-code', { method: 'POST' }),
|
||||
status: () => request<StatusResponse>('/api/status'),
|
||||
// 내 정보 · 관리 화면 (v1.6.0)
|
||||
setMyName: (name: string) => request<{ user: Me['user']; customName: string | null }>('/site/profile/name', { method: 'PUT', body: JSON.stringify({ name }) }),
|
||||
/** 색 · 녹음 제외 · 라이엇 ID (게임 PC 앱 v1.6.0~, 본인 또는 관리자) */
|
||||
updateUser: (id: string, patch: { color?: string; excluded?: boolean; riotIds?: string[] }) =>
|
||||
request<{ user: User; taken: string[] }>(`/api/users/${encodeURIComponent(id)}`, { method: 'PATCH', body: JSON.stringify(patch) }),
|
||||
adminOverview: () => request<AdminOverview>('/site/admin/overview'),
|
||||
adminUsers: () => request<{ users: AppUserRow[]; names: Record<string, string> }>('/site/admin/users'),
|
||||
adminSetName: (id: string, name: string) => request<{ names: Record<string, string> }>('/site/admin/names', { method: 'PUT', body: JSON.stringify({ id, name }) }),
|
||||
adminAddUser: (id: string, role: 'admin' | 'user') => request<{ users: AppUserRow[] }>('/site/admin/users', { method: 'POST', body: JSON.stringify({ id, role }) }),
|
||||
adminSetRole: (id: string, role: 'admin' | 'user') => request<{ users: AppUserRow[] }>(`/site/admin/users/${encodeURIComponent(id)}`, { method: 'PATCH', body: JSON.stringify({ role }) }),
|
||||
adminRemoveUser: (id: string) => request<{ users: AppUserRow[] }>(`/site/admin/users/${encodeURIComponent(id)}`, { method: 'DELETE' }),
|
||||
overview: () => request<Overview>('/api/overview'),
|
||||
users: () => request<User[]>('/api/users'),
|
||||
user: (id: string) => request<UserProfile>(`/api/users/${encodeURIComponent(id)}`),
|
||||
@@ -135,6 +164,8 @@ export const api = {
|
||||
),
|
||||
matches: (o: { game?: GameType; limit?: number; before?: number } = {}) => request<MatchSummary[]>(`/api/matches${qs(o)}`),
|
||||
match: (id: string) => request<MatchDetail>(`/api/matches/${encodeURIComponent(id)}`),
|
||||
/** 발로란트 리플레이(.vrf)에서 뽑은 재생 데이터. 없으면 404 replay_not_found, 게임 PC 가 변환 중이면 202 { status: 'converting' } */
|
||||
replay: (id: string) => request<ReplayFile | { status: 'converting' }>(`/api/matches/${encodeURIComponent(id)}/replay`),
|
||||
culpritMatches: (o: { game?: GameType; limit?: number } = {}) => request<CulpritMatchItem[]>(`/api/culprit/matches${qs(o)}`),
|
||||
culpritMatch: (id: string) => request<CulpritMatchInfo>(`/api/culprit/matches/${encodeURIComponent(id)}`),
|
||||
culpritBudget: () => request<CulpritBudget>('/api/culprit/budget'),
|
||||
|
||||
94
site/web/src/lib/map3d.ts
Normal file
94
site/web/src/lib/map3d.ts
Normal file
@@ -0,0 +1,94 @@
|
||||
import * as THREE from 'three';
|
||||
import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
|
||||
import { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';
|
||||
|
||||
/**
|
||||
* 발로란트 맵 3D 모양 (사이트 서버 /site/maps3d, 로그인 필요).
|
||||
* glb 의 위치는 UE 월드 좌표(cm) 그대로다. 리플레이 선수 x,y,z 와 같은 좌표라 같은 변환으로 옮기면 겹친다.
|
||||
*/
|
||||
interface Index {
|
||||
dir: string | null;
|
||||
version: string | null;
|
||||
maps: Record<string, { code: string; file: string; bytes: number; triangles: number }>;
|
||||
}
|
||||
|
||||
let indexP: Promise<Index | null> | null = null;
|
||||
function loadIndex(): Promise<Index | null> {
|
||||
indexP ??= fetch('/site/maps3d', { credentials: 'same-origin' })
|
||||
.then((r) => (r.ok ? (r.json() as Promise<Index>) : null))
|
||||
.catch(() => null)
|
||||
.then((d) => {
|
||||
if (!d) indexP = null; // 실패하면 다음에 다시
|
||||
return d;
|
||||
});
|
||||
return indexP;
|
||||
}
|
||||
|
||||
export interface Map3dInfo {
|
||||
url: string;
|
||||
bytes: number;
|
||||
triangles: number;
|
||||
version: string | null;
|
||||
}
|
||||
|
||||
/** 경기 맵 경로(/Game/Maps/Ascent/Ascent)의 3D 파일. 없으면 null. 폴더 대소문자는 게임 파일과 다를 수 있어 무시한다 */
|
||||
export async function findMap3d(mapUrl: string): Promise<Map3dInfo | null> {
|
||||
const idx = await loadIndex();
|
||||
if (!idx?.dir || !mapUrl) return null;
|
||||
const key = mapUrl.toLowerCase();
|
||||
const hit = Object.entries(idx.maps).find(([k]) => k.toLowerCase() === key)?.[1];
|
||||
return hit ? { url: `/site/maps3d/${encodeURIComponent(idx.dir)}/${encodeURIComponent(hit.file)}`, bytes: hit.bytes, triangles: hit.triangles, version: idx.version } : null;
|
||||
}
|
||||
|
||||
/** glb 를 받아 메시 하나로. onProgress: 0~1 */
|
||||
export function loadMap3d(url: string, material: THREE.Material, onProgress?: (p: number) => void): Promise<THREE.Object3D> {
|
||||
const loader = new GLTFLoader();
|
||||
loader.setMeshoptDecoder(MeshoptDecoder);
|
||||
return new Promise((resolve, reject) => {
|
||||
loader.load(
|
||||
url,
|
||||
(gltf) => {
|
||||
gltf.scene.traverse((o) => {
|
||||
const mesh = o as THREE.Mesh;
|
||||
if (mesh.isMesh) {
|
||||
mesh.material = material;
|
||||
mesh.frustumCulled = false;
|
||||
}
|
||||
});
|
||||
resolve(gltf.scene);
|
||||
},
|
||||
(e) => onProgress?.(e.total ? e.loaded / e.total : 0),
|
||||
reject,
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
/** UE 월드 좌표(cm) → 3D 리플레이 화면 좌표. ReplayViewer 의 toWorld 와 같은 식을 행렬로 */
|
||||
export function worldMatrix(T: { xMultiplier: number; yMultiplier: number; xScalarToAdd: number; yScalarToAdd: number }, S: number, zBase: number, vex: number) {
|
||||
const h = Math.abs(T.xMultiplier) * S * vex;
|
||||
return new THREE.Matrix4().set(
|
||||
0, T.xMultiplier * S, 0, (T.xScalarToAdd - 0.5) * S,
|
||||
0, 0, h, -zBase * h,
|
||||
T.yMultiplier * S, 0, 0, (T.yScalarToAdd - 0.5) * S,
|
||||
0, 0, 0, 1,
|
||||
);
|
||||
}
|
||||
|
||||
/** 높이에 따라 색이 바뀌는 맵 재질 (낮은 곳 푸른 회색 → 높은 곳 밝은 베이지). 천장 자르기 평면을 쓴다 */
|
||||
export function mapMaterial(clip: THREE.Plane, yRange: { lo: number; hi: number }) {
|
||||
const mat = new THREE.MeshStandardMaterial({ color: 0xffffff, roughness: 0.92, metalness: 0, flatShading: true, side: THREE.DoubleSide, clippingPlanes: [clip], clipShadows: true });
|
||||
mat.onBeforeCompile = (sh) => {
|
||||
sh.uniforms.uLo = { value: yRange.lo };
|
||||
sh.uniforms.uHi = { value: yRange.hi };
|
||||
sh.vertexShader = sh.vertexShader
|
||||
.replace('#include <common>', '#include <common>\nvarying float vH;')
|
||||
.replace('#include <worldpos_vertex>', '#include <worldpos_vertex>\nvH = (modelMatrix * vec4(transformed, 1.0)).y;');
|
||||
sh.fragmentShader = sh.fragmentShader
|
||||
.replace('#include <common>', '#include <common>\nvarying float vH;\nuniform float uLo;\nuniform float uHi;')
|
||||
.replace(
|
||||
'vec4 diffuseColor = vec4( diffuse, opacity );',
|
||||
'float hN = clamp((vH - uLo) / max(uHi - uLo, 0.001), 0.0, 1.0);\nvec4 diffuseColor = vec4(mix(vec3(0.20, 0.25, 0.32), vec3(0.62, 0.57, 0.48), hN), opacity);',
|
||||
);
|
||||
};
|
||||
return mat;
|
||||
}
|
||||
141
site/web/src/lib/replay.ts
Normal file
141
site/web/src/lib/replay.ts
Normal file
@@ -0,0 +1,141 @@
|
||||
import type { KillData, MatchDetail } from '@gvr/shared';
|
||||
|
||||
/** tools/replay-extract (gvr-replay v1) 출력. t 는 리플레이 시작부터 ms, 좌표는 게임 월드 단위 */
|
||||
export interface ReplayFile {
|
||||
format: 'gvr-replay';
|
||||
v: 1;
|
||||
matchId: string | null;
|
||||
map: string | null;
|
||||
build: string | null;
|
||||
/** 리플레이 녹화 시작 (서버 시계, 유닉스 ms) */
|
||||
recordedAt: number;
|
||||
durationMs: number;
|
||||
sampleMs: number;
|
||||
players: { puuid: string | null; character: string | null; track: { t: number[]; x: number[]; y: number[]; z: number[]; yaw: number[]; pitch: number[] } }[];
|
||||
rounds: { num: number; buy: number; combat: number; end: number }[];
|
||||
phases: [number, number][];
|
||||
/** [t, killer, victim] */
|
||||
kills: [number, number, number][];
|
||||
/** [t, player, x, y, z, yaw, pitch] */
|
||||
shots: [number, number, number, number, number, number, number][];
|
||||
/** [t0, t1, kind, x, y, z, owner] */
|
||||
objects: [number, number, number, number, number, number, number][];
|
||||
objectKinds: string[];
|
||||
}
|
||||
|
||||
/**
|
||||
* 리플레이 시간(t) ↔ 기록 시각(ts, 게임 PC 시계) 맞추기.
|
||||
* 기본: ts = recordedAt + t + offset. offset 은 같은 킬(죽인 사람 · 죽은 사람이 같은 것)이
|
||||
* 경기 기록(match-details → 킬 이벤트 ts)과 리플레이에서 각각 언제인지 비교한 차이의 중앙값.
|
||||
* 킬을 못 맞추면 라운드 교전 시작으로 맞춘다 (정확도 낮음).
|
||||
*/
|
||||
export interface ReplaySync {
|
||||
offset: number;
|
||||
/** 맞춘 킬 수 */
|
||||
matched: number;
|
||||
/** 킬별 차이가 중앙값에서 벗어난 정도 (절대값 최대, ms). 이게 작아야 동기화가 정확하다 */
|
||||
spreadMs: number | null;
|
||||
/** 킬별 차이 (ms, 중앙값 기준) */
|
||||
residuals: number[];
|
||||
}
|
||||
|
||||
export function computeSync(m: MatchDetail, r: ReplayFile): ReplaySync {
|
||||
const kills = m.events.filter((e) => e.type === 'kill');
|
||||
const used = new Set<string>();
|
||||
const diffs: number[] = [];
|
||||
for (const [t, ki, vi] of r.kills) {
|
||||
const killer = r.players[ki]?.puuid;
|
||||
const victim = r.players[vi]?.puuid;
|
||||
if (!victim) continue;
|
||||
const at = r.recordedAt + t;
|
||||
let best: { id: string; d: number } | null = null;
|
||||
for (const e of kills) {
|
||||
if (used.has(e.id)) continue;
|
||||
const d = e.data as KillData;
|
||||
if (d.victim?.puuid !== victim) continue;
|
||||
if (killer && d.killer?.puuid && d.killer.puuid !== killer) continue;
|
||||
const diff = e.ts - at;
|
||||
// 1분 넘게 차이 나면 다른 라운드의 킬
|
||||
if (Math.abs(diff - (diffs.length ? median(diffs) : diff)) > 60000) continue;
|
||||
if (!best || Math.abs(diff) < Math.abs(best.d)) best = { id: e.id, d: diff };
|
||||
}
|
||||
if (best) {
|
||||
used.add(best.id);
|
||||
diffs.push(best.d);
|
||||
}
|
||||
}
|
||||
if (diffs.length >= 3) {
|
||||
const off = median(diffs);
|
||||
const residuals = diffs.map((d) => d - off);
|
||||
return { offset: off, matched: diffs.length, spreadMs: Math.max(...residuals.map(Math.abs)), residuals };
|
||||
}
|
||||
// 킬로 못 맞추면 라운드 교전 시작으로 맞춘다. 앱은 라운드 시작을 "교전 시작 - 30초" 로 저장한다 (valorant.ts BUY_MS)
|
||||
const rd: number[] = [];
|
||||
for (const mr of m.rounds ?? []) {
|
||||
const rr = r.rounds.find((x) => x.num === mr.num);
|
||||
if (rr && rr.combat >= 0) rd.push(mr.startedAt + 30000 - (r.recordedAt + rr.combat));
|
||||
}
|
||||
if (rd.length) return { offset: median(rd), matched: 0, spreadMs: null, residuals: [] };
|
||||
return { offset: 0, matched: 0, spreadMs: null, residuals: [] };
|
||||
}
|
||||
|
||||
function median(a: number[]): number {
|
||||
const s = [...a].sort((x, y) => x - y);
|
||||
const n = s.length;
|
||||
return n % 2 ? s[(n - 1) / 2] : (s[n / 2 - 1] + s[n / 2]) / 2;
|
||||
}
|
||||
|
||||
/** 이동 기록에서 t 시점 위치 (앞뒤 표본 사이 직선 보간). 표본이 sampleMs*5 넘게 끊겼으면 그 사이는 없음 */
|
||||
export function samplePlayer(tr: ReplayFile['players'][number]['track'], t: number, gapMs: number) {
|
||||
const T = tr.t;
|
||||
if (!T.length || t < T[0] - gapMs) return null;
|
||||
let lo = 0;
|
||||
let hi = T.length - 1;
|
||||
while (lo < hi) {
|
||||
const mid = (lo + hi + 1) >> 1;
|
||||
if (T[mid] <= t) lo = mid;
|
||||
else hi = mid - 1;
|
||||
}
|
||||
const i = lo;
|
||||
const j = Math.min(i + 1, T.length - 1);
|
||||
if (t - T[i] > gapMs) return { x: tr.x[i], y: tr.y[i], z: tr.z[i], yaw: tr.yaw[i], pitch: tr.pitch[i], stale: true };
|
||||
const span = T[j] - T[i];
|
||||
const k = j === i || span > gapMs || span <= 0 ? 0 : Math.min(1, Math.max(0, (t - T[i]) / span));
|
||||
let dy = tr.yaw[j] - tr.yaw[i];
|
||||
if (dy > 180) dy -= 360;
|
||||
if (dy < -180) dy += 360;
|
||||
return {
|
||||
x: tr.x[i] + (tr.x[j] - tr.x[i]) * k,
|
||||
y: tr.y[i] + (tr.y[j] - tr.y[i]) * k,
|
||||
z: tr.z[i] + (tr.z[j] - tr.z[i]) * k,
|
||||
yaw: tr.yaw[i] + dy * k,
|
||||
pitch: tr.pitch[i] + (tr.pitch[j] - tr.pitch[i]) * k,
|
||||
stale: false,
|
||||
};
|
||||
}
|
||||
|
||||
/** t 가 속한 라운드 (구매 단계 시작 기준) */
|
||||
export function roundAt(r: ReplayFile, t: number) {
|
||||
let cur = r.rounds[0] ?? null;
|
||||
for (const rd of r.rounds) if (rd.buy <= t) cur = rd;
|
||||
return cur;
|
||||
}
|
||||
|
||||
/** 이 라운드에서 t 전에 죽었는지 (다시 움직인 기록이 있으면 부활로 본다) */
|
||||
export function isDead(r: ReplayFile, player: number, t: number) {
|
||||
const rd = roundAt(r, t);
|
||||
if (!rd) return false;
|
||||
let death = -1;
|
||||
for (const [kt, , v] of r.kills) if (v === player && kt >= rd.buy && kt <= t) death = kt;
|
||||
if (death < 0) return false;
|
||||
const T = r.players[player]?.track.t ?? [];
|
||||
// 죽은 뒤 2초 넘어 움직인 표본이 t 전에 있으면 살아난 것
|
||||
let lo = 0;
|
||||
let hi = T.length;
|
||||
while (lo < hi) {
|
||||
const mid = (lo + hi) >> 1;
|
||||
if (T[mid] <= death + 2000) lo = mid + 1;
|
||||
else hi = mid;
|
||||
}
|
||||
return !(lo < T.length && T[lo] <= t);
|
||||
}
|
||||
299
site/web/src/pages/AdminPage.tsx
Normal file
299
site/web/src/pages/AdminPage.tsx
Normal file
@@ -0,0 +1,299 @@
|
||||
// 관리 페이지 (v1.6.0, 관리자 · 최고 관리자)
|
||||
// - 게임 PC: 연결 · 앱 버전 · 새 버전 안내
|
||||
// - 유저: 표시 이름 · 색 · 녹음 제외 · 라이엇 ID (녹음된 사람), 앱 등록 · 역할 · 해제 (최고 관리자)
|
||||
import { useCallback, useEffect, useMemo, useState } from 'react';
|
||||
import { Link } from 'react-router';
|
||||
import type { AppUserRow, User } from '@gvr/shared';
|
||||
import { api, type AdminOverview } from '../lib/api';
|
||||
import { fmtDay } from '../lib/format';
|
||||
import { useAuth, useData } from '../store/app';
|
||||
import { Avatar, ErrorBox, Panel, Spinner } from '../components/common';
|
||||
import { AppUserEditor, errText, NameEditor } from '../components/UserEdit';
|
||||
|
||||
const ROLE: Record<string, string> = { superadmin: '최고 관리자', admin: '관리자', user: '앱 유저' };
|
||||
|
||||
/** "1.4.1" < "1.5.0" */
|
||||
export function olderVersion(a: string | null | undefined, b: string | null | undefined): boolean {
|
||||
if (!a || !b) return false;
|
||||
const pa = a.split('.').map((x) => parseInt(x, 10) || 0);
|
||||
const pb = b.split('.').map((x) => parseInt(x, 10) || 0);
|
||||
for (let i = 0; i < Math.max(pa.length, pb.length); i++) if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) < (pb[i] ?? 0);
|
||||
return false;
|
||||
}
|
||||
|
||||
const when = (t: number | null) => (t ? `${fmtDay(t)} ${new Date(t).toLocaleTimeString('ko-KR', { hour12: false, hour: '2-digit', minute: '2-digit' })}` : '—');
|
||||
|
||||
interface Row {
|
||||
id: string;
|
||||
name: string;
|
||||
avatar: string | null;
|
||||
/** 녹음 기록에 있는 사람 (게임 PC 앱) */
|
||||
user: User | null;
|
||||
/** 앱 등록 (사이트 서버) */
|
||||
reg: AppUserRow | null;
|
||||
}
|
||||
|
||||
export function AdminPage() {
|
||||
const { auth } = useAuth();
|
||||
const { users } = useData();
|
||||
const [ov, setOv] = useState<AdminOverview | null>(null);
|
||||
const [regs, setRegs] = useState<AppUserRow[] | null>(null);
|
||||
const [names, setNames] = useState<Record<string, string>>({});
|
||||
const [err, setErr] = useState<unknown>(null);
|
||||
const [open, setOpen] = useState<string | null>(null);
|
||||
const [q, setQ] = useState('');
|
||||
const load = useCallback(() => {
|
||||
setErr(null);
|
||||
Promise.all([api.adminOverview(), api.adminUsers()])
|
||||
.then(([o, u]) => {
|
||||
setOv(o);
|
||||
setRegs(u.users);
|
||||
setNames(u.names ?? {});
|
||||
})
|
||||
.catch(setErr);
|
||||
}, []);
|
||||
useEffect(load, [load]);
|
||||
const sup = ov?.role === 'superadmin';
|
||||
|
||||
const rows = useMemo<Row[]>(() => {
|
||||
const m = new Map<string, Row>();
|
||||
for (const u of users) m.set(u.id, { id: u.id, name: u.name, avatar: u.avatar, user: u, reg: null });
|
||||
for (const r of regs ?? []) {
|
||||
const cur = m.get(r.id);
|
||||
if (cur) cur.reg = r;
|
||||
else m.set(r.id, { id: r.id, name: r.name, avatar: r.avatar, user: null, reg: r });
|
||||
}
|
||||
const order = (r: Row) => (r.reg?.role === 'superadmin' ? 0 : r.reg?.role === 'admin' ? 1 : r.reg ? 2 : 3);
|
||||
const k = q.trim().toLowerCase();
|
||||
return [...m.values()]
|
||||
.filter((r) => !k || r.name.toLowerCase().includes(k) || r.id.includes(k) || r.user?.riot.some((x) => x.riotId.toLowerCase().includes(k)))
|
||||
.sort((a, b) => order(a) - order(b) || a.name.localeCompare(b.name, 'ko'));
|
||||
}, [users, regs, q]);
|
||||
|
||||
if (auth.status !== 'ok' || !auth.me.canViewLogs)
|
||||
return (
|
||||
<main className="page-pad">
|
||||
<h2 className="page-h h">관리</h2>
|
||||
<div className="dim">관리자만 볼 수 있습니다.</div>
|
||||
</main>
|
||||
);
|
||||
if (err) return <main className="page-pad"><ErrorBox error={err} onRetry={load} /></main>;
|
||||
if (!ov || !regs) return <main className="page-pad"><Spinner /></main>;
|
||||
|
||||
const dev = ov.device;
|
||||
const outdated = olderVersion(dev.version, ov.latest?.version);
|
||||
return (
|
||||
<main className="page-pad admin-page">
|
||||
<div className="page-h-row">
|
||||
<h2 className="page-h h">🛡️ 관리</h2>
|
||||
<div className="chips-wrap">
|
||||
<a className="mini-btn" href="/logs">
|
||||
📄 사이트 로그
|
||||
</a>
|
||||
<button className="mini-btn" onClick={load}>
|
||||
새로고침
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<Panel title="게임 PC">
|
||||
<div className="adm-dev">
|
||||
<div>
|
||||
<span className={`dot-st ${dev.online ? 'on' : 'off'}`} /> <b>{dev.name ?? '등록된 PC 없음'}</b>
|
||||
<span className="dim small"> · {dev.online ? '연결됨' : dev.lastSeen ? `마지막 연결 ${when(dev.lastSeen)}` : '연결 안 됨'}</span>
|
||||
</div>
|
||||
<div>
|
||||
앱 <b className="mono">{dev.version ?? '?'}</b>
|
||||
{ov.latest && (
|
||||
<span className="dim small">
|
||||
{' '}
|
||||
· 최신 <span className="mono">{ov.latest.version}</span>
|
||||
</span>
|
||||
)}
|
||||
{outdated && ov.latest && (
|
||||
<a className="adm-update" href={ov.latest.url} target="_blank" rel="noreferrer">
|
||||
새 버전 v{ov.latest.version} 받기 →
|
||||
</a>
|
||||
)}
|
||||
</div>
|
||||
{outdated && <div className="ue-hint">게임 PC 앱이 최신이 아닙니다. 색 · 녹음 제외 · 라이엇 ID 바꾸기와 3D 리플레이는 최신 앱에서 됩니다.</div>}
|
||||
</div>
|
||||
</Panel>
|
||||
|
||||
<Panel
|
||||
title={`유저 ${rows.length}명`}
|
||||
right={<input className="ue-input adm-search" value={q} placeholder="이름 · 아이디 · 라이엇 ID 찾기" onChange={(e) => setQ(e.target.value)} aria-label="유저 찾기" />}
|
||||
>
|
||||
<div className="ue-hint adm-note">
|
||||
표시 이름은 디스코드 이름 대신 사이트 · 게임 PC 기록 · 범인 분석에 보입니다 (관리자). 앱 등록 · 역할 바꾸기 · 등록 해제는 최고 관리자만 할 수 있습니다.
|
||||
</div>
|
||||
<div className="adm-list">
|
||||
{rows.map((r) => (
|
||||
<AdminUserRow
|
||||
key={r.id}
|
||||
r={r}
|
||||
custom={!!names[r.id]}
|
||||
sup={sup}
|
||||
open={open === r.id}
|
||||
onToggle={() => setOpen((o) => (o === r.id ? null : r.id))}
|
||||
onNames={setNames}
|
||||
onRegs={setRegs}
|
||||
/>
|
||||
))}
|
||||
</div>
|
||||
{sup && <AddUser onRegs={setRegs} />}
|
||||
</Panel>
|
||||
</main>
|
||||
);
|
||||
}
|
||||
|
||||
function AdminUserRow({
|
||||
r,
|
||||
custom,
|
||||
sup,
|
||||
open,
|
||||
onToggle,
|
||||
onNames,
|
||||
onRegs,
|
||||
}: {
|
||||
r: Row;
|
||||
custom: boolean;
|
||||
sup: boolean;
|
||||
open: boolean;
|
||||
onToggle: () => void;
|
||||
onNames: (n: Record<string, string>) => void;
|
||||
onRegs: (u: AppUserRow[]) => void;
|
||||
}) {
|
||||
const { reloadUsers } = useData();
|
||||
const { auth, refreshMe } = useAuth();
|
||||
const [msg, setMsg] = useState<string | null>(null);
|
||||
const [busy, setBusy] = useState(false);
|
||||
const act = async (fn: () => Promise<{ users: AppUserRow[] }>) => {
|
||||
setBusy(true);
|
||||
setMsg(null);
|
||||
try {
|
||||
onRegs((await fn()).users);
|
||||
} catch (e) {
|
||||
setMsg(errText(e));
|
||||
} finally {
|
||||
setBusy(false);
|
||||
}
|
||||
};
|
||||
const role = r.reg?.role ?? null;
|
||||
return (
|
||||
<div className={`adm-row${open ? ' open' : ''}`}>
|
||||
<button className="adm-sum" onClick={onToggle} aria-expanded={open}>
|
||||
<Avatar user={r.user} name={r.name} src={r.avatar} size={30} />
|
||||
<span className="adm-nm">
|
||||
<b style={r.user ? { color: r.user.color } : undefined}>{r.name}</b>
|
||||
{custom && <span className="badge b-name">표시 이름</span>}
|
||||
{r.user?.excluded && <span className="badge b-excl">녹음 제외</span>}
|
||||
<span className="dim small mono">{r.id}</span>
|
||||
</span>
|
||||
<span className="adm-role">{role ? <span className={`badge b-role ${role}`}>{ROLE[role]}</span> : <span className="dim small">앱 미등록</span>}</span>
|
||||
<span className="adm-seen dim small">{r.reg?.lastSeenAt ? `앱 ${when(r.reg.lastSeenAt)}${r.reg.lastVersion ? ` · v${r.reg.lastVersion}` : ''}` : r.user ? '녹음 기록 있음' : ''}</span>
|
||||
<span className="adm-caret">{open ? '▴' : '▾'}</span>
|
||||
</button>
|
||||
{open && (
|
||||
<div className="adm-body">
|
||||
<div className="ue-label">표시 이름</div>
|
||||
<NameEditor
|
||||
value={r.name}
|
||||
custom={custom}
|
||||
onSave={async (name) => {
|
||||
const res = await api.adminSetName(r.id, name);
|
||||
onNames(res.names);
|
||||
// 게임 PC 앱이 이름을 받아 유저 목록을 다시 보낸다. 조금 기다렸다가 다시 받는다
|
||||
window.setTimeout(reloadUsers, 1500);
|
||||
if (auth.status === 'ok' && auth.me.user.id === r.id) await refreshMe();
|
||||
const regs = await api.adminUsers().catch(() => null);
|
||||
if (regs) onRegs(regs.users);
|
||||
}}
|
||||
/>
|
||||
{r.user ? (
|
||||
<AppUserEditor user={r.user} self={false} />
|
||||
) : (
|
||||
<div className="ue-hint">이 PC 녹음 기록에 없는 사람입니다. 음성채널에서 한 번 녹음되면 색 · 라이엇 ID · 녹음 제외를 바꿀 수 있습니다.</div>
|
||||
)}
|
||||
{r.user && (
|
||||
<Link className="mini-btn" to={`/users/${r.id}`}>
|
||||
기록 보기
|
||||
</Link>
|
||||
)}
|
||||
{sup && role !== 'superadmin' && (
|
||||
<div className="adm-acts">
|
||||
<div className="ue-label">앱 사용 (게임 PC 앱 로그인)</div>
|
||||
{role ? (
|
||||
<>
|
||||
<button className="btn sm" disabled={busy} onClick={() => void act(() => api.adminSetRole(r.id, role === 'admin' ? 'user' : 'admin'))}>
|
||||
{role === 'admin' ? '관리자 → 앱 유저로' : '앱 유저 → 관리자로'}
|
||||
</button>
|
||||
<button
|
||||
className="btn sm danger"
|
||||
disabled={busy}
|
||||
onClick={() => {
|
||||
if (window.confirm(`${r.name} 님의 앱 등록을 해제할까요? 그 사람의 겜녹이 앱이 바로 잠깁니다.`)) void act(() => api.adminRemoveUser(r.id));
|
||||
}}
|
||||
>
|
||||
등록 해제
|
||||
</button>
|
||||
</>
|
||||
) : (
|
||||
<>
|
||||
<button className="btn sm" disabled={busy} onClick={() => void act(() => api.adminAddUser(r.id, 'user'))}>
|
||||
앱 유저로 등록
|
||||
</button>
|
||||
<button className="btn sm" disabled={busy} onClick={() => void act(() => api.adminAddUser(r.id, 'admin'))}>
|
||||
관리자로 등록
|
||||
</button>
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
{msg && <div className="ue-msg bad">{msg}</div>}
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
function AddUser({ onRegs }: { onRegs: (u: AppUserRow[]) => void }) {
|
||||
const [id, setId] = useState('');
|
||||
const [role, setRole] = useState<'user' | 'admin'>('user');
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [msg, setMsg] = useState<{ ok: boolean; text: string } | null>(null);
|
||||
const ok = /^\d{17,20}$/.test(id.trim());
|
||||
return (
|
||||
<form
|
||||
className="adm-add"
|
||||
onSubmit={(e) => {
|
||||
e.preventDefault();
|
||||
if (!ok) return;
|
||||
setBusy(true);
|
||||
setMsg(null);
|
||||
api
|
||||
.adminAddUser(id.trim(), role)
|
||||
.then((r) => {
|
||||
onRegs(r.users);
|
||||
setMsg({ ok: true, text: '등록했습니다. 그 사람은 이제 겜녹이 앱에 로그인할 수 있습니다' });
|
||||
setId('');
|
||||
})
|
||||
.catch((e) => setMsg({ ok: false, text: errText(e) }))
|
||||
.finally(() => setBusy(false));
|
||||
}}
|
||||
>
|
||||
<div className="ue-label">디스코드 아이디로 앱 유저 등록</div>
|
||||
<div className="ue-row">
|
||||
<input className="ue-input mono" value={id} inputMode="numeric" placeholder="디스코드 아이디 (17~20자리 숫자)" onChange={(e) => setId(e.target.value)} aria-label="디스코드 아이디" />
|
||||
<select className="ue-input adm-sel" value={role} onChange={(e) => setRole(e.target.value as 'user' | 'admin')} aria-label="역할">
|
||||
<option value="user">앱 유저</option>
|
||||
<option value="admin">관리자</option>
|
||||
</select>
|
||||
<button className="btn sm primary" disabled={busy || !ok}>
|
||||
등록
|
||||
</button>
|
||||
</div>
|
||||
{msg && <div className={`ue-msg${msg.ok ? ' ok' : ' bad'}`}>{msg.text}</div>}
|
||||
</form>
|
||||
);
|
||||
}
|
||||
@@ -13,6 +13,7 @@ import { UtteranceRow } from '../components/UtteranceRow';
|
||||
import { KillLine, SeparatorRow } from '../components/EventRow';
|
||||
import { IPlay, IWaves } from '../components/Icons';
|
||||
import { matchMeta } from './MatchPage';
|
||||
import { ReplayPanel } from '../components/ReplayPanel';
|
||||
|
||||
const BUY_MS = 30000;
|
||||
/** "R7 · 0:38" → "0:38" */
|
||||
@@ -299,6 +300,7 @@ export function ValorantMatch({ m }: { m: MatchDetail }) {
|
||||
</div>
|
||||
<RoundStrip rounds={rounds} sel={round.num} onSelect={select} />
|
||||
</div>
|
||||
<ReplayPanel m={m} />
|
||||
<div className="mgrid">
|
||||
<Panel
|
||||
className="map-panel"
|
||||
|
||||
@@ -6,7 +6,7 @@ import { makeUnknownUserCheck } from '../lib/unknown-users';
|
||||
|
||||
// ── 로그인 ───────────────────────────────────────────
|
||||
type AuthState = { status: 'loading' } | { status: 'anon' } | { status: 'not_member' } | { status: 'ok'; me: Me };
|
||||
const AuthCtx = createContext<{ auth: AuthState; logout: () => void }>({ auth: { status: 'loading' }, logout: () => {} });
|
||||
const AuthCtx = createContext<{ auth: AuthState; logout: () => void; refreshMe: () => Promise<void> }>({ auth: { status: 'loading' }, logout: () => {}, refreshMe: async () => {} });
|
||||
|
||||
export function AuthProvider({ children }: { children: ReactNode }) {
|
||||
const [auth, setAuth] = useState<AuthState>({ status: 'loading' });
|
||||
@@ -28,7 +28,12 @@ export function AuthProvider({ children }: { children: ReactNode }) {
|
||||
const logout = useCallback(() => {
|
||||
void api.logout().finally(() => setAuth({ status: 'anon' }));
|
||||
}, []);
|
||||
return <AuthCtx.Provider value={{ auth, logout }}>{children}</AuthCtx.Provider>;
|
||||
// 내 표시 이름을 바꾼 뒤 머리글 이름을 다시 받는다
|
||||
const refreshMe = useCallback(async () => {
|
||||
const r = await api.me().catch(() => null);
|
||||
if (r?.ok) setAuth({ status: 'ok', me: r.me });
|
||||
}, []);
|
||||
return <AuthCtx.Provider value={{ auth, logout, refreshMe }}>{children}</AuthCtx.Provider>;
|
||||
}
|
||||
export const useAuth = () => useContext(AuthCtx);
|
||||
|
||||
@@ -123,8 +128,10 @@ interface DataValue {
|
||||
overview: Overview | null;
|
||||
users: User[];
|
||||
userById: (id: string | undefined | null) => User | undefined;
|
||||
/** 유저 목록 다시 받기 (유저 설정을 바꾼 뒤) */
|
||||
reloadUsers: () => void;
|
||||
}
|
||||
const DataCtx = createContext<DataValue>({ overview: null, users: [], userById: () => undefined });
|
||||
const DataCtx = createContext<DataValue>({ overview: null, users: [], userById: () => undefined, reloadUsers: () => {} });
|
||||
|
||||
export function DataProvider({ children }: { children: ReactNode }) {
|
||||
const { epoch, locked } = useStatus();
|
||||
@@ -163,6 +170,6 @@ export function DataProvider({ children }: { children: ReactNode }) {
|
||||
if (e.type === 'games.state') setOverview((o) => (o ? { ...o, live: e.data } : o));
|
||||
});
|
||||
const userById = useCallback((id: string | undefined | null) => (id ? map.get(id) : undefined), [map]);
|
||||
return <DataCtx.Provider value={{ overview, users, userById }}>{children}</DataCtx.Provider>;
|
||||
return <DataCtx.Provider value={{ overview, users, userById, reloadUsers }}>{children}</DataCtx.Provider>;
|
||||
}
|
||||
export const useData = () => useContext(DataCtx);
|
||||
|
||||
@@ -3934,3 +3934,418 @@ button.match:hover {
|
||||
opacity: 0.45;
|
||||
cursor: default;
|
||||
}
|
||||
|
||||
/* ── 3D 리플레이 (components/ReplayViewer.tsx) ── */
|
||||
.replay-panel {
|
||||
flex: none;
|
||||
}
|
||||
.match.val:has(.replay-panel.open) {
|
||||
height: auto;
|
||||
}
|
||||
.match.val:has(.replay-panel.open) .mgrid {
|
||||
flex: none;
|
||||
height: 680px;
|
||||
}
|
||||
.r3d {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 8px;
|
||||
}
|
||||
.r3d-stage {
|
||||
position: relative;
|
||||
height: min(72vh, 760px);
|
||||
min-height: 420px;
|
||||
border-radius: 10px;
|
||||
overflow: hidden;
|
||||
border: 1px solid var(--line);
|
||||
background: #0b141c;
|
||||
}
|
||||
.r3d-stage canvas {
|
||||
display: block;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
cursor: grab;
|
||||
}
|
||||
.r3d-stage canvas:active {
|
||||
cursor: grabbing;
|
||||
}
|
||||
.r3d-hud {
|
||||
position: absolute;
|
||||
z-index: 2;
|
||||
padding: 8px 12px;
|
||||
border-radius: 10px;
|
||||
background: rgba(8, 14, 20, 0.72);
|
||||
font-size: 14px;
|
||||
pointer-events: none;
|
||||
}
|
||||
.r3d-hud.tl {
|
||||
top: 10px;
|
||||
left: 10px;
|
||||
font-size: 16px;
|
||||
}
|
||||
.r3d-hud.tr {
|
||||
top: 10px;
|
||||
right: 10px;
|
||||
background: none;
|
||||
padding: 0;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 4px;
|
||||
align-items: flex-end;
|
||||
}
|
||||
.r3d-hud.bl {
|
||||
left: 10px;
|
||||
bottom: 10px;
|
||||
pointer-events: auto;
|
||||
}
|
||||
.r3d-kill {
|
||||
background: rgba(8, 14, 20, 0.78);
|
||||
border-radius: 8px;
|
||||
padding: 4px 10px;
|
||||
font-size: 13px;
|
||||
}
|
||||
.r3d .a {
|
||||
color: #8fd8ff;
|
||||
}
|
||||
.r3d .e {
|
||||
color: #ff9aa5;
|
||||
}
|
||||
.r3d-cap {
|
||||
position: absolute;
|
||||
z-index: 2;
|
||||
left: 50%;
|
||||
bottom: 14px;
|
||||
transform: translateX(-50%);
|
||||
max-width: min(70%, 760px);
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 4px;
|
||||
pointer-events: none;
|
||||
}
|
||||
.r3d-cap > div {
|
||||
background: rgba(8, 14, 20, 0.82);
|
||||
border-radius: 8px;
|
||||
padding: 6px 12px;
|
||||
font-size: 15px;
|
||||
text-align: center;
|
||||
}
|
||||
.r3d-cap b {
|
||||
color: var(--gold);
|
||||
margin-right: 6px;
|
||||
}
|
||||
.r3d-follow {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 6px;
|
||||
margin-top: 6px;
|
||||
font-size: 13px;
|
||||
cursor: pointer;
|
||||
}
|
||||
.r3d-bar {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 8px;
|
||||
}
|
||||
.r3d-play {
|
||||
min-width: 44px;
|
||||
}
|
||||
.r3d-scrub {
|
||||
position: relative;
|
||||
flex: 1;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
}
|
||||
.r3d-scrub input {
|
||||
width: 100%;
|
||||
accent-color: var(--accent);
|
||||
}
|
||||
.r3d-scrub i {
|
||||
position: absolute;
|
||||
top: -6px;
|
||||
width: 1px;
|
||||
height: 8px;
|
||||
background: var(--muted);
|
||||
pointer-events: none;
|
||||
}
|
||||
.r3d-foot {
|
||||
font-size: 12px;
|
||||
}
|
||||
.r3d-ceil {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
gap: 6px;
|
||||
}
|
||||
.r3d-ceil input {
|
||||
width: 90px;
|
||||
accent-color: var(--accent);
|
||||
}
|
||||
|
||||
/* ── 내 정보 · 관리 페이지 (v1.6.0) ───────────────── */
|
||||
.me-btn {
|
||||
padding: 4px 8px 4px 4px;
|
||||
border-radius: 20px;
|
||||
border: 1px solid transparent;
|
||||
transition: border-color 0.15s, background 0.15s;
|
||||
}
|
||||
.me-btn:hover,
|
||||
.me-btn[aria-expanded='true'] {
|
||||
border-color: var(--line);
|
||||
background: #15222f;
|
||||
}
|
||||
.me-caret {
|
||||
font-size: 10px;
|
||||
color: var(--dim);
|
||||
}
|
||||
.popover.profile-pop {
|
||||
right: 0;
|
||||
width: 360px;
|
||||
max-height: calc(100vh - var(--header-h) - 24px);
|
||||
overflow: auto;
|
||||
}
|
||||
.pp-head {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 10px;
|
||||
padding-bottom: 10px;
|
||||
border-bottom: 1px solid var(--line);
|
||||
margin-bottom: 4px;
|
||||
}
|
||||
.pp-head b {
|
||||
font-size: 15px;
|
||||
}
|
||||
.pp-links {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: 6px;
|
||||
margin-top: 14px;
|
||||
padding-top: 10px;
|
||||
border-top: 1px solid var(--line);
|
||||
}
|
||||
.ue-block {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 6px;
|
||||
}
|
||||
.ue-row {
|
||||
display: flex;
|
||||
gap: 6px;
|
||||
align-items: center;
|
||||
}
|
||||
.ue-input {
|
||||
flex: 1;
|
||||
min-width: 0;
|
||||
background: #0b141c;
|
||||
border: 1px solid var(--line);
|
||||
border-radius: 7px;
|
||||
padding: 6px 9px;
|
||||
font-size: 13px;
|
||||
color: var(--ink);
|
||||
}
|
||||
.ue-input:focus {
|
||||
outline: none;
|
||||
border-color: #3a5670;
|
||||
}
|
||||
.ue-label {
|
||||
font-size: 11.5px;
|
||||
color: var(--muted);
|
||||
margin-top: 6px;
|
||||
}
|
||||
.ue-hint {
|
||||
font-size: 11.5px;
|
||||
color: var(--dim);
|
||||
line-height: 1.5;
|
||||
display: block;
|
||||
}
|
||||
.ue-msg {
|
||||
font-size: 12px;
|
||||
}
|
||||
.ue-msg.ok {
|
||||
color: var(--good);
|
||||
}
|
||||
.ue-msg.bad {
|
||||
color: #ff8a8a;
|
||||
}
|
||||
.ue-colors {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: 6px;
|
||||
}
|
||||
.ue-sw {
|
||||
width: 22px;
|
||||
height: 22px;
|
||||
border-radius: 50%;
|
||||
border: 2px solid transparent;
|
||||
box-shadow: 0 0 0 1px #2c3f52;
|
||||
}
|
||||
.ue-sw.on {
|
||||
border-color: #fff;
|
||||
}
|
||||
.ue-sw.custom {
|
||||
background: var(--panel2);
|
||||
color: var(--muted);
|
||||
font-size: 13px;
|
||||
line-height: 1;
|
||||
}
|
||||
.ue-hidden {
|
||||
position: absolute;
|
||||
width: 0;
|
||||
height: 0;
|
||||
opacity: 0;
|
||||
pointer-events: none;
|
||||
}
|
||||
.ue-check {
|
||||
display: flex;
|
||||
gap: 8px;
|
||||
align-items: flex-start;
|
||||
font-size: 13px;
|
||||
margin-top: 6px;
|
||||
cursor: pointer;
|
||||
}
|
||||
.ue-check input {
|
||||
margin-top: 3px;
|
||||
accent-color: var(--accent);
|
||||
}
|
||||
.ue-check > span {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 2px;
|
||||
}
|
||||
.admin-page .panel {
|
||||
margin-bottom: 16px;
|
||||
}
|
||||
.adm-dev {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 6px;
|
||||
font-size: 13.5px;
|
||||
}
|
||||
.dot-st {
|
||||
display: inline-block;
|
||||
width: 8px;
|
||||
height: 8px;
|
||||
border-radius: 50%;
|
||||
background: #4a5866;
|
||||
vertical-align: middle;
|
||||
}
|
||||
.dot-st.on {
|
||||
background: var(--good);
|
||||
}
|
||||
.adm-update {
|
||||
margin-left: 10px;
|
||||
color: var(--gold);
|
||||
font-weight: 700;
|
||||
font-size: 12.5px;
|
||||
}
|
||||
.adm-search {
|
||||
max-width: 240px;
|
||||
}
|
||||
.adm-note {
|
||||
margin-bottom: 10px;
|
||||
}
|
||||
.adm-list {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 4px;
|
||||
}
|
||||
.adm-row {
|
||||
border: 1px solid var(--line);
|
||||
border-radius: 10px;
|
||||
background: #0f1923;
|
||||
}
|
||||
.adm-row.open {
|
||||
border-color: #34506a;
|
||||
}
|
||||
.adm-sum {
|
||||
width: 100%;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 10px;
|
||||
padding: 8px 12px;
|
||||
text-align: left;
|
||||
}
|
||||
.adm-nm {
|
||||
flex: 1;
|
||||
min-width: 0;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 8px;
|
||||
flex-wrap: wrap;
|
||||
}
|
||||
.adm-role {
|
||||
width: 96px;
|
||||
}
|
||||
.adm-seen {
|
||||
width: 200px;
|
||||
text-align: right;
|
||||
}
|
||||
.adm-caret {
|
||||
color: var(--dim);
|
||||
font-size: 11px;
|
||||
}
|
||||
.adm-body {
|
||||
padding: 4px 14px 14px 52px;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 6px;
|
||||
align-items: flex-start;
|
||||
}
|
||||
.adm-body > .ue-block {
|
||||
width: min(520px, 100%);
|
||||
}
|
||||
.adm-acts {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: 6px;
|
||||
align-items: center;
|
||||
}
|
||||
.adm-acts .ue-label {
|
||||
width: 100%;
|
||||
}
|
||||
.adm-add {
|
||||
margin-top: 14px;
|
||||
padding-top: 12px;
|
||||
border-top: 1px solid var(--line);
|
||||
max-width: 560px;
|
||||
}
|
||||
.adm-sel {
|
||||
flex: none;
|
||||
width: auto;
|
||||
}
|
||||
.b-name {
|
||||
background: #13283a;
|
||||
color: #8fc6ff;
|
||||
border: 1px solid #23415c;
|
||||
}
|
||||
.b-role.superadmin {
|
||||
background: #3a1820;
|
||||
color: #ff8a95;
|
||||
}
|
||||
.b-role.admin {
|
||||
background: #2b2412;
|
||||
color: var(--gold);
|
||||
}
|
||||
.b-role.user {
|
||||
background: #18303a;
|
||||
color: var(--mint);
|
||||
}
|
||||
.btn.danger {
|
||||
border-color: #5a2029;
|
||||
color: #ff8a8a;
|
||||
}
|
||||
@media (max-width: 760px) {
|
||||
.adm-seen,
|
||||
.adm-role {
|
||||
display: none;
|
||||
}
|
||||
.adm-body {
|
||||
padding-left: 14px;
|
||||
}
|
||||
.popover.profile-pop {
|
||||
position: fixed;
|
||||
top: calc(var(--header-h) + 6px);
|
||||
left: 8px;
|
||||
right: 8px;
|
||||
width: auto;
|
||||
max-height: calc(100vh - var(--header-h) - 16px);
|
||||
}
|
||||
}
|
||||
|
||||
4
tools/map-extract/.gitignore
vendored
Normal file
4
tools/map-extract/.gitignore
vendored
Normal file
@@ -0,0 +1,4 @@
|
||||
vendor/
|
||||
bin/
|
||||
obj/
|
||||
out/
|
||||
20
tools/map-extract/MapExtract.csproj
Normal file
20
tools/map-extract/MapExtract.csproj
Normal file
@@ -0,0 +1,20 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
<!-- 발로란트 맵 3D 모양 추출: Riot CDN 에서 필요한 부분만 읽어(게임 설치 · 전체 다운로드 없음) 맵마다 glb 하나.
|
||||
CUE4Parse 는 fetch-cue4parse.sh 로 vendor/ 에 받는다. 빌드: CUE4PARSE_SKIP_NATIVE=1 dotnet build -c Release -->
|
||||
<PropertyGroup>
|
||||
<OutputType>Exe</OutputType>
|
||||
<TargetFramework>net10.0</TargetFramework>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
<AssemblyName>gvr-map-extract</AssemblyName>
|
||||
<InvariantGlobalization>true</InvariantGlobalization>
|
||||
<EnableDefaultCompileItems>false</EnableDefaultCompileItems>
|
||||
<ServerGarbageCollection>false</ServerGarbageCollection>
|
||||
<ConcurrentGarbageCollection>false</ConcurrentGarbageCollection>
|
||||
</PropertyGroup>
|
||||
<ItemGroup>
|
||||
<Compile Include="src/**/*.cs" />
|
||||
<PackageReference Include="Serilog.Sinks.Console" Version="6.1.1" />
|
||||
<ProjectReference Include="vendor/CUE4Parse/CUE4Parse/CUE4Parse.csproj" />
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
15
tools/map-extract/fetch-cue4parse.sh
Executable file
15
tools/map-extract/fetch-cue4parse.sh
Executable file
@@ -0,0 +1,15 @@
|
||||
#!/usr/bin/env bash
|
||||
# CUE4Parse (Apache-2.0, https://github.com/FabianFG/CUE4Parse) 를 고정 커밋으로 받아 vendor/ 에 둔다.
|
||||
# 발로란트 패치로 읽기가 깨지면 CUE4PARSE_COMMIT 을 새 커밋으로 올린다.
|
||||
set -euo pipefail
|
||||
CUE4PARSE_COMMIT="${CUE4PARSE_COMMIT:-605672df7a993a90094bad92d30c388d87ae6c1a}"
|
||||
here="$(cd "$(dirname "$0")" && pwd)"
|
||||
dst="$here/vendor/CUE4Parse"
|
||||
if [ ! -d "$dst/.git" ]; then
|
||||
git clone --quiet https://github.com/FabianFG/CUE4Parse "$dst"
|
||||
fi
|
||||
if [ "$(git -C "$dst" rev-parse HEAD)" != "$CUE4PARSE_COMMIT" ]; then
|
||||
git -C "$dst" fetch --quiet origin
|
||||
git -C "$dst" checkout --quiet --force "$CUE4PARSE_COMMIT"
|
||||
fi
|
||||
echo "CUE4Parse @ $(git -C "$dst" rev-parse --short HEAD)"
|
||||
62
tools/map-extract/scripts/install.sh
Executable file
62
tools/map-extract/scripts/install.sh
Executable file
@@ -0,0 +1,62 @@
|
||||
#!/usr/bin/env bash
|
||||
# 맵 3D 자동 갱신을 이 리눅스 서버(.9)에 설치한다. 저장소에서: tools/map-extract/scripts/install.sh
|
||||
# - gvr-map-extract 를 빌드해 $GVR_MAPS_HOME/bin 에 둔다 (저장소 작업 폴더가 바뀌어도 타이머는 그대로 돈다)
|
||||
# - systemd 사용자 타이머 gvr-maps-update.timer (30분마다 update.sh). 메모리 6GB · CPU 3코어 상한, 봇과 다른 cgroup
|
||||
# 코드를 고쳤으면 다시 실행하면 된다. 지금 바로 한 번 돌리기: systemctl --user start gvr-maps-update
|
||||
set -euo pipefail
|
||||
here="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
GVR_MAPS_HOME="${GVR_MAPS_HOME:-$HOME/gvr-maps}"
|
||||
export PATH="$HOME/.dotnet:$PATH" DOTNET_ROOT="${DOTNET_ROOT:-$HOME/.dotnet}" DOTNET_CLI_TELEMETRY_OPTOUT=1
|
||||
"$here/fetch-cue4parse.sh"
|
||||
rm -rf "$GVR_MAPS_HOME/bin.new"
|
||||
CUE4PARSE_SKIP_NATIVE=1 dotnet build "$here/MapExtract.csproj" -c Release -o "$GVR_MAPS_HOME/bin.new" -v quiet -nologo -clp:ErrorsOnly
|
||||
rm -rf "$GVR_MAPS_HOME/bin.old"
|
||||
[ -d "$GVR_MAPS_HOME/bin" ] && mv "$GVR_MAPS_HOME/bin" "$GVR_MAPS_HOME/bin.old"
|
||||
mv "$GVR_MAPS_HOME/bin.new" "$GVR_MAPS_HOME/bin"
|
||||
# Oodle 압축 풀기 라이브러리: 처음 실행 때 받는다. 이전 설치에 있으면 옮겨 둔다
|
||||
[ -f "$GVR_MAPS_HOME/bin.old/liboodle-data-shared.so" ] && cp "$GVR_MAPS_HOME/bin.old/liboodle-data-shared.so" "$GVR_MAPS_HOME/bin/"
|
||||
rm -rf "$GVR_MAPS_HOME/bin.old"
|
||||
mkdir -p "$GVR_MAPS_HOME/scripts"
|
||||
cp "$here/scripts/update.sh" "$here/scripts/pack.py" "$here/scripts/preview.py" "$GVR_MAPS_HOME/scripts/"
|
||||
chmod +x "$GVR_MAPS_HOME/scripts/update.sh"
|
||||
|
||||
unit="$HOME/.config/systemd/user"
|
||||
mkdir -p "$unit"
|
||||
node_dir="$(dirname "$(command -v node)")"
|
||||
cat > "$unit/gvr-maps-update.service" <<EOF
|
||||
[Unit]
|
||||
Description=겜녹이: 발로란트 맵 3D 자동 갱신 (uedb 매핑 · 라이브 패치 확인 → 추출 → 사이트 반영)
|
||||
After=network-online.target
|
||||
|
||||
[Service]
|
||||
Type=oneshot
|
||||
Environment=GVR_MAPS_HOME=$GVR_MAPS_HOME
|
||||
Environment=DOTNET_ROOT=$DOTNET_ROOT
|
||||
Environment=PATH=$node_dir:$HOME/.dotnet:/usr/local/bin:/usr/bin:/bin
|
||||
Environment=TMPDIR=$HOME/.tmp
|
||||
Environment=NOTIFY_CHANNEL=${NOTIFY_CHANNEL:-}
|
||||
Environment=NOTIFY_ENV=${NOTIFY_ENV:-}
|
||||
ExecStart=$GVR_MAPS_HOME/scripts/update.sh
|
||||
MemoryMax=6G
|
||||
MemorySwapMax=0
|
||||
CPUQuota=300%
|
||||
CPUWeight=50
|
||||
Nice=10
|
||||
TimeoutStartSec=2h
|
||||
EOF
|
||||
cat > "$unit/gvr-maps-update.timer" <<EOF
|
||||
[Unit]
|
||||
Description=겜녹이: 발로란트 맵 3D 자동 갱신 (30분마다)
|
||||
|
||||
[Timer]
|
||||
OnBootSec=5min
|
||||
OnUnitActiveSec=30min
|
||||
RandomizedDelaySec=2min
|
||||
Persistent=true
|
||||
|
||||
[Install]
|
||||
WantedBy=timers.target
|
||||
EOF
|
||||
systemctl --user daemon-reload
|
||||
systemctl --user enable --now gvr-maps-update.timer
|
||||
echo "설치 완료: $GVR_MAPS_HOME · $(systemctl --user list-timers gvr-maps-update.timer --no-legend | head -1)"
|
||||
33
tools/map-extract/scripts/pack.py
Executable file
33
tools/map-extract/scripts/pack.py
Executable file
@@ -0,0 +1,33 @@
|
||||
#!/usr/bin/env python3
|
||||
"""gvr-map-extract 결과(<코드>.glb + <코드>.json)를 사이트용으로 압축한다.
|
||||
pack.py <추출 폴더> <출력 폴더> <버전(예: VALORANT_13.08)>
|
||||
출력: <출력>/<dir>/<코드>.glb.gz (gltfpack -cc 로 meshopt 압축 · 위치 양자화 → gzip) + <출력>/index.json
|
||||
사이트 서버 data/maps3d 에 그대로 올리면 된다 (site/server/src/maps3d.ts)."""
|
||||
import datetime, gzip, json, os, re, shutil, subprocess, sys
|
||||
|
||||
src, out, version = sys.argv[1], sys.argv[2], sys.argv[3]
|
||||
stamp = datetime.datetime.now(datetime.timezone.utc).strftime('%Y%m%d%H%M')
|
||||
d = re.sub(r'[^\w.-]', '_', f'{version}-{stamp}')
|
||||
os.makedirs(os.path.join(out, d), exist_ok=True)
|
||||
maps = {}
|
||||
for name in sorted(os.listdir(src)):
|
||||
if not name.endswith('.json'):
|
||||
continue
|
||||
info = json.load(open(os.path.join(src, name)))
|
||||
code = info['code']
|
||||
glb = os.path.join(src, code + '.glb')
|
||||
if not os.path.exists(glb) or info.get('triangles', 0) == 0:
|
||||
continue
|
||||
packed = os.path.join(out, d, code + '.glb')
|
||||
subprocess.run(['npx', '-y', 'gltfpack@1.3.0', '-i', glb, '-o', packed, '-cc'], check=True, stdout=subprocess.DEVNULL)
|
||||
with open(packed, 'rb') as f, gzip.open(packed + '.gz', 'wb', 9) as g:
|
||||
shutil.copyfileobj(f, g)
|
||||
os.remove(packed)
|
||||
size = os.path.getsize(packed + '.gz')
|
||||
maps[info['mapUrl']] = {'code': code, 'file': code + '.glb', 'bytes': size, 'triangles': info['triangles']}
|
||||
print(f"{code}: {info['triangles']} 삼각형 → {size / 1e6:.1f}MB")
|
||||
idx = {'version': version, 'dir': d, 'updatedAt': datetime.datetime.now(datetime.timezone.utc).isoformat(), 'maps': maps}
|
||||
tmp = os.path.join(out, 'index.json.tmp')
|
||||
json.dump(idx, open(tmp, 'w'), ensure_ascii=False, indent=1)
|
||||
os.replace(tmp, os.path.join(out, 'index.json'))
|
||||
print(f'index.json: 맵 {len(maps)}개 · 폴더 {d}')
|
||||
43
tools/map-extract/scripts/preview.py
Executable file
43
tools/map-extract/scripts/preview.py
Executable file
@@ -0,0 +1,43 @@
|
||||
#!/usr/bin/env python3
|
||||
"""추출한 맵 glb 를 위에서 본 그림(PNG)으로 그린다. 확인용.
|
||||
preview.py <맵.glb> <출력.png> [천장 cm (이보다 높은 삼각형 제외)]
|
||||
삼각형마다 무게중심 · 꼭짓점을 찍고 높은 것이 위에 오게 칠한다 (빠른 근사)."""
|
||||
import json, struct, sys
|
||||
import numpy as np
|
||||
from PIL import Image
|
||||
|
||||
src, dst = sys.argv[1], sys.argv[2]
|
||||
zmax = float(sys.argv[3]) if len(sys.argv) > 3 else None
|
||||
b = open(src, 'rb').read()
|
||||
jl = struct.unpack('<I', b[12:16])[0]
|
||||
j = json.loads(b[20:20 + jl])
|
||||
bin_ = b[20 + jl + 8:]
|
||||
pa, ia = j['accessors'][0], j['accessors'][1]
|
||||
pv, iv = j['bufferViews'][pa['bufferView']], j['bufferViews'][ia['bufferView']]
|
||||
P = np.frombuffer(bin_, '<f4', pa['count'] * 3, pv.get('byteOffset', 0)).reshape(-1, 3)
|
||||
I = np.frombuffer(bin_, '<u4', ia['count'], iv.get('byteOffset', 0)).reshape(-1, 3)
|
||||
T = P[I] # (n,3,3)
|
||||
if zmax is not None:
|
||||
T = T[T[:, :, 2].max(1) < zmax]
|
||||
# 면 방향 음영
|
||||
n = np.cross(T[:, 1] - T[:, 0], T[:, 2] - T[:, 0])
|
||||
n /= np.linalg.norm(n, axis=1, keepdims=True) + 1e-9
|
||||
lum = 0.35 + 0.65 * np.abs(n @ np.array([0.3, 0.5, 0.81]))
|
||||
pts = np.concatenate([T.mean(1), T[:, 0], T[:, 1], T[:, 2], (T[:, 0] + T[:, 1]) / 2, (T[:, 1] + T[:, 2]) / 2, (T[:, 0] + T[:, 2]) / 2])
|
||||
L = np.tile(lum, 7)
|
||||
lo, hi = np.percentile(pts, 0.5, axis=0), np.percentile(pts, 99.5, axis=0)
|
||||
size = 1400
|
||||
s = (size - 20) / max(hi[0] - lo[0], hi[1] - lo[1])
|
||||
# 미니맵과 같은 방향: 화면 x = 월드 y, 화면 아래 = 월드 x 감소
|
||||
x = ((pts[:, 1] - lo[1]) * s + 10).astype(int)
|
||||
y = ((hi[0] - pts[:, 0]) * s + 10).astype(int)
|
||||
W, H = int((hi[1] - lo[1]) * s + 20), int((hi[0] - lo[0]) * s + 20)
|
||||
ok = (x >= 0) & (x < W) & (y >= 0) & (y < H)
|
||||
x, y, z, L = x[ok], y[ok], pts[ok, 2], L[ok]
|
||||
order = np.argsort(z) # 낮은 것 먼저, 높은 것이 덮는다
|
||||
img = np.zeros((H, W, 3), np.float32) + np.array([18, 20, 26], np.float32) / 255
|
||||
zn = np.clip((z - lo[2]) / (hi[2] - lo[2] + 1e-9), 0, 1)
|
||||
col = np.stack([0.35 + 0.45 * zn, 0.40 + 0.35 * zn, 0.55 - 0.15 * zn], 1) * L[:, None]
|
||||
img[y[order], x[order]] = col[order]
|
||||
Image.fromarray((np.clip(img, 0, 1) * 255).astype(np.uint8)).save(dst)
|
||||
print(dst, W, H, 'triangles', len(T), 'z', lo[2].round(), hi[2].round())
|
||||
52
tools/map-extract/scripts/test-update.sh
Executable file
52
tools/map-extract/scripts/test-update.sh
Executable file
@@ -0,0 +1,52 @@
|
||||
#!/usr/bin/env bash
|
||||
# update.sh 시험 (네트워크 · 사이트 서버 없이): 가짜 추출기 · 가짜 pack.py · ssh/scp 를 로컬 복사로 바꿔
|
||||
# 성공 → 변경 없음 → 추출 실패(첫 실패만 알림, 대기) → 재시도 간격 2배 → 맵 누락이면 안 올림 → 압축 실패 → 복구 → uedb 장애
|
||||
set -uo pipefail
|
||||
UPD="$(cd "$(dirname "$0")" && pwd)/update.sh"
|
||||
T="$(mktemp -d "${TMPDIR:-/tmp}/gvr-upd-test.XXXXXX")"
|
||||
trap 'rm -rf "$T"' EXIT
|
||||
mkdir -p "$T/home/scripts" "$T/shim" "$T/site"
|
||||
cat > "$T/shim/ssh" <<'E'
|
||||
#!/bin/bash
|
||||
while [[ "$1" == -* ]]; do shift 2; done; shift; exec bash -c "$*"
|
||||
E
|
||||
cat > "$T/shim/scp" <<'E'
|
||||
#!/bin/bash
|
||||
a=(); s=0; for x in "$@"; do [ $s = 1 ] && { s=0; continue; }; [ "$x" = -o ] && { s=1; continue; }; [[ "$x" == -* ]] && continue; a+=("${x#*:}"); done; cp "${a[0]}" "${a[1]}"
|
||||
E
|
||||
cat > "$T/fakebin" <<'E'
|
||||
#!/bin/bash
|
||||
[ "$1" = manifest ] && { echo "https://x/releases/${FAKE_MANIFEST:-AAA}.manifest"; exit 0; }
|
||||
[ "${FAKE_FAIL:-}" = extract ] && exit 1
|
||||
for m in ${FAKE_MAPS:-Ascent Bind}; do echo "{\"code\":\"$m\",\"mapUrl\":\"/Game/Maps/$m/$m\",\"triangles\":10}" > "$2/$m.json"; echo glb > "$2/$m.glb"; done
|
||||
E
|
||||
cat > "$T/home/scripts/pack.py" <<'E'
|
||||
import json, os, sys
|
||||
src, out, ver = sys.argv[1:4]; d = ver + '-' + os.environ.get('FAKE_STAMP', '1'); os.makedirs(f'{out}/{d}', exist_ok=True); maps = {}
|
||||
for n in os.listdir(src):
|
||||
if n.endswith('.json'):
|
||||
i = json.load(open(f'{src}/{n}')); open(f"{out}/{d}/{i['code']}.glb.gz", 'w').write('x'); maps[i['mapUrl']] = {'code': i['code'], 'file': i['code'] + '.glb', 'bytes': 1, 'triangles': 10}
|
||||
json.dump({'version': ver, 'dir': d, 'maps': maps}, open(f'{out}/index.json', 'w'))
|
||||
E
|
||||
chmod +x "$T/shim/"* "$T/fakebin"
|
||||
echo usmap > "$T/m_br.usmap"
|
||||
echo "{\"version\":\"V1\",\"updated\":\"2026-10-17T00:00:00Z\",\"mappings\":{\"Brotli\":\"file://$T/m_br.usmap\"}}" > "$T/uedb.json"
|
||||
run() { PATH="$T/shim:$PATH" GVR_MAPS_HOME="$T/home" SITE_HOST=x SITE_DATA="$T/site" UEDB="file://$T/uedb.json" BIN="$T/fakebin" SECRETS=/nonexistent NOTIFY_CHANNEL= bash "$UPD" "$@" 2>&1; }
|
||||
st() { python3 -c 'import json,sys; print(json.load(open(sys.argv[1])).get(sys.argv[2], ""))' "$T/home/state.json" "$1"; }
|
||||
ready() { python3 -c 'import json,sys; f=sys.argv[1]; d=json.load(open(f)); d["retryAt"]="0"; json.dump(d, open(f, "w"))' "$T/home/state.json"; }
|
||||
maps() { jq -c '.maps | keys' "$T/site/maps3d/index.json"; }
|
||||
fail=0
|
||||
ok() { if eval "$2"; then echo "ok - $1"; else echo "not ok - $1"; fail=1; fi; }
|
||||
|
||||
o="$(run)"; ok "처음: 올리고 알림" '[[ "$o" == *"사이트 반영 완료: 맵 2"* && "$o" == *"알림: 🗺️"* && "$(maps)" == *Bind* ]]'
|
||||
o="$(run)"; ok "같으면 변경 없음" '[[ "$o" == *"변경 없음"* ]]'
|
||||
o="$(FAKE_MANIFEST=BBB FAKE_FAIL=extract run)"; ok "추출 실패: 첫 실패 알림 · 30분 대기" '[[ "$o" == *"알림: ⚠️"* && "$o" == *"30분 뒤"* && "$(st failCount)" == 1 ]]'
|
||||
o="$(FAKE_MANIFEST=BBB run)"; ok "대기 중에는 다시 안 함" '[[ "$o" == *"이후 다시"* ]]'
|
||||
ready; o="$(FAKE_MANIFEST=BBB FAKE_FAIL=extract run)"; ok "재실패: 알림 없이 간격 2배" '[[ "$o" != *"알림:"* && "$o" == *"60분 뒤"* && "$(st failCount)" == 2 ]]'
|
||||
ready; o="$(FAKE_MANIFEST=BBB FAKE_MAPS=Ascent FAKE_STAMP=2 run)"; ok "맵이 빠진 결과는 안 올림" '[[ "$o" == *"빠진 맵: /Game/Maps/Bind/Bind"* && "$(maps)" == *Bind* ]]'
|
||||
ready; mv "$T/home/scripts/pack.py" "$T/pack.bak"; o="$(FAKE_MANIFEST=BBB run)"; mv "$T/pack.bak" "$T/home/scripts/pack.py"
|
||||
ok "압축 실패도 같은 실패 처리" '[[ "$o" == *"압축 단계"* ]]'
|
||||
ready; o="$(FAKE_MANIFEST=BBB FAKE_MAPS="Ascent Bind Haven" FAKE_STAMP=3 run)"; ok "복구: 새 맵 포함해 올리고 이전 폴더 하나만 남김" '[[ "$o" == *"맵 3 개"* && "$(maps)" == *Haven* && "$(ls "$T/site/maps3d" | tr "\n" " ")" == "V1-1 V1-3 index.json " && "$(st failCount)" == 0 ]]'
|
||||
mv "$T/uedb.json" "$T/uedb.bak"; o="$(FAKE_MANIFEST=CCC run)"; mv "$T/uedb.bak" "$T/uedb.json"; ok "uedb 장애: 확인 실패 횟수만 셈" '[[ "$o" == *"확인 실패 (1 번째"* ]]'
|
||||
o="$(FAKE_MANIFEST=DDD FAKE_MAPS=Ascent FAKE_STAMP=4 run --force)"; ok "--force 면 빠진 맵도 올림" '[[ "$(maps)" == "[\"/Game/Maps/Ascent/Ascent\"]" ]]'
|
||||
exit $fail
|
||||
153
tools/map-extract/scripts/update.sh
Executable file
153
tools/map-extract/scripts/update.sh
Executable file
@@ -0,0 +1,153 @@
|
||||
#!/usr/bin/env bash
|
||||
# 발로란트 맵 3D 자동 갱신 (systemd 타이머가 30분마다 실행, install.sh 참고)
|
||||
#
|
||||
# 1. uedb.dev 발로란트 매핑(.usmap) 버전 · 라이브 패치 매니페스트를 본다. 지난번에 올린 것과 같으면 끝
|
||||
# 2. 새 매핑이면 받아서 보관한다: $GVR_MAPS_HOME/mappings/ + nextcloud claude/game-voice-recorder/valorant/mappings/
|
||||
# 3. 모든 맵을 Riot CDN 에서 바로 뽑고(gvr-map-extract, 필요한 조각만 받음 · 디스크 거의 안 씀) 압축한다 (pack.py)
|
||||
# 4. 사이트 서버(.5) data/maps3d 에 올리고 index.json 을 바꿔 끼운다 → 사이트가 바로 새 맵을 쓴다
|
||||
#
|
||||
# 실패하면(어느 단계든) 사이트는 이전 맵을 그대로 쓰고, 같은 조합은 30분 · 1시간 · 2시간 … 최대 6시간 간격으로 다시 해 본다.
|
||||
# 처음 실패 · 다시 성공했을 때 알린다. 지금 올라가 있는 맵 중 하나라도 새 결과에 없으면 올리지 않는다 (일부 누락 방지).
|
||||
# 강제로 다시(대기 · 누락 검사 무시): update.sh --force
|
||||
set -Eeuo pipefail
|
||||
GVR_MAPS_HOME="${GVR_MAPS_HOME:-$HOME/gvr-maps}"
|
||||
SITE_HOST="${SITE_HOST:-root@192.168.10.5}"
|
||||
SITE_DATA="${SITE_DATA:-/root/other/game-voice-recorder/data}"
|
||||
UEDB="${UEDB:-https://uedb.dev/svc/api/v1/valorant/mappings}"
|
||||
SECRETS="${SECRETS:-$HOME/.config/ejclaw/secrets.json}"
|
||||
export DOTNET_ROOT="${DOTNET_ROOT:-$HOME/.dotnet}"
|
||||
BIN="${BIN:-$GVR_MAPS_HOME/bin/gvr-map-extract}"
|
||||
STATE="$GVR_MAPS_HOME/state.json"
|
||||
mkdir -p "$GVR_MAPS_HOME/mappings" "$GVR_MAPS_HOME/work"
|
||||
exec 9>"$GVR_MAPS_HOME/.lock"
|
||||
flock -n 9 || { echo "이미 실행 중"; exit 0; }
|
||||
log() { echo "[$(date '+%F %T')] $*"; }
|
||||
# 결과 알림 (선택): NOTIFY_CHANNEL=<디스코드 채널 id>, NOTIFY_ENV=<DISCORD_OWNER_BOT_TOKEN 이 든 .env>
|
||||
notify() {
|
||||
log "알림: $1"
|
||||
[ -n "${NOTIFY_CHANNEL:-}" ] && [ -f "${NOTIFY_ENV:-}" ] || return 0
|
||||
local token
|
||||
token="$(grep -E '^DISCORD_OWNER_BOT_TOKEN=' "$NOTIFY_ENV" | head -1 | sed -E 's/^[^=]+=//' | tr -d '"'\''\r')"
|
||||
[ -n "$token" ] || return 0
|
||||
curl -sS -o /dev/null --max-time 20 -X POST "https://discord.com/api/v10/channels/$NOTIFY_CHANNEL/messages" \
|
||||
-H "Authorization: Bot $token" -H 'Content-Type: application/json' \
|
||||
-d "$(jq -nc --arg c "$1" '{content:$c, allowed_mentions:{parse:[]}}')" || true
|
||||
}
|
||||
st() { python3 -c 'import json,sys; d=json.load(open(sys.argv[1])) if __import__("os").path.exists(sys.argv[1]) else {}; print(d.get(sys.argv[2],""))' "$STATE" "$1"; }
|
||||
stn() { local v; v="$(st "$1")"; echo "${v:-0}"; }
|
||||
set_state() { python3 - "$STATE" "$@" <<'P'
|
||||
import json, os, sys
|
||||
f = sys.argv[1]
|
||||
d = json.load(open(f)) if os.path.exists(f) else {}
|
||||
for kv in sys.argv[2:]:
|
||||
k, v = kv.split('=', 1)
|
||||
d[k] = v
|
||||
json.dump(d, open(f + '.tmp', 'w'), indent=1)
|
||||
os.replace(f + '.tmp', f)
|
||||
P
|
||||
}
|
||||
|
||||
FORCE=0
|
||||
[ "${1:-}" = "--force" ] && FORCE=1
|
||||
stage="확인"
|
||||
key=""
|
||||
# 어느 단계에서 실패해도: 상태 기록(다음 재시도 시각) · 처음 실패면 알림. 사이트의 이전 맵은 그대로
|
||||
on_fail() {
|
||||
local rc=$?
|
||||
# $(...) 안에서 난 오류는 바깥 셸이 한 번 더 받는다 → 바깥에서만 처리
|
||||
[ "$BASHPID" = "$$" ] || exit "$rc"
|
||||
trap - ERR
|
||||
if [ -z "$key" ]; then
|
||||
# uedb · 매니페스트 확인 단계 (네트워크 문제 등). 3시간(6번) 연속이면 한 번 알림
|
||||
local n=$(( $(stn checkFails) + 1 ))
|
||||
set_state "checkFails=$n"
|
||||
log "확인 실패 ($n 번째 연속)"
|
||||
[ "$n" = 6 ] && notify "⚠️ 발로란트 맵 3D 자동 갱신: uedb · Riot 패치 확인이 3시간째 실패합니다. 로그: journalctl --user -u gvr-maps-update"
|
||||
exit "$rc"
|
||||
fi
|
||||
local n=1
|
||||
[ "$key" = "$(st failed)" ] && n=$(( $(stn failCount) + 1 ))
|
||||
local wait=$(( 1800 * (1 << (n > 5 ? 4 : n - 1)) ))
|
||||
[ "$wait" -gt 21600 ] && wait=21600
|
||||
set_state "failed=$key" "failCount=$n" "failedAt=$(date -Is)" "retryAt=$(( $(date +%s) + wait - 120 ))" "failStage=$stage"
|
||||
log "실패 ($stage 단계, $n 번째) → 사이트는 이전 맵 유지, $(( wait / 60 ))분 뒤 다시"
|
||||
[ "$n" = 1 ] && notify "⚠️ 발로란트 맵 3D 자동 갱신 실패 ($stage 단계 · 매핑 $version · 패치 $(basename "$manifest" .manifest)). 사이트는 이전 맵을 그대로 쓰고, 간격을 늘려 가며 다시 해 봅니다. 로그: journalctl --user -u gvr-maps-update"
|
||||
exit "$rc"
|
||||
}
|
||||
trap on_fail ERR
|
||||
|
||||
# 1. 바뀐 것이 있나
|
||||
meta="$(curl -fsS --max-time 30 "$UEDB")"
|
||||
version="$(jq -r .version <<<"$meta")"
|
||||
updated="$(jq -r .updated <<<"$meta")"
|
||||
usmap_url="$(jq -r '.mappings.Brotli // .mappings.ZStandard' <<<"$meta")"
|
||||
[ -n "$version" ] && [ "$version" != null ] && [ -n "$usmap_url" ] && [ "$usmap_url" != null ] || { log "uedb 응답 이상: $meta"; false; }
|
||||
manifest="$("$BIN" manifest)"
|
||||
set_state "checkFails=0"
|
||||
if [ "$version|$updated|$manifest" = "$(st published)" ] && [ "$FORCE" = 0 ]; then
|
||||
log "변경 없음 ($version, $(basename "$manifest"))"
|
||||
exit 0
|
||||
fi
|
||||
key="$version|$updated|$manifest"
|
||||
if [ "$FORCE" = 0 ] && [ "$key" = "$(st failed)" ] && [ "$(date +%s)" -lt "$(stn retryAt)" ]; then
|
||||
log "지난번 실패($(st failStage) 단계, $(st failCount)번) → $(date -d "@$(st retryAt)" '+%H:%M') 이후 다시"
|
||||
exit 0
|
||||
fi
|
||||
log "새로 뽑기: 매핑 $version ($updated) · 패치 $(basename "$manifest")"
|
||||
stage="매핑 받기"
|
||||
|
||||
# 2. 매핑 받기 · 보관
|
||||
stamp="$(date -u -d "$updated" +%Y%m%d%H%M 2>/dev/null || date -u +%Y%m%d%H%M)"
|
||||
usmap="$GVR_MAPS_HOME/mappings/${version}_${stamp}_$(basename "$usmap_url" | sed 's/^.*_\(br\|zs\)\.usmap$/\1/').usmap"
|
||||
if [ ! -s "$usmap" ]; then
|
||||
curl -fsS --max-time 300 -o "$usmap.part" "$usmap_url"
|
||||
mv "$usmap.part" "$usmap"
|
||||
log "매핑 저장 $usmap ($(stat -c %s "$usmap") 바이트)"
|
||||
# nextcloud 보관 (claude/ 폴더 안만 쓴다, 사용자 규칙)
|
||||
if [ -f "$SECRETS" ]; then
|
||||
read -r nc_host nc_user nc_token < <(python3 -c 'import json,sys; c=json.load(open(sys.argv[1]))["credentials"]["nextcloud.192.168.10.10"]; print(c["host"], c["username"], c["token"])' "$SECRETS") || true
|
||||
if [ -n "${nc_token:-}" ]; then
|
||||
dav="$nc_host/remote.php/dav/files/$nc_user/claude/game-voice-recorder/valorant/mappings"
|
||||
curl -fsS -u "$nc_user:$nc_token" -X MKCOL "$nc_host/remote.php/dav/files/$nc_user/claude/game-voice-recorder/valorant" >/dev/null 2>&1 || true
|
||||
curl -fsS -u "$nc_user:$nc_token" -X MKCOL "$dav" >/dev/null 2>&1 || true
|
||||
if curl -fsS -u "$nc_user:$nc_token" -T "$usmap" "$dav/$(basename "$usmap")" >/dev/null; then log "nextcloud 보관 완료"; else log "nextcloud 보관 실패 (계속 진행)"; fi
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
# 3. 뽑기 · 압축
|
||||
stage="추출"
|
||||
raw="$GVR_MAPS_HOME/work/raw"
|
||||
out="$GVR_MAPS_HOME/work/out"
|
||||
rm -rf "$raw" "$out"
|
||||
mkdir -p "$raw" "$out"
|
||||
GVR_USMAP="$usmap" GVR_MANIFEST="$manifest" "$BIN" extract "$raw"
|
||||
stage="압축"
|
||||
python3 "$GVR_MAPS_HOME/scripts/pack.py" "$raw" "$out" "$version"
|
||||
dir="$(jq -r .dir "$out/index.json")"
|
||||
count="$(jq '.maps | length' "$out/index.json")"
|
||||
|
||||
# 지금 사이트에 있는 맵이 새 결과에 다 있어야 올린다 (일부만 뽑힌 결과로 덮어쓰지 않게)
|
||||
stage="맵 목록 대조"
|
||||
cur="$(ssh -o BatchMode=yes "$SITE_HOST" "cat '$SITE_DATA/maps3d/index.json' 2>/dev/null || echo '{}'")"
|
||||
prev="$(jq -r '.dir // empty' <<<"$cur")"
|
||||
missing="$(jq -rn --argjson a "$cur" --slurpfile b "$out/index.json" '[($a.maps // {}) | keys[] as $k | select(($b[0].maps | has($k)) | not) | $k] | join(", ")')"
|
||||
if [ -n "$missing" ] && [ "$FORCE" = 0 ]; then
|
||||
log "새 결과에 빠진 맵: $missing → 올리지 않음 (게임에서 정말 빠진 맵이면 update.sh --force)"
|
||||
false
|
||||
fi
|
||||
[ "$count" -gt 0 ] || { log "맵 0개 → 올리지 않음"; false; }
|
||||
|
||||
# 4. 사이트 서버에 올리기 (폴더 먼저, index.json 은 마지막에 바꿔 끼움)
|
||||
stage="사이트 올리기"
|
||||
ssh -o BatchMode=yes "$SITE_HOST" "mkdir -p '$SITE_DATA/maps3d'"
|
||||
tar -C "$out" -cf - "$dir" | ssh -o BatchMode=yes "$SITE_HOST" "tar -xf - -C '$SITE_DATA/maps3d'"
|
||||
scp -q -o BatchMode=yes "$out/index.json" "$SITE_HOST:$SITE_DATA/maps3d/index.json.tmp"
|
||||
ssh -o BatchMode=yes "$SITE_HOST" "mv '$SITE_DATA/maps3d/index.json.tmp' '$SITE_DATA/maps3d/index.json'"
|
||||
# 지금 것과 바로 전 것(이미 열어 둔 화면용)만 남긴다
|
||||
ssh -o BatchMode=yes "$SITE_HOST" "cd '$SITE_DATA/maps3d' && for d in */; do d=\${d%/}; [ \"\$d\" = '$dir' ] || [ \"\$d\" = '$prev' ] || rm -rf -- \"\$d\"; done"
|
||||
trap - ERR
|
||||
set_state "published=$key" "publishedAt=$(date -Is)" "dir=$dir" "failed=" "failCount=0" "retryAt=0"
|
||||
rm -rf "$raw" "$out"
|
||||
log "사이트 반영 완료: 맵 $count 개 · $dir"
|
||||
notify "🗺️ 발로란트 맵 3D 자동 갱신: 매핑 $version · 맵 ${count}개를 사이트에 반영했습니다"
|
||||
220
tools/map-extract/src/Cdn.cs
Normal file
220
tools/map-extract/src/Cdn.cs
Normal file
@@ -0,0 +1,220 @@
|
||||
using System.Net;
|
||||
using System.Net.Http.Headers;
|
||||
using CUE4Parse.UE4.Readers;
|
||||
using CUE4Parse.UE4.Versions;
|
||||
|
||||
namespace GvrMapExtract;
|
||||
|
||||
/// <summary>Riot CDN 번들에서 매니페스트 조각을 필요할 때만 받는다 (HTTP Range).
|
||||
/// 받은 조각은 압축을 풀어 메모리에 둔다 (오래 안 쓴 것부터 버림). 디스크는 쓰지 않는다.</summary>
|
||||
public sealed class CdnStore(string bundleBase, long cacheBytes)
|
||||
{
|
||||
private readonly HttpClient _http = new(new SocketsHttpHandler { MaxConnectionsPerServer = 8, AutomaticDecompression = DecompressionMethods.None })
|
||||
{
|
||||
Timeout = TimeSpan.FromSeconds(90),
|
||||
};
|
||||
private readonly object _lock = new();
|
||||
private readonly Dictionary<(ulong, uint), LinkedListNode<((ulong, uint) key, byte[] data)>> _map = new();
|
||||
private readonly LinkedList<((ulong, uint) key, byte[] data)> _lru = new();
|
||||
private readonly Dictionary<(ulong, uint), Task> _inflight = new();
|
||||
private long _cached;
|
||||
public long DownloadedBytes;
|
||||
public long Requests;
|
||||
|
||||
private bool TryGet((ulong, uint) key, out byte[] data)
|
||||
{
|
||||
lock (_lock)
|
||||
{
|
||||
if (_map.TryGetValue(key, out var node))
|
||||
{
|
||||
_lru.Remove(node);
|
||||
_lru.AddFirst(node);
|
||||
data = node.Value.data;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
data = [];
|
||||
return false;
|
||||
}
|
||||
|
||||
private void Put((ulong, uint) key, byte[] data)
|
||||
{
|
||||
lock (_lock)
|
||||
{
|
||||
if (_map.ContainsKey(key)) return;
|
||||
_map[key] = _lru.AddFirst((key, data));
|
||||
_cached += data.Length;
|
||||
while (_cached > cacheBytes && _lru.Last is { } last)
|
||||
{
|
||||
_lru.RemoveLast();
|
||||
_map.Remove(last.Value.key);
|
||||
_cached -= last.Value.data.Length;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>파일의 i 번째 조각. 없으면 뒤로 이어진 조각(같은 번들 · 연속 위치)까지 한 번에 받는다</summary>
|
||||
public byte[] Get(Rman.RFile f, int i)
|
||||
{
|
||||
var c = f.Chunks[i];
|
||||
var key = (c.BundleId, c.BundleOffset);
|
||||
for (var attempt = 0; ; attempt++)
|
||||
{
|
||||
if (TryGet(key, out var hit)) return hit;
|
||||
Task? wait;
|
||||
TaskCompletionSource? mine = null;
|
||||
lock (_lock)
|
||||
{
|
||||
if (!_inflight.TryGetValue(key, out wait))
|
||||
{
|
||||
mine = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
|
||||
_inflight[key] = mine.Task;
|
||||
}
|
||||
}
|
||||
if (mine == null)
|
||||
{
|
||||
try { wait!.Wait(); } catch { /* 받던 쪽이 실패하면 다시 시도 */ }
|
||||
if (attempt > 4) throw new IOException("조각 받기 실패 (반복)");
|
||||
continue;
|
||||
}
|
||||
// 이어 받을 조각 범위
|
||||
var run = new List<int> { i };
|
||||
long total = c.CompressedSize;
|
||||
for (var j = i + 1; j < f.Chunks.Length && run.Count < 64 && total < 8 << 20; j++)
|
||||
{
|
||||
var n = f.Chunks[j];
|
||||
var prev = f.Chunks[j - 1];
|
||||
if (n.BundleId != c.BundleId || n.BundleOffset != prev.BundleOffset + prev.CompressedSize) break;
|
||||
lock (_lock) if (_map.ContainsKey((n.BundleId, n.BundleOffset)) || _inflight.ContainsKey((n.BundleId, n.BundleOffset))) break;
|
||||
run.Add(j);
|
||||
total += n.CompressedSize;
|
||||
}
|
||||
lock (_lock) foreach (var j in run.Skip(1)) _inflight.TryAdd((f.Chunks[j].BundleId, f.Chunks[j].BundleOffset), mine.Task);
|
||||
try
|
||||
{
|
||||
var raw = Fetch(c.BundleId, c.BundleOffset, total);
|
||||
var pos = 0;
|
||||
using var z = new ZstdSharp.Decompressor();
|
||||
foreach (var j in run)
|
||||
{
|
||||
var cj = f.Chunks[j];
|
||||
var outBuf = new byte[cj.UncompressedSize];
|
||||
var n = z.Unwrap(raw.AsSpan(pos, (int)cj.CompressedSize), outBuf);
|
||||
if (n != cj.UncompressedSize) throw new IOException("조각 크기가 다름");
|
||||
pos += (int)cj.CompressedSize;
|
||||
Put((cj.BundleId, cj.BundleOffset), outBuf);
|
||||
}
|
||||
mine.SetResult();
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
mine.SetException(e);
|
||||
if (attempt > 4) throw;
|
||||
}
|
||||
finally
|
||||
{
|
||||
lock (_lock) foreach (var j in run) if (_inflight.TryGetValue((f.Chunks[j].BundleId, f.Chunks[j].BundleOffset), out var t) && t == mine.Task) _inflight.Remove((f.Chunks[j].BundleId, f.Chunks[j].BundleOffset));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private byte[] Fetch(ulong bundle, uint offset, long length)
|
||||
{
|
||||
var url = $"{bundleBase}/{bundle:X16}.bundle";
|
||||
for (var attempt = 0; ; attempt++)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var req = new HttpRequestMessage(HttpMethod.Get, url);
|
||||
req.Headers.Range = new RangeHeaderValue(offset, offset + length - 1);
|
||||
using var res = _http.Send(req, HttpCompletionOption.ResponseHeadersRead);
|
||||
if (res.StatusCode != HttpStatusCode.PartialContent) throw new IOException($"{url} {(int)res.StatusCode}");
|
||||
using var s = res.Content.ReadAsStream();
|
||||
var buf = new byte[length];
|
||||
s.ReadExactly(buf);
|
||||
Interlocked.Add(ref DownloadedBytes, length);
|
||||
Interlocked.Increment(ref Requests);
|
||||
return buf;
|
||||
}
|
||||
catch (Exception) when (attempt < 4)
|
||||
{
|
||||
Thread.Sleep(1000 * (attempt + 1));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<byte[]> GetBytes(string url) => await _http.GetByteArrayAsync(url);
|
||||
}
|
||||
|
||||
/// <summary>매니페스트 파일 하나를 CUE4Parse 가 읽는 파일처럼 보이게 한다 (임의 위치 읽기)</summary>
|
||||
public sealed class CdnArchive : FArchive
|
||||
{
|
||||
private readonly CdnStore _store;
|
||||
private readonly Rman.RFile _file;
|
||||
private readonly long[] _starts;
|
||||
|
||||
public CdnArchive(CdnStore store, Rman.RFile file, VersionContainer? versions) : base(versions)
|
||||
{
|
||||
_store = store;
|
||||
_file = file;
|
||||
_starts = file.Chunks.Select(c => c.FileOffset).ToArray();
|
||||
Name = file.Path;
|
||||
}
|
||||
|
||||
public override string Name { get; }
|
||||
public override bool CanSeek => true;
|
||||
public override long Length => _file.Size;
|
||||
public override long Position { get; set; }
|
||||
|
||||
public override int Read(byte[] buffer, int offset, int count)
|
||||
{
|
||||
var n = ReadAt(Position, buffer, offset, count);
|
||||
Position += n;
|
||||
return n;
|
||||
}
|
||||
|
||||
public override int ReadAt(long position, byte[] buffer, int offset, int count)
|
||||
{
|
||||
if (position >= Length) return 0;
|
||||
count = (int)Math.Min(count, Length - position);
|
||||
var done = 0;
|
||||
var i = Array.BinarySearch(_starts, position);
|
||||
if (i < 0) i = ~i - 1;
|
||||
while (done < count)
|
||||
{
|
||||
var c = _file.Chunks[i];
|
||||
var data = _store.Get(_file, i);
|
||||
var inChunk = (int)(position + done - c.FileOffset);
|
||||
var n = Math.Min(count - done, data.Length - inChunk);
|
||||
Buffer.BlockCopy(data, inChunk, buffer, offset + done, n);
|
||||
done += n;
|
||||
i++;
|
||||
}
|
||||
return done;
|
||||
}
|
||||
|
||||
public override Task<int> ReadAtAsync(long position, byte[] buffer, int offset, int count, CancellationToken cancellationToken = default)
|
||||
=> Task.FromResult(ReadAt(position, buffer, offset, count));
|
||||
|
||||
public override ValueTask<int> ReadAtAsync(long position, Memory<byte> memory, CancellationToken cancellationToken = default)
|
||||
{
|
||||
var tmp = new byte[memory.Length];
|
||||
var n = ReadAt(position, tmp, 0, tmp.Length);
|
||||
tmp.AsSpan(0, n).CopyTo(memory.Span);
|
||||
return ValueTask.FromResult(n);
|
||||
}
|
||||
|
||||
public override long Seek(long offset, SeekOrigin origin)
|
||||
{
|
||||
Position = origin switch
|
||||
{
|
||||
SeekOrigin.Begin => offset,
|
||||
SeekOrigin.Current => Position + offset,
|
||||
SeekOrigin.End => Length + offset,
|
||||
_ => throw new ArgumentOutOfRangeException(nameof(origin)),
|
||||
};
|
||||
return Position;
|
||||
}
|
||||
|
||||
public override object Clone() => new CdnArchive(_store, _file, Versions) { Position = Position };
|
||||
}
|
||||
225
tools/map-extract/src/MapScene.cs
Normal file
225
tools/map-extract/src/MapScene.cs
Normal file
@@ -0,0 +1,225 @@
|
||||
using System.Text;
|
||||
using CUE4Parse.FileProvider;
|
||||
using CUE4Parse.UE4.Assets.Exports;
|
||||
using CUE4Parse.UE4.Assets.Exports.Component.StaticMesh;
|
||||
using CUE4Parse.UE4.Assets.Exports.StaticMesh;
|
||||
using CUE4Parse.UE4.Objects.Core.Math;
|
||||
|
||||
namespace GvrMapExtract;
|
||||
|
||||
/// <param name="Code">영구 레벨 이름 (Ascent, HURM_Alley …)</param>
|
||||
/// <param name="MapUrl">경기 기록의 맵 경로 (/Game/Maps/Ascent/Ascent)</param>
|
||||
public sealed record MapInfo(string Code, string MapUrl, List<string> Levels);
|
||||
|
||||
/// <summary>맵 레벨들의 StaticMesh 배치를 모아 월드 좌표(UE cm) 삼각형 하나로 굽는다.
|
||||
/// 재질 · 텍스처는 없다 (사이트는 높이 · 면 방향으로 색을 칠한다).</summary>
|
||||
public sealed class MapScene
|
||||
{
|
||||
public int Placements, Meshes, Failed, Skipped;
|
||||
public long Triangles => _idx.Count / 3;
|
||||
private readonly List<float> _pos = new();
|
||||
private readonly List<uint> _idx = new();
|
||||
private readonly List<string> _levels = new();
|
||||
private string _code = "";
|
||||
private string _mapUrl = "";
|
||||
|
||||
/// <summary>맵 = 하위 레벨을 불러오는 영구 레벨 (경기 기록의 맵 경로 "/Game/Maps/Ascent/Ascent" 와 같다).
|
||||
/// 연습장 · 튜토리얼 · 메뉴처럼 경기가 없는 곳은 뺀다</summary>
|
||||
public static List<MapInfo> FindMaps(IFileProvider provider, Action<string>? log = null)
|
||||
{
|
||||
var umaps = provider.Files.Keys.Where(k => k.StartsWith("ShooterGame/Content/Maps/", StringComparison.OrdinalIgnoreCase) && k.EndsWith(".umap", StringComparison.OrdinalIgnoreCase)).ToList();
|
||||
var byDir = umaps.GroupBy(k => k[..k.LastIndexOf('/')]).ToDictionary(g => g.Key, g => g.Select(x => Path.GetFileNameWithoutExtension(x)).ToList());
|
||||
var res = new List<MapInfo>();
|
||||
foreach (var k in umaps.OrderBy(x => x))
|
||||
{
|
||||
var dir = k[..k.LastIndexOf('/')];
|
||||
var name = Path.GetFileNameWithoutExtension(k);
|
||||
if (NotPlayable.Any(x => k.Contains(x, StringComparison.OrdinalIgnoreCase))) continue;
|
||||
if (!byDir[dir].Any(o => o.StartsWith(name + "_", StringComparison.OrdinalIgnoreCase))) continue;
|
||||
List<(string level, string cls, string props)> subs;
|
||||
try { subs = StreamingLevels(provider, k); } catch (Exception e) { log?.Invoke($"{k}: 레벨 목록 실패 {e.Message}"); continue; }
|
||||
var levels = subs.Where(x => x.cls == "LevelStreamingAlwaysLoaded" && IsVisualLevel(x.level))
|
||||
.Select(x => "ShooterGame/Content" + x.level["/Game".Length..] + ".umap")
|
||||
.Where(provider.Files.ContainsKey).ToList();
|
||||
if (levels.Count == 0) continue;
|
||||
levels.Insert(0, k);
|
||||
res.Add(new MapInfo(name, "/Game" + k["ShooterGame/Content".Length..^".umap".Length], levels));
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
private static readonly string[] NotPlayable = ["/Poveglia", "/NPE", "/Menu/", "/Init/", "/Pregame", "_Copy/", "/SharedSubLevels/"];
|
||||
// 보이는 모양이 아닌 하위 레벨 (게임 규칙 · 빛 · 소리 · 부피 · 길찾기 · 카메라 · 효과 · 먼 배경 · 이벤트 장식)
|
||||
private static readonly string[] NotVisual = ["Gameplay", "Lighting", "Volume", "NavMesh", "Audio", "Sound", "_BV", "Callout", "VFX", "_FX", "Vista", "Background", "Decal",
|
||||
"Activation", "Birthday", "Snow", "LiveStory", "Sequence", "Camera", "Probe", "Profiling", "Greybox", "Blockout", "Design", "Layout", "Lanes", "Mode_", "Spawns_Proto", "SpawnPoints", "Skybox", "AuxiliaryZones", "KillVol", "Barrier", "Collider"];
|
||||
|
||||
/// <summary>영구 레벨이 불러오는 하위 레벨들 (패키지 경로 · 형 · b 로 시작하는 속성)</summary>
|
||||
public static List<(string level, string cls, string props)> StreamingLevels(IFileProvider provider, string umap)
|
||||
{
|
||||
var res = new List<(string, string, string)>();
|
||||
var pkg = provider.LoadPackage(umap);
|
||||
var world = pkg.GetExports().OfType<CUE4Parse.UE4.Objects.Engine.UWorld>().FirstOrDefault();
|
||||
if (world?.StreamingLevels == null) return res;
|
||||
foreach (var r in world.StreamingLevels)
|
||||
{
|
||||
var ls = r.Load<CUE4Parse.UE4.Objects.Engine.ULevelStreaming>();
|
||||
if (ls?.WorldAsset == null) continue;
|
||||
var pkgName = ls.WorldAsset.Value.AssetPathName.Text.Split('.')[0];
|
||||
var props = string.Join(' ', ls.Properties.Where(p => p.Name.Text.StartsWith('b')).Select(p => $"{p.Name.Text}={p.Tag?.GenericValue}"));
|
||||
res.Add((pkgName, ls.ExportType, props));
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static bool IsVisualLevel(string level)
|
||||
{
|
||||
var name = level[(level.LastIndexOf('/') + 1)..];
|
||||
return !NotVisual.Any(x => name.Contains(x, StringComparison.OrdinalIgnoreCase));
|
||||
}
|
||||
|
||||
// 부피 · 하늘 · 먼 배경 · 블록아웃 메시는 뺀다
|
||||
private static readonly string[] SkipMesh = ["Box_For_Volumes", "BasicShapes/Plane", "Blockout", "/Sky", "Vista", "EditorMeshes", "Cubemap"];
|
||||
|
||||
public static MapScene Build(IFileProvider provider, MapInfo map)
|
||||
{
|
||||
var s = new MapScene { _code = map.Code, _mapUrl = map.MapUrl };
|
||||
var meshCache = new Dictionary<string, (FVector[] v, uint[] i)?>();
|
||||
foreach (var level in map.Levels)
|
||||
{
|
||||
s._levels.Add(Path.GetFileNameWithoutExtension(level));
|
||||
var pkg = provider.LoadPackage(level);
|
||||
foreach (var lazy in pkg.ExportsLazy)
|
||||
{
|
||||
UObject o;
|
||||
try { o = lazy.Value; } catch { s.Failed++; continue; }
|
||||
if (o is not UStaticMeshComponent c) continue;
|
||||
if (c.GetOrDefault<bool>("bHiddenInGame") || !c.GetOrDefault("bVisible", true)) { s.Skipped++; continue; }
|
||||
UStaticMesh? mesh;
|
||||
try { mesh = c.GetStaticMesh()?.Load<UStaticMesh>(); } catch { s.Failed++; continue; }
|
||||
if (mesh == null) continue;
|
||||
var path = mesh.GetPathName();
|
||||
if (SkipMesh.Any(x => path.Contains(x, StringComparison.OrdinalIgnoreCase))) { s.Skipped++; continue; }
|
||||
if (!meshCache.TryGetValue(path, out var geo))
|
||||
{
|
||||
geo = Geometry(mesh);
|
||||
meshCache[path] = geo;
|
||||
if (geo != null) s.Meshes++;
|
||||
}
|
||||
if (geo == null) continue;
|
||||
FTransform w;
|
||||
try { w = c.GetAbsoluteTransform(); } catch { s.Failed++; continue; }
|
||||
if (c is UInstancedStaticMeshComponent ism && ism.PerInstanceSMData is { Length: > 0 } data)
|
||||
foreach (var d in data) s.Add(geo.Value, d.TransformData * w);
|
||||
else s.Add(geo.Value, w);
|
||||
}
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
/// <summary>가장 낮은 LOD 의 위치 · 삼각형 (사이트에서 내려다보는 용도라 충분하다)</summary>
|
||||
private static (FVector[] v, uint[] i)? Geometry(UStaticMesh mesh)
|
||||
{
|
||||
var lods = mesh.RenderData?.LODs;
|
||||
if (lods == null) return null;
|
||||
for (var l = lods.Length - 1; l >= 0; l--)
|
||||
{
|
||||
var lod = lods[l];
|
||||
if (lod.SkipLod || lod.PositionVertexBuffer?.Verts is not { Length: > 0 } v || lod.IndexBuffer?.Buffer is not { Length: > 0 } ib) continue;
|
||||
var idx = new List<uint>();
|
||||
foreach (var sec in lod.Sections)
|
||||
for (var k = 0; k < sec.NumTriangles * 3; k++) idx.Add(ib[sec.FirstIndex + k]);
|
||||
return (v, idx.ToArray());
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private void Add((FVector[] v, uint[] i) g, FTransform t)
|
||||
{
|
||||
Placements++;
|
||||
var b = (uint)(_pos.Count / 3);
|
||||
foreach (var p in g.v)
|
||||
{
|
||||
var w = t.TransformPosition(p);
|
||||
_pos.Add(w.X);
|
||||
_pos.Add(w.Y);
|
||||
_pos.Add(w.Z);
|
||||
}
|
||||
// 크기가 음수(거울)면 삼각형 방향이 뒤집힌다
|
||||
var flip = t.Scale3D.X * t.Scale3D.Y * t.Scale3D.Z < 0;
|
||||
for (var k = 0; k + 2 < g.i.Length; k += 3)
|
||||
{
|
||||
_idx.Add(b + g.i[k]);
|
||||
_idx.Add(b + g.i[flip ? k + 2 : k + 1]);
|
||||
_idx.Add(b + g.i[flip ? k + 1 : k + 2]);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>glb: 메시 하나, 위치(float32, UE 월드 cm 그대로) + 삼각형(uint32). 사이트가 미니맵 좌표로 옮긴다</summary>
|
||||
public void WriteGlb(string file)
|
||||
{
|
||||
var pos = _pos.ToArray();
|
||||
var idx = _idx.ToArray();
|
||||
float[] min = [float.MaxValue, float.MaxValue, float.MaxValue], max = [float.MinValue, float.MinValue, float.MinValue];
|
||||
for (var i = 0; i < pos.Length; i++)
|
||||
{
|
||||
min[i % 3] = Math.Min(min[i % 3], pos[i]);
|
||||
max[i % 3] = Math.Max(max[i % 3], pos[i]);
|
||||
}
|
||||
var posBytes = pos.Length * 4;
|
||||
var idxBytes = idx.Length * 4;
|
||||
var gltf = new
|
||||
{
|
||||
asset = new { version = "2.0", generator = "gvr-map-extract" },
|
||||
scene = 0,
|
||||
scenes = new[] { new { nodes = new[] { 0 } } },
|
||||
nodes = new[] { new { mesh = 0, name = _code } },
|
||||
meshes = new[] { new { name = _code, primitives = new[] { new { attributes = new { POSITION = 0 }, indices = 1, mode = 4 } } } },
|
||||
accessors = new object[]
|
||||
{
|
||||
new { bufferView = 0, componentType = 5126, count = pos.Length / 3, type = "VEC3", min, max },
|
||||
new { bufferView = 1, componentType = 5125, count = idx.Length, type = "SCALAR" },
|
||||
},
|
||||
bufferViews = new[]
|
||||
{
|
||||
new { buffer = 0, byteOffset = 0, byteLength = posBytes, target = 34962 },
|
||||
new { buffer = 0, byteOffset = posBytes, byteLength = idxBytes, target = 34963 },
|
||||
},
|
||||
buffers = new[] { new { byteLength = posBytes + idxBytes } },
|
||||
};
|
||||
var json = Encoding.UTF8.GetBytes(System.Text.Json.JsonSerializer.Serialize(gltf));
|
||||
var jsonPad = (4 - json.Length % 4) % 4;
|
||||
using var fs = File.Create(file);
|
||||
using var w = new BinaryWriter(fs);
|
||||
var total = 12 + 8 + json.Length + jsonPad + 8 + posBytes + idxBytes;
|
||||
w.Write(0x46546C67u); // glTF
|
||||
w.Write(2u);
|
||||
w.Write((uint)total);
|
||||
w.Write((uint)(json.Length + jsonPad));
|
||||
w.Write(0x4E4F534Au); // JSON
|
||||
w.Write(json);
|
||||
for (var i = 0; i < jsonPad; i++) w.Write((byte)' ');
|
||||
w.Write((uint)(posBytes + idxBytes));
|
||||
w.Write(0x004E4942u); // BIN
|
||||
foreach (var f in pos) w.Write(f);
|
||||
foreach (var i in idx) w.Write(i);
|
||||
}
|
||||
|
||||
public void WriteInfo(string file, string manifest, string? usmap)
|
||||
{
|
||||
var info = new
|
||||
{
|
||||
code = _code,
|
||||
mapUrl = _mapUrl,
|
||||
levels = _levels,
|
||||
placements = Placements,
|
||||
meshes = Meshes,
|
||||
triangles = Triangles,
|
||||
skipped = Skipped,
|
||||
failed = Failed,
|
||||
manifest,
|
||||
usmap = usmap == null ? null : Path.GetFileName(usmap),
|
||||
extractedAt = DateTimeOffset.UtcNow.ToString("o"),
|
||||
};
|
||||
File.WriteAllText(file, System.Text.Json.JsonSerializer.Serialize(info, new System.Text.Json.JsonSerializerOptions { WriteIndented = true }));
|
||||
}
|
||||
}
|
||||
127
tools/map-extract/src/Program.cs
Normal file
127
tools/map-extract/src/Program.cs
Normal file
@@ -0,0 +1,127 @@
|
||||
using Serilog;
|
||||
using System.Diagnostics;
|
||||
using System.Text.RegularExpressions;
|
||||
using CUE4Parse;
|
||||
using CUE4Parse.Compression;
|
||||
using CUE4Parse.Encryption.Aes;
|
||||
using CUE4Parse.FileProvider;
|
||||
using CUE4Parse.MappingsProvider.Usmap;
|
||||
using CUE4Parse.UE4.Objects.Core.Misc;
|
||||
using CUE4Parse.UE4.Versions;
|
||||
using GvrMapExtract;
|
||||
|
||||
// gvr-map-extract: 발로란트 맵 3D 모양을 Riot CDN 에서 바로 뽑는다 (게임 설치 · 전체 다운로드 없음)
|
||||
//
|
||||
// gvr-map-extract ls <정규식> [개수] 파일 목록
|
||||
// gvr-map-extract maps 맵 목록 (코드 이름 · 레벨 수)
|
||||
// gvr-map-extract extract <출력 폴더> [맵...] 맵마다 <코드>.glb (UE 월드 좌표 cm, 위치 + 삼각형) + <코드>.json
|
||||
//
|
||||
// 환경변수
|
||||
// GVR_USMAP 매핑 파일 (.usmap, 필수: 13.08 부터 패키지에 형 정보가 없다). uedb.dev 에서 받는다
|
||||
// GVR_MANIFEST 매니페스트 URL (없으면 지금 라이브 패치를 Riot 설정에서 찾는다)
|
||||
// GVR_CACHE_MB 받은 조각을 메모리에 둘 크기 (기본 1500)
|
||||
// GVR_OODLE Oodle 라이브러리 경로 (없으면 실행 파일 옆, 없으면 받는다)
|
||||
|
||||
Serilog.Log.Logger = new Serilog.LoggerConfiguration().MinimumLevel.Error().WriteTo.Console().CreateLogger();
|
||||
CUE4ParseLog.UseLogger(Serilog.Log.Logger);
|
||||
|
||||
const string AesKey = "0x4BE71AF2459CF83899EC9DC2CB60E22AC4B3047E0211034BBABE9D174C069DD6"; // 발로란트 공개 키 (모든 패치 같음)
|
||||
const string BundleBase = "https://valorant.secure.dyn.riotcdn.net/channels/public/bundles";
|
||||
const string Patchlines = "https://clientconfig.rpg.riotgames.com/api/v1/config/public?namespace=keystone.products.valorant.patchlines";
|
||||
|
||||
if (args.Length == 0)
|
||||
{
|
||||
Console.Error.WriteLine("사용법: gvr-map-extract ls <정규식> | maps | extract <출력 폴더> [맵...] | manifest");
|
||||
return 2;
|
||||
}
|
||||
var sw = Stopwatch.StartNew();
|
||||
var store = new CdnStore(BundleBase, long.Parse(Environment.GetEnvironmentVariable("GVR_CACHE_MB") ?? "1500") << 20);
|
||||
var manifestUrl = Environment.GetEnvironmentVariable("GVR_MANIFEST") ?? await LiveManifest(store);
|
||||
if (args[0] == "manifest")
|
||||
{
|
||||
Console.WriteLine(manifestUrl);
|
||||
return 0;
|
||||
}
|
||||
var rman = Rman.Parse(await store.GetBytes(manifestUrl));
|
||||
Console.Error.WriteLine($"매니페스트 {manifestUrl} 파일 {rman.Files.Count}");
|
||||
|
||||
var oodle = Environment.GetEnvironmentVariable("GVR_OODLE") ?? Path.Combine(AppContext.BaseDirectory, OodleHelper.OodleFileName);
|
||||
await OodleHelper.InitializeAsync(oodle);
|
||||
var versions = new VersionContainer(EGame.GAME_Valorant);
|
||||
var provider = new StreamedFileProvider("VALORANT", versions, StringComparer.OrdinalIgnoreCase);
|
||||
provider.Initialize();
|
||||
foreach (var f in rman.Files.Values.Where(f => f.Path.StartsWith("ShooterGame/Content/Paks/", StringComparison.OrdinalIgnoreCase)))
|
||||
{
|
||||
var ext = Path.GetExtension(f.Path).ToLowerInvariant();
|
||||
if (ext == ".utoc")
|
||||
provider.RegisterRandomAccessVfs(new CdnArchive(store, f, versions), null, open =>
|
||||
rman.Files.TryGetValue(open, out var c) ? new CdnArchive(store, c, versions) : throw new FileNotFoundException(open));
|
||||
else if (ext == ".pak")
|
||||
provider.RegisterRandomAccessVfs(new CdnArchive(store, f, versions), null, null);
|
||||
}
|
||||
provider.SubmitKey(new FGuid(), new FAesKey(AesKey));
|
||||
provider.PostMount();
|
||||
var usmap = Environment.GetEnvironmentVariable("GVR_USMAP");
|
||||
if (usmap != null) provider.MappingsContainer = new FileUsmapTypeMappingsProvider(usmap);
|
||||
Console.Error.WriteLine($"파일 {provider.Files.Count} · 묶음 {provider.MountedVfs.Count} (못 연 것 {provider.UnloadedVfs.Count}) · 받은 양 {store.DownloadedBytes >> 20}MB · {sw.Elapsed.TotalSeconds:F0}초");
|
||||
|
||||
switch (args[0])
|
||||
{
|
||||
case "ls":
|
||||
{
|
||||
var re = new Regex(args[1], RegexOptions.IgnoreCase);
|
||||
foreach (var k in provider.Files.Keys.Where(k => re.IsMatch(k)).OrderBy(k => k).Take(args.Length > 2 ? int.Parse(args[2]) : 200)) Console.WriteLine(k);
|
||||
break;
|
||||
}
|
||||
case "levels":
|
||||
foreach (var (lvl, cls, props) in MapScene.StreamingLevels(provider, args[1]))
|
||||
Console.WriteLine($"{lvl}\t{cls}\t{props}");
|
||||
break;
|
||||
case "maps":
|
||||
foreach (var m in MapScene.FindMaps(provider, Console.Error.WriteLine)) Console.WriteLine($"{m.Code}\t{m.MapUrl}\t{m.Levels.Count}\t{string.Join(',', m.Levels.Select(Path.GetFileNameWithoutExtension))}");
|
||||
break;
|
||||
case "extract":
|
||||
{
|
||||
var outDir = args[1];
|
||||
Directory.CreateDirectory(outDir);
|
||||
var want = args.Skip(2).ToHashSet(StringComparer.OrdinalIgnoreCase);
|
||||
// 맵 찾기에서 읽지 못한 레벨이 있으면 맵이 빠졌을 수 있다 → 실패로 친다 (빠진 결과로 기존 맵을 덮어쓰지 않게)
|
||||
var findErrors = 0;
|
||||
var maps = MapScene.FindMaps(provider, e => { findErrors++; Console.Error.WriteLine(e); }).Where(m => want.Count == 0 || want.Contains(m.Code)).ToList();
|
||||
var failed = findErrors;
|
||||
foreach (var m in maps)
|
||||
{
|
||||
var t0 = sw.Elapsed;
|
||||
var d0 = store.DownloadedBytes;
|
||||
try
|
||||
{
|
||||
var r = MapScene.Build(provider, m);
|
||||
r.WriteGlb(Path.Combine(outDir, m.Code + ".glb"));
|
||||
r.WriteInfo(Path.Combine(outDir, m.Code + ".json"), manifestUrl, usmap);
|
||||
Console.WriteLine($"{m.Code}: 배치 {r.Placements} · 메시 {r.Meshes} · 삼각형 {r.Triangles} · 빠짐 {r.Skipped} · 실패 {r.Failed} · 받은 양 {(store.DownloadedBytes - d0) >> 20}MB · {(sw.Elapsed - t0).TotalSeconds:F0}초");
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
failed++;
|
||||
Console.WriteLine($"{m.Code}: 실패 {e.GetType().Name} {e.Message}");
|
||||
}
|
||||
GC.Collect();
|
||||
}
|
||||
if (findErrors > 0) Console.WriteLine($"맵 찾기 실패 {findErrors}개 (위 로그)");
|
||||
Console.WriteLine($"끝: 맵 {maps.Count - (failed - findErrors)}/{maps.Count} · 받은 양 {store.DownloadedBytes >> 20}MB ({store.Requests}번) · {sw.Elapsed.TotalMinutes:F1}분");
|
||||
return failed == 0 ? 0 : 1;
|
||||
}
|
||||
default:
|
||||
Console.Error.WriteLine("모르는 명령 " + args[0]);
|
||||
return 2;
|
||||
}
|
||||
return 0;
|
||||
|
||||
static async Task<string> LiveManifest(CdnStore store)
|
||||
{
|
||||
var json = System.Text.Json.JsonDocument.Parse(await store.GetBytes(Patchlines));
|
||||
var live = json.RootElement.GetProperty("keystone.products.valorant.patchlines.live");
|
||||
foreach (var c in live.GetProperty("platforms").GetProperty("win").GetProperty("configurations").EnumerateArray())
|
||||
if (c.TryGetProperty("patch_url", out var u)) return u.GetString()!;
|
||||
throw new InvalidOperationException("라이브 매니페스트를 못 찾음");
|
||||
}
|
||||
119
tools/map-extract/src/Rman.cs
Normal file
119
tools/map-extract/src/Rman.cs
Normal file
@@ -0,0 +1,119 @@
|
||||
using System.Buffers.Binary;
|
||||
using System.Text;
|
||||
|
||||
namespace GvrMapExtract;
|
||||
|
||||
/// <summary>Riot 매니페스트(.manifest, RMAN 2.x) 읽기. 본문은 zstd 로 압축된 FlatBuffers.
|
||||
/// 구조는 Morilli/ManifestDownloader rman.c 를 따랐다.</summary>
|
||||
public sealed class Rman
|
||||
{
|
||||
public sealed record Chunk(ulong BundleId, uint BundleOffset, uint CompressedSize, uint UncompressedSize, long FileOffset);
|
||||
public sealed record RFile(string Path, long Size, Chunk[] Chunks);
|
||||
|
||||
public ulong ManifestId { get; private set; }
|
||||
public Dictionary<string, RFile> Files { get; } = new(StringComparer.OrdinalIgnoreCase);
|
||||
|
||||
public static Rman Parse(byte[] data)
|
||||
{
|
||||
if (data.Length < 28 || Encoding.ASCII.GetString(data, 0, 4) != "RMAN") throw new InvalidDataException("RMAN 아님");
|
||||
if (data[4] != 2) throw new InvalidDataException($"모르는 매니페스트 버전 {data[4]}.{data[5]}");
|
||||
var contentOffset = BinaryPrimitives.ReadUInt32LittleEndian(data.AsSpan(8));
|
||||
var compressedSize = BinaryPrimitives.ReadUInt32LittleEndian(data.AsSpan(12));
|
||||
var r = new Rman { ManifestId = BinaryPrimitives.ReadUInt64LittleEndian(data.AsSpan(16)) };
|
||||
var uncompressedSize = BinaryPrimitives.ReadUInt32LittleEndian(data.AsSpan(24));
|
||||
var body = new byte[uncompressedSize];
|
||||
using (var z = new ZstdSharp.Decompressor())
|
||||
{
|
||||
var n = z.Unwrap(data.AsSpan((int)contentOffset, (int)compressedSize), body);
|
||||
if (n != uncompressedSize) throw new InvalidDataException("매니페스트 압축 풀기 실패");
|
||||
}
|
||||
r.ParseBody(new Fb(body));
|
||||
return r;
|
||||
}
|
||||
|
||||
private void ParseBody(Fb b)
|
||||
{
|
||||
var root = b.Root();
|
||||
// 번들 → 조각 (번들 안 위치는 앞 조각 크기의 누적)
|
||||
var chunks = new Dictionary<ulong, (ulong bundle, uint off, uint comp, uint raw)>();
|
||||
foreach (var bt in b.Tables(root, 0))
|
||||
{
|
||||
var bundleId = b.U64(bt, 0);
|
||||
uint off = 0;
|
||||
foreach (var ct in b.Tables(bt, 1))
|
||||
{
|
||||
var comp = b.U32(ct, 1);
|
||||
chunks[b.U64(ct, 0)] = (bundleId, off, comp, b.U32(ct, 2));
|
||||
off += comp;
|
||||
}
|
||||
}
|
||||
// 폴더
|
||||
var dirs = new Dictionary<ulong, (ulong parent, string name)>();
|
||||
foreach (var dt in b.Tables(root, 3)) dirs[b.U64(dt, 0)] = (b.U64(dt, 1), b.Str(dt, 2));
|
||||
// 파일
|
||||
foreach (var ft in b.Tables(root, 2))
|
||||
{
|
||||
var name = b.Str(ft, 3);
|
||||
var dir = b.U64(ft, 1);
|
||||
while (dir != 0 && dirs.TryGetValue(dir, out var d))
|
||||
{
|
||||
if (d.name.Length > 0) name = d.name + "/" + name;
|
||||
dir = d.parent;
|
||||
}
|
||||
var ids = b.U64Vector(ft, 7);
|
||||
var list = new Chunk[ids.Length];
|
||||
long fo = 0;
|
||||
for (var i = 0; i < ids.Length; i++)
|
||||
{
|
||||
var c = chunks[ids[i]];
|
||||
list[i] = new Chunk(c.bundle, c.off, c.comp, c.raw, fo);
|
||||
fo += c.raw;
|
||||
}
|
||||
Files[name] = new RFile(name, (long)b.U64(ft, 2), list);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>아주 작은 FlatBuffers 읽기 (필요한 형만)</summary>
|
||||
private sealed class Fb(byte[] d)
|
||||
{
|
||||
private uint U32At(int p) => BinaryPrimitives.ReadUInt32LittleEndian(d.AsSpan(p));
|
||||
public int Root() => (int)U32At(0);
|
||||
/// <summary>테이블 필드 위치. 없으면 -1</summary>
|
||||
private int Field(int table, int idx)
|
||||
{
|
||||
var vt = table - BinaryPrimitives.ReadInt32LittleEndian(d.AsSpan(table));
|
||||
var vsize = BinaryPrimitives.ReadUInt16LittleEndian(d.AsSpan(vt));
|
||||
if (4 + idx * 2 >= vsize) return -1;
|
||||
var off = BinaryPrimitives.ReadUInt16LittleEndian(d.AsSpan(vt + 4 + idx * 2));
|
||||
return off == 0 ? -1 : table + off;
|
||||
}
|
||||
private int Ref(int p) => p + (int)U32At(p);
|
||||
public ulong U64(int t, int i) { var p = Field(t, i); return p < 0 ? 0 : BinaryPrimitives.ReadUInt64LittleEndian(d.AsSpan(p)); }
|
||||
public uint U32(int t, int i) { var p = Field(t, i); return p < 0 ? 0 : U32At(p); }
|
||||
public string Str(int t, int i)
|
||||
{
|
||||
var p = Field(t, i);
|
||||
if (p < 0) return "";
|
||||
var v = Ref(p);
|
||||
return Encoding.UTF8.GetString(d, v + 4, (int)U32At(v));
|
||||
}
|
||||
public ulong[] U64Vector(int t, int i)
|
||||
{
|
||||
var p = Field(t, i);
|
||||
if (p < 0) return [];
|
||||
var v = Ref(p);
|
||||
var n = (int)U32At(v);
|
||||
var a = new ulong[n];
|
||||
for (var k = 0; k < n; k++) a[k] = BinaryPrimitives.ReadUInt64LittleEndian(d.AsSpan(v + 4 + k * 8));
|
||||
return a;
|
||||
}
|
||||
public IEnumerable<int> Tables(int t, int i)
|
||||
{
|
||||
var p = Field(t, i);
|
||||
if (p < 0) yield break;
|
||||
var v = Ref(p);
|
||||
var n = (int)U32At(v);
|
||||
for (var k = 0; k < n; k++) yield return Ref(v + 4 + k * 4);
|
||||
}
|
||||
}
|
||||
}
|
||||
4
tools/replay-extract/.gitignore
vendored
Normal file
4
tools/replay-extract/.gitignore
vendored
Normal file
@@ -0,0 +1,4 @@
|
||||
vendor/
|
||||
bin/
|
||||
obj/
|
||||
out/
|
||||
20
tools/replay-extract/ReplayExtract.csproj
Normal file
20
tools/replay-extract/ReplayExtract.csproj
Normal file
@@ -0,0 +1,20 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
<!-- 발로란트 리플레이(.vrf) → 사이트 재생기용 작은 JSON. 파서는 fetch-parser.sh 로 vendor/ 에 받는다 -->
|
||||
<PropertyGroup>
|
||||
<OutputType>Exe</OutputType>
|
||||
<TargetFramework>net10.0</TargetFramework>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
<AssemblyName>gvr-replay</AssemblyName>
|
||||
<InvariantGlobalization>true</InvariantGlobalization>
|
||||
<EnableDefaultCompileItems>false</EnableDefaultCompileItems>
|
||||
</PropertyGroup>
|
||||
<ItemGroup>
|
||||
<Compile Include="src/**/*.cs" />
|
||||
<ProjectReference Include="vendor/ValorantReplayParser/src/Replay.Encoding/Replay.Encoding.csproj" />
|
||||
<ProjectReference Include="vendor/ValorantReplayParser/src/Replay.Models/Replay.Models.csproj" />
|
||||
<ProjectReference Include="vendor/ValorantReplayParser/src/Replay.Unreal/Replay.Unreal.csproj" />
|
||||
<ProjectReference Include="vendor/ValorantReplayParser/src/Replay.Valorant/Replay.Valorant.csproj" />
|
||||
<ProjectReference Include="vendor/ValorantReplayParser/src/Replay.Valorant.Events/Replay.Valorant.Events.csproj" />
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
21
tools/replay-extract/fetch-parser.sh
Executable file
21
tools/replay-extract/fetch-parser.sh
Executable file
@@ -0,0 +1,21 @@
|
||||
#!/usr/bin/env bash
|
||||
# ValorantReplayParser (MIT, https://github.com/michel-giehl/ValorantReplayParser) 를 고정 커밋으로 받아 vendor/ 에 둔다.
|
||||
# 발로란트 패치로 리플레이 형식이 바뀌면 PARSER_COMMIT 을 새 커밋으로 올린다.
|
||||
set -euo pipefail
|
||||
PARSER_COMMIT="${PARSER_COMMIT:-28e24af44f5d2e2444fb679f500b6ec04ab60672}"
|
||||
here="$(cd "$(dirname "$0")" && pwd)"
|
||||
dst="$here/vendor/ValorantReplayParser"
|
||||
if [ ! -d "$dst/.git" ]; then
|
||||
git clone --quiet https://github.com/michel-giehl/ValorantReplayParser "$dst"
|
||||
fi
|
||||
git -C "$dst" fetch --quiet origin
|
||||
git -C "$dst" checkout --quiet --force "$PARSER_COMMIT"
|
||||
# 저장소의 global.json 은 SDK 패치 버전까지 고정한다. 같은 10.0 대 SDK 면 쓰게 풀어 준다
|
||||
python3 - "$dst/global.json" <<'P'
|
||||
import json, sys
|
||||
p = sys.argv[1]
|
||||
d = json.load(open(p))
|
||||
d.setdefault('sdk', {})['rollForward'] = 'latestFeature'
|
||||
json.dump(d, open(p, 'w'), indent=2)
|
||||
P
|
||||
echo "parser @ $(git -C "$dst" rev-parse --short HEAD)"
|
||||
265
tools/replay-extract/src/Collector.cs
Normal file
265
tools/replay-extract/src/Collector.cs
Normal file
@@ -0,0 +1,265 @@
|
||||
using System.Text.RegularExpressions;
|
||||
using Replay.Models.Events;
|
||||
using Replay.Models.Unreal;
|
||||
using Replay.Valorant.Combat;
|
||||
using Replay.Valorant.Descriptors;
|
||||
using Replay.Valorant.Descriptors.Agents;
|
||||
using Replay.Valorant.Events.Combat;
|
||||
using Replay.Valorant.Events.Movement;
|
||||
using Replay.Valorant.GameState;
|
||||
|
||||
namespace GvrReplay;
|
||||
|
||||
/// 파서 이벤트 → 필요한 것만 모은다 (선수 이동은 sampleMs 간격으로 줄임)
|
||||
public sealed partial class Collector(int sampleMs) : IReplayEventSink
|
||||
{
|
||||
private string? _matchId;
|
||||
private string? _map;
|
||||
private readonly Dictionary<uint, string> _archetypeByActor = [];
|
||||
private readonly Dictionary<uint, string> _subjectByState = [];
|
||||
private readonly Dictionary<uint, uint> _stateByCharacter = [];
|
||||
// 조종 중인 폰 (드론 · 카메라 · 클로브 사후 몸 등). 요원 몸(*_PC_C)만 선수 이동으로 쓴다
|
||||
private readonly Dictionary<uint, uint> _possessedByState = [];
|
||||
private readonly Dictionary<uint, List<int[]>> _moves = [];
|
||||
private readonly Dictionary<uint, int> _lastMoveT = [];
|
||||
private readonly List<int[]> _phases = [];
|
||||
private readonly List<(int T, int NewRoundIndex)> _roundEnds = [];
|
||||
private readonly List<(int T, uint Killer, uint Victim)> _kills = [];
|
||||
private readonly List<(int T, uint State, int X, int Y, int Z, int Yaw, int Pitch)> _shots = [];
|
||||
private readonly List<(int T0, uint Actor, string Kind, int X, int Y, int Z)> _objects = [];
|
||||
private readonly Dictionary<uint, int> _closedAt = [];
|
||||
private readonly Dictionary<uint, uint> _objectOwner = [];
|
||||
private readonly Dictionary<string, int> _stats = [];
|
||||
|
||||
private static int Ms(float seconds) => (int)Math.Round(seconds * 1000.0);
|
||||
private static int R(double v) => (int)Math.Round(v);
|
||||
|
||||
[GeneratedRegex(@"^/Game/Maps/([^/.]+)/\1$")]
|
||||
private static partial Regex MapPath();
|
||||
|
||||
// 스킬 · 설치물로 보는 액터 클래스 (요원 본체 *_PC_C 와 무기 · 상태는 뺀다)
|
||||
// GameObject_* (연막 · 함정 · 정찰 등), Patch_* (장판), Pawn_* (드론 · 분신), Projectile_* (날아가는 스킬), TimedBomb_C (설치된 스파이크)
|
||||
[GeneratedRegex(@"^Default__(GameObject_|Patch_|Pawn_|Projectile_|TimedBomb_C$)")]
|
||||
private static partial Regex ObjectClass();
|
||||
|
||||
public void Emit(ReplayEvent e)
|
||||
{
|
||||
switch (e)
|
||||
{
|
||||
case NetGuidExported g:
|
||||
if (_map is null && MapPath().IsMatch(g.Path)) _map = g.Path;
|
||||
break;
|
||||
case ActorSpawned s:
|
||||
if (s.ArchetypePath is { } arch)
|
||||
{
|
||||
_archetypeByActor[s.ActorNetGuid] = arch;
|
||||
Count("spawn " + Simplify(arch));
|
||||
if (s.Location is { } loc && ObjectClass().IsMatch(arch) && !arch.EndsWith("_PC_C"))
|
||||
_objects.Add((Ms(s.TimeSeconds), s.ActorNetGuid, Simplify(arch), R(loc.X), R(loc.Y), R(loc.Z)));
|
||||
}
|
||||
break;
|
||||
case ActorClosed c:
|
||||
_closedAt[c.ActorNetGuid] = Ms(c.TimeSeconds);
|
||||
break;
|
||||
case ExportGroupReceived x:
|
||||
OnExport(x);
|
||||
break;
|
||||
case RpcReceived r:
|
||||
OnRpc(r);
|
||||
break;
|
||||
case RemoteCharacterMovementReceived m:
|
||||
OnMove(m);
|
||||
break;
|
||||
case ValorantShotReceived shot:
|
||||
OnShot(shot);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private void OnExport(ExportGroupReceived x)
|
||||
{
|
||||
switch (x.Payload)
|
||||
{
|
||||
case BombGameStateDescriptor gs when gs.HasDecoded(nameof(BombGameStateDescriptor.MatchID)) && !string.IsNullOrEmpty(gs.MatchID):
|
||||
_matchId ??= gs.MatchID;
|
||||
break;
|
||||
case BombPlayerStateDescriptor ps:
|
||||
if (ps.HasDecoded(nameof(BombPlayerStateDescriptor.Subject)) && !string.IsNullOrEmpty(ps.Subject))
|
||||
_subjectByState[x.ActorNetGuid] = ps.Subject!;
|
||||
if (ps.HasDecoded(nameof(BombPlayerStateDescriptor.SpawnedCharacter)) && ps.SpawnedCharacter.NetGuid != 0)
|
||||
_stateByCharacter[ps.SpawnedCharacter.NetGuid] = x.ActorNetGuid;
|
||||
if (ps.HasDecoded(nameof(BombPlayerStateDescriptor.PossessedCharacter)) && ps.PossessedCharacter.NetGuid != 0)
|
||||
_possessedByState[ps.PossessedCharacter.NetGuid] = x.ActorNetGuid;
|
||||
break;
|
||||
case GenericAgentDescriptor agent:
|
||||
if (agent.HasDecoded(nameof(GenericAgentDescriptor.PlayerState)) && agent.PlayerState.NetGuid != 0)
|
||||
_stateByCharacter.TryAdd(x.ActorNetGuid, agent.PlayerState.NetGuid);
|
||||
if (agent.HasDecoded(nameof(GenericAgentDescriptor.Owner)) && agent.Owner.NetGuid != 0)
|
||||
_objectOwner.TryAdd(x.ActorNetGuid, agent.Owner.NetGuid);
|
||||
if (agent.HasDecoded(nameof(GenericAgentDescriptor.Instigator)) && agent.Instigator.NetGuid != 0)
|
||||
_objectOwner[x.ActorNetGuid] = agent.Instigator.NetGuid;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private void OnRpc(RpcReceived r)
|
||||
{
|
||||
var t = Ms(r.TimeSeconds);
|
||||
switch (r.Payload)
|
||||
{
|
||||
case ClientGamePhaseBeginParameters p:
|
||||
// 같은 시각에 같은 단계가 여러 컨트롤러로 올 수 있다
|
||||
if (_phases.Count == 0 || _phases[^1][1] != p.NewPhase || _phases[^1][0] != t)
|
||||
_phases.Add([t, p.NewPhase]);
|
||||
break;
|
||||
case MulticastEndRoundParameters er:
|
||||
if (_roundEnds.Count == 0 || _roundEnds[^1].NewRoundIndex != er.NewRoundNumber)
|
||||
_roundEnds.Add((t, er.NewRoundNumber));
|
||||
break;
|
||||
case MulticastNotifyKilledEnemyParameters k:
|
||||
if (!_kills.Any(q => Math.Abs(q.T - t) < 50 && q.Victim == k.KilledCharacter.NetGuid))
|
||||
_kills.Add((t, k.KillerCharacter.NetGuid, k.KilledCharacter.NetGuid));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private void OnMove(RemoteCharacterMovementReceived m)
|
||||
{
|
||||
var t = Ms(m.TimeSeconds);
|
||||
var ch = m.ShooterCharacterNetGuidValue;
|
||||
if (_lastMoveT.TryGetValue(ch, out var last) && t - last < sampleMs) return;
|
||||
_lastMoveT[ch] = t;
|
||||
var p = m.Move.Position;
|
||||
if (!_moves.TryGetValue(ch, out var list)) _moves[ch] = list = [];
|
||||
list.Add([t, R(p.X), R(p.Y), R(p.Z), R(m.Move.Yaw), R(m.Move.Pitch)]);
|
||||
}
|
||||
|
||||
private void OnShot(ValorantShotReceived s)
|
||||
{
|
||||
var shot = s.Shot;
|
||||
if (shot.Location is not { } loc) return;
|
||||
var state = shot.FiringPlayerState?.NetGuid ?? 0;
|
||||
double yaw = 0, pitch = 0;
|
||||
if (shot.Rotation is { } rot)
|
||||
{
|
||||
yaw = rot.Yaw;
|
||||
pitch = rot.Pitch;
|
||||
}
|
||||
else if (shot.AttackVectors.Count > 0)
|
||||
{
|
||||
var v = shot.AttackVectors[0];
|
||||
yaw = Math.Atan2(v.Y, v.X) * 180 / Math.PI;
|
||||
pitch = Math.Atan2(v.Z, Math.Sqrt(v.X * v.X + v.Y * v.Y)) * 180 / Math.PI;
|
||||
}
|
||||
_shots.Add((Ms(s.TimeSeconds), state, R(loc.X), R(loc.Y), R(loc.Z), R(yaw), R(pitch)));
|
||||
}
|
||||
|
||||
private static string Simplify(string archetype) => archetype.StartsWith("Default__") ? archetype[9..] : archetype;
|
||||
|
||||
private void Count(string key) => _stats[key] = _stats.GetValueOrDefault(key) + 1;
|
||||
|
||||
public void PrintStats()
|
||||
{
|
||||
Console.WriteLine($"match {_matchId} map {_map} states {_subjectByState.Count} chars {_stateByCharacter.Count} moves {_moves.Count} kills {_kills.Count} shots {_shots.Count} objects {_objects.Count} phases {_phases.Count} roundEnds {_roundEnds.Count}");
|
||||
Console.WriteLine("stateByChar: " + string.Join(",", _stateByCharacter.Select(kv => $"{kv.Key}->{kv.Value}({(_archetypeByActor.TryGetValue(kv.Key, out var a) ? a : "?")})")));
|
||||
Console.WriteLine("moves: " + string.Join(",", _moves.OrderByDescending(kv => kv.Value.Count).Take(14).Select(kv => $"{kv.Key}:{kv.Value.Count}({(_archetypeByActor.TryGetValue(kv.Key, out var a) ? a : "?")})")));
|
||||
Console.WriteLine("states: " + string.Join(",", _subjectByState.Keys));
|
||||
foreach (var (k, v) in _stats.OrderByDescending(kv => kv.Value).Take(150)) Console.WriteLine($"{v,6} {k}");
|
||||
}
|
||||
|
||||
public ReplayFile Build(string? branch, long recordedAt, int durationMs, int hz)
|
||||
{
|
||||
// 선수 = 계정(subject) 하나. 캐릭터가 여러 번 바뀌어도(부활 등) 같은 선수로 묶는다
|
||||
var players = new List<ReplayPlayer>();
|
||||
var indexBySubject = new Dictionary<string, int>();
|
||||
var indexByCharacter = new Dictionary<uint, int>();
|
||||
int PlayerOfState(uint state)
|
||||
{
|
||||
if (!_subjectByState.TryGetValue(state, out var subject)) return -1;
|
||||
if (!indexBySubject.TryGetValue(subject, out var i))
|
||||
{
|
||||
i = players.Count;
|
||||
indexBySubject[subject] = i;
|
||||
players.Add(new ReplayPlayer { Puuid = subject });
|
||||
}
|
||||
return i;
|
||||
}
|
||||
foreach (var state in _subjectByState.Keys.OrderBy(k => k)) PlayerOfState(state);
|
||||
foreach (var (ch, state) in _possessedByState)
|
||||
if (_archetypeByActor.TryGetValue(ch, out var a) && a.EndsWith("_PC_C")) _stateByCharacter.TryAdd(ch, state);
|
||||
foreach (var (ch, state) in _stateByCharacter)
|
||||
{
|
||||
var i = PlayerOfState(state);
|
||||
if (i < 0) continue;
|
||||
indexByCharacter[ch] = i;
|
||||
if (_archetypeByActor.TryGetValue(ch, out var arch) && arch.EndsWith("_PC_C"))
|
||||
players[i].Character ??= Simplify(arch);
|
||||
}
|
||||
var merged = players.Select(_ => new List<int[]>()).ToList();
|
||||
foreach (var (ch, moves) in _moves)
|
||||
if (indexByCharacter.TryGetValue(ch, out var i)) merged[i].AddRange(moves);
|
||||
for (var i = 0; i < players.Count; i++)
|
||||
{
|
||||
var tr = players[i].Track;
|
||||
var lastT = int.MinValue / 2;
|
||||
foreach (var mv in merged[i].OrderBy(m => m[0]))
|
||||
{
|
||||
if (mv[0] - lastT < sampleMs) continue;
|
||||
lastT = mv[0];
|
||||
tr.T.Add(mv[0]); tr.X.Add(mv[1]); tr.Y.Add(mv[2]); tr.Z.Add(mv[3]); tr.Yaw.Add(mv[4]); tr.Pitch.Add(mv[5]);
|
||||
}
|
||||
}
|
||||
|
||||
// 라운드: MulticastEndRound(NewRoundNumber=k) 는 라운드 k+1(1부터) 의 시작. 단계 3=구매, 4=교전, 5=라운드 끝
|
||||
var rounds = new List<ReplayRound>();
|
||||
var starts = new List<(int T, int Num)> { (0, 1) };
|
||||
foreach (var (t, idx) in _roundEnds) starts.Add((t, idx + 1));
|
||||
for (var r = 0; r < starts.Count; r++)
|
||||
{
|
||||
var from = starts[r].T;
|
||||
var to = r + 1 < starts.Count ? starts[r + 1].T : int.MaxValue;
|
||||
int Phase(int ph) => _phases.FirstOrDefault(p => p[1] == ph && p[0] >= from && p[0] < to)?[0] ?? -1;
|
||||
var buy = Phase(3);
|
||||
rounds.Add(new ReplayRound { Num = starts[r].Num, Buy = buy >= 0 ? buy : from, Combat = Phase(4), End = Phase(5) });
|
||||
}
|
||||
|
||||
var kinds = new List<string>();
|
||||
var kindIndex = new Dictionary<string, int>();
|
||||
var objects = new List<int[]>();
|
||||
// 맵 자체 연출(예: GameObject_Infinity_Rain_*)은 뺀다
|
||||
var mapName = _map?.Split('/')[^1];
|
||||
foreach (var o in _objects)
|
||||
{
|
||||
if (mapName is not null && o.Kind.Contains("_" + mapName + "_")) continue;
|
||||
if (!kindIndex.TryGetValue(o.Kind, out var k)) { k = kinds.Count; kinds.Add(o.Kind); kindIndex[o.Kind] = k; }
|
||||
var owner = -1;
|
||||
var cur = o.Actor;
|
||||
for (var d = 0; d < 6 && _objectOwner.TryGetValue(cur, out var up); d++)
|
||||
{
|
||||
if (indexByCharacter.TryGetValue(up, out owner)) break;
|
||||
owner = -1;
|
||||
if (_stateByCharacter.ContainsKey(up)) break;
|
||||
if (_subjectByState.ContainsKey(up)) { owner = PlayerOfState(up); break; }
|
||||
cur = up;
|
||||
}
|
||||
objects.Add([o.T0, _closedAt.TryGetValue(o.Actor, out var t1) && t1 >= o.T0 ? t1 : -1, k, o.X, o.Y, o.Z, owner]);
|
||||
}
|
||||
|
||||
return new ReplayFile
|
||||
{
|
||||
MatchId = _matchId,
|
||||
Map = _map,
|
||||
Build = branch?.Replace("++Ares-Core+", ""),
|
||||
RecordedAt = recordedAt,
|
||||
DurationMs = durationMs,
|
||||
SampleMs = sampleMs,
|
||||
Players = players,
|
||||
Rounds = rounds,
|
||||
Phases = _phases,
|
||||
Kills = _kills.Select(k => new[] { k.T, indexByCharacter.GetValueOrDefault(k.Killer, -1), indexByCharacter.GetValueOrDefault(k.Victim, -1) }).ToList(),
|
||||
Shots = _shots.Select(s => new[] { s.T, PlayerOfState(s.State), s.X, s.Y, s.Z, s.Yaw, s.Pitch }).ToList(),
|
||||
Objects = objects,
|
||||
ObjectKinds = kinds,
|
||||
};
|
||||
}
|
||||
}
|
||||
69
tools/replay-extract/src/Model.cs
Normal file
69
tools/replay-extract/src/Model.cs
Normal file
@@ -0,0 +1,69 @@
|
||||
using System.Text.Json;
|
||||
using System.Text.Json.Serialization;
|
||||
|
||||
namespace GvrReplay;
|
||||
|
||||
// 사이트로 가는 형식. 시간은 모두 리플레이 시작부터 ms (t), 좌표는 게임 월드 단위(cm) 정수
|
||||
public sealed class ReplayFile
|
||||
{
|
||||
public string Format { get; set; } = "gvr-replay";
|
||||
public int V { get; set; } = 1;
|
||||
public string? MatchId { get; set; }
|
||||
public string? Map { get; set; }
|
||||
public string? Build { get; set; }
|
||||
/// 리플레이 녹화 시작 시각 (서버 기준 유닉스 ms). t 를 실제 시각으로 바꿀 때 recordedAt + t
|
||||
public long RecordedAt { get; set; }
|
||||
public int DurationMs { get; set; }
|
||||
public int SampleMs { get; set; }
|
||||
public List<ReplayPlayer> Players { get; set; } = [];
|
||||
public List<ReplayRound> Rounds { get; set; } = [];
|
||||
/// [t, phase] 게임 단계 바뀜 (원본 값)
|
||||
public List<int[]> Phases { get; set; } = [];
|
||||
/// [t, killer, victim] (선수 번호, 모르면 -1)
|
||||
public List<int[]> Kills { get; set; } = [];
|
||||
/// [t, player, x, y, z, yaw, pitch] 사격 위치와 방향
|
||||
public List<int[]> Shots { get; set; } = [];
|
||||
/// 스킬 · 설치물 [t0, t1, kind 번호, x, y, z, player] (t1 = 사라진 시각, 모르면 -1)
|
||||
public List<int[]> Objects { get; set; } = [];
|
||||
public List<string> ObjectKinds { get; set; } = [];
|
||||
}
|
||||
|
||||
public sealed class ReplayPlayer
|
||||
{
|
||||
public string? Puuid { get; set; }
|
||||
/// 캐릭터 클래스 (예: Wushu_PC_C). 요원 이름은 사이트가 경기 상세(match-details)로 붙인다
|
||||
public string? Character { get; set; }
|
||||
/// 이동 기록. 열 별 배열 (같은 길이): t, x, y, z, yaw(도), pitch(도)
|
||||
public PlayerTrack Track { get; set; } = new();
|
||||
}
|
||||
|
||||
public sealed class PlayerTrack
|
||||
{
|
||||
public List<int> T { get; set; } = [];
|
||||
public List<int> X { get; set; } = [];
|
||||
public List<int> Y { get; set; } = [];
|
||||
public List<int> Z { get; set; } = [];
|
||||
public List<int> Yaw { get; set; } = [];
|
||||
public List<int> Pitch { get; set; } = [];
|
||||
}
|
||||
|
||||
public sealed class ReplayRound
|
||||
{
|
||||
/// 1부터
|
||||
public int Num { get; set; }
|
||||
/// 구매 단계 시작
|
||||
public int Buy { get; set; }
|
||||
/// 교전 시작 (구매 단계 끝), 모르면 -1
|
||||
public int Combat { get; set; }
|
||||
/// 라운드 끝 (승패 확정), 모르면 -1
|
||||
public int End { get; set; }
|
||||
}
|
||||
|
||||
public static class ReplayJson
|
||||
{
|
||||
public static readonly JsonSerializerOptions Options = new()
|
||||
{
|
||||
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
|
||||
DefaultIgnoreCondition = JsonIgnoreCondition.Never,
|
||||
};
|
||||
}
|
||||
76
tools/replay-extract/src/Program.cs
Normal file
76
tools/replay-extract/src/Program.cs
Normal file
@@ -0,0 +1,76 @@
|
||||
// gvr-replay: 발로란트 리플레이(.vrf) → 사이트 재생기용 JSON (형식 gvr-replay v1)
|
||||
// gvr-replay <file.vrf> <out.json> [--hz 10]
|
||||
// gvr-replay <file.vrf> --stats (디버그: 액터 종류별 개수)
|
||||
// 성공하면 종료 코드 0 과 함께 stdout 마지막 줄에 {"ok":true,...} 요약을 쓴다. 실패는 1 과 {"ok":false,"error":...}
|
||||
using System.Diagnostics;
|
||||
using System.Text.Json;
|
||||
using Replay.Encoding.Archives;
|
||||
using Replay.Models.Descriptors;
|
||||
using Replay.Valorant;
|
||||
using Replay.Valorant.Events;
|
||||
|
||||
namespace GvrReplay;
|
||||
|
||||
public static class Program
|
||||
{
|
||||
public static int Main(string[] args)
|
||||
{
|
||||
if (args.Length < 2)
|
||||
{
|
||||
Console.Error.WriteLine("사용법: gvr-replay <file.vrf> <out.json> [--hz 10] | gvr-replay <file.vrf> --stats");
|
||||
return 2;
|
||||
}
|
||||
var input = args[0];
|
||||
var stats = args[1] == "--stats";
|
||||
var hz = 10;
|
||||
for (var i = 2; i < args.Length - 1; i++)
|
||||
if (args[i] == "--hz") hz = Math.Clamp(int.Parse(args[i + 1]), 1, 60);
|
||||
try
|
||||
{
|
||||
var sw = Stopwatch.StartNew();
|
||||
var collector = new Collector(1000 / hz);
|
||||
using var file = File.OpenRead(input);
|
||||
using var archive = new FBinaryArchive(file);
|
||||
var enricher = new ValorantEventEnricher(collector);
|
||||
var result = ValorantReplayReader.CreateDefault(null, enricher, ParseProfile.Default).Read(archive);
|
||||
enricher.Complete();
|
||||
var info = result.Metadata.ReplayInfo;
|
||||
if (stats)
|
||||
{
|
||||
collector.PrintStats();
|
||||
return 0;
|
||||
}
|
||||
var replay = collector.Build(
|
||||
result.Metadata.ReplayVersion.Branch,
|
||||
FDateTimeToUnixMs(info.Timestamp),
|
||||
info.LengthInMs,
|
||||
hz);
|
||||
var tmp = args[1] + ".tmp";
|
||||
using (var fs = File.Create(tmp))
|
||||
JsonSerializer.Serialize(fs, replay, ReplayJson.Options);
|
||||
File.Move(tmp, args[1], true);
|
||||
Console.WriteLine(JsonSerializer.Serialize(new
|
||||
{
|
||||
ok = true,
|
||||
matchId = replay.MatchId,
|
||||
map = replay.Map,
|
||||
build = replay.Build,
|
||||
players = replay.Players.Count,
|
||||
rounds = replay.Rounds.Count,
|
||||
kills = replay.Kills.Count,
|
||||
elapsedMs = sw.ElapsedMilliseconds,
|
||||
status = result.Status.ToString(),
|
||||
warnings = result.TotalDiagnosticCount,
|
||||
}));
|
||||
return 0;
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
Console.WriteLine(JsonSerializer.Serialize(new { ok = false, error = e.GetType().Name + ": " + e.Message }));
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
/// UE FDateTime ticks (100ns, 0001-01-01 기준, UTC) → 유닉스 ms
|
||||
public static long FDateTimeToUnixMs(long ticks) => ticks <= 0 ? 0 : (ticks - 621355968000000000L) / 10000L;
|
||||
}
|
||||
@@ -120,6 +120,46 @@ try {
|
||||
}
|
||||
|
||||
if ($Phase -eq 'full') {
|
||||
# 3D 리플레이 변환기 (v1.5.0~): .NET SDK 10 (없으면 받음) → ValorantReplayParser 고정 커밋 → win-x64 단일 exe
|
||||
$r['replay_build'] = Step 'replay_build' {
|
||||
$dn = 'C:\win-ci\dotnet'
|
||||
if (-not (Test-Path (Join-Path $dn 'dotnet.exe'))) {
|
||||
$inst = Get-File 'https://dot.net/v1/dotnet-install.ps1' 'dotnet-install.ps1'
|
||||
& powershell -NoProfile -ExecutionPolicy Bypass -File $inst -Channel 10.0 -InstallDir $dn
|
||||
}
|
||||
$env:DOTNET_ROOT = $dn
|
||||
$env:DOTNET_CLI_TELEMETRY_OPTOUT = '1'
|
||||
$env:DOTNET_NOLOGO = '1'
|
||||
& (Join-Path $dn 'dotnet.exe') --version
|
||||
$tx = Join-Path $Repo 'tools\replay-extract'
|
||||
$vd = Join-Path $tx 'vendor\ValorantReplayParser'
|
||||
$pc = (Select-String -Path (Join-Path $tx 'fetch-parser.sh') -Pattern 'PARSER_COMMIT:-([0-9a-f]{40})').Matches[0].Groups[1].Value
|
||||
if (-not (Test-Path (Join-Path $vd '.git'))) { & git clone -q https://github.com/michel-giehl/ValorantReplayParser $vd }
|
||||
& git -C $vd fetch -q origin
|
||||
& git -C $vd checkout -q --force $pc
|
||||
# global.json 의 SDK 패치 버전 고정을 푼다 (fetch-parser.sh 와 같게)
|
||||
$gj = Join-Path $vd 'global.json'
|
||||
$j = Get-Content $gj -Raw | ConvertFrom-Json
|
||||
$j.sdk | Add-Member -NotePropertyName rollForward -NotePropertyValue 'latestFeature' -Force
|
||||
$j | ConvertTo-Json -Depth 5 | Set-Content $gj -Encoding UTF8
|
||||
"parser @ $(& git -C $vd rev-parse --short HEAD)"
|
||||
Push-Location $tx
|
||||
& (Join-Path $dn 'dotnet.exe') publish -c Release -r win-x64 --self-contained true -p:PublishSingleFile=true -p:EnableCompressionInSingleFile=true -p:IncludeNativeLibrariesForSelfExtract=true -p:DebugType=none -o out\win
|
||||
$c = $LASTEXITCODE
|
||||
Pop-Location
|
||||
if ($c -ne 0) { throw "dotnet publish exit $c" }
|
||||
$exe = Join-Path $tx 'out\win\gvr-replay.exe'
|
||||
if (-not (Test-Path $exe)) { throw 'gvr-replay.exe 없음' }
|
||||
"gvr-replay.exe $([math]::Round((Get-Item $exe).Length / 1MB, 1)) MB"
|
||||
# 실제 13.08 리플레이 변환 (호스트가 serve/ 에 둔 시험 파일, 없으면 건너뜀)
|
||||
$vrf = Join-Path $OutDir '4145f041-7d83-4785-ac4b-b532154f14a4.vrf'
|
||||
try { Invoke-WebRequest -Uri 'http://10.0.2.2:8099/gvr-test.vrf' -OutFile $vrf -UseBasicParsing -TimeoutSec 600 } catch { Remove-Item $vrf -Force -ErrorAction SilentlyContinue; "시험 리플레이 없음: $($_.Exception.Message)" }
|
||||
if (Test-Path $vrf) {
|
||||
$out = & $exe $vrf (Join-Path $OutDir 'replay.json')
|
||||
$out
|
||||
if ($LASTEXITCODE -ne 0) { throw "gvr-replay exit $LASTEXITCODE" }
|
||||
}
|
||||
}
|
||||
$r['app_build'] = Step 'app_build' {
|
||||
Push-Location (Join-Path $Repo 'app')
|
||||
& npm.cmd ci --no-audit --no-fund
|
||||
@@ -134,6 +174,9 @@ try {
|
||||
$exe = Get-ChildItem app\release\win-unpacked\GameVoiceRecorder.exe
|
||||
$data = Join-Path $OutDir 'smoke-data'
|
||||
Remove-Item $data -Recurse -Force -ErrorAction SilentlyContinue
|
||||
# 시험 리플레이가 있으면 앱 안의 변환기로 실제 변환까지 확인한다
|
||||
$vrf = Join-Path $OutDir '4145f041-7d83-4785-ac4b-b532154f14a4.vrf'
|
||||
if (Test-Path $vrf) { $env:GVR_SMOKE_VRF = $vrf } else { Remove-Item Env:GVR_SMOKE_VRF -ErrorAction SilentlyContinue }
|
||||
$p = Start-Process $exe.FullName -ArgumentList '--smoke', "--data-dir=$data" -PassThru -Wait
|
||||
Get-Content (Join-Path $data 'smoke.json') -ErrorAction SilentlyContinue
|
||||
if ($p.ExitCode -ne 0) { throw "app smoke exit $($p.ExitCode)" }
|
||||
|
||||
Reference in New Issue
Block a user