51 | );
52 | }
53 |
--------------------------------------------------------------------------------
/tlp-recorder/prisma/migrations/20220525132132_split_up_match_outcome_column/migration.sql:
--------------------------------------------------------------------------------
1 | /*
2 | Warnings:
3 |
4 | - You are about to drop the column `outcome` on the `Match` table. All the data in the column will be lost.
5 | - Added the required column `opponentRoundWins` to the `Match` table without a default value. This is not possible if the table is not empty.
6 | - Added the required column `playerRoundWins` to the `Match` table without a default value. This is not possible if the table is not empty.
7 | - Added the required column `roundWinsRequired` to the `Match` table without a default value. This is not possible if the table is not empty.
8 |
9 | */
10 | -- RedefineTables
11 | PRAGMA foreign_keys=OFF;
12 | CREATE TABLE "new_Match" (
13 | "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
14 | "playerCharacter" TEXT NOT NULL,
15 | "opponent" TEXT NOT NULL,
16 | "opponentCharacter" TEXT NOT NULL,
17 | "stage" TEXT,
18 | "playerRoundWins" INTEGER NOT NULL,
19 | "opponentRoundWins" INTEGER NOT NULL,
20 | "roundWinsRequired" INTEGER NOT NULL,
21 | "recordingUrl" TEXT
22 | );
23 | INSERT INTO "new_Match" ("id", "opponent", "opponentCharacter", "playerCharacter", "recordingUrl", "stage") SELECT "id", "opponent", "opponentCharacter", "playerCharacter", "recordingUrl", "stage" FROM "Match";
24 | DROP TABLE "Match";
25 | ALTER TABLE "new_Match" RENAME TO "Match";
26 | PRAGMA foreign_key_check;
27 | PRAGMA foreign_keys=ON;
28 |
--------------------------------------------------------------------------------
/tlp-webapp/prisma/migrations/20220525132132_split_up_match_outcome_column/migration.sql:
--------------------------------------------------------------------------------
1 | /*
2 | Warnings:
3 |
4 | - You are about to drop the column `outcome` on the `Match` table. All the data in the column will be lost.
5 | - Added the required column `opponentRoundWins` to the `Match` table without a default value. This is not possible if the table is not empty.
6 | - Added the required column `playerRoundWins` to the `Match` table without a default value. This is not possible if the table is not empty.
7 | - Added the required column `roundWinsRequired` to the `Match` table without a default value. This is not possible if the table is not empty.
8 |
9 | */
10 | -- RedefineTables
11 | PRAGMA foreign_keys=OFF;
12 | CREATE TABLE "new_Match" (
13 | "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
14 | "playerCharacter" TEXT NOT NULL,
15 | "opponent" TEXT NOT NULL,
16 | "opponentCharacter" TEXT NOT NULL,
17 | "stage" TEXT,
18 | "playerRoundWins" INTEGER NOT NULL,
19 | "opponentRoundWins" INTEGER NOT NULL,
20 | "roundWinsRequired" INTEGER NOT NULL,
21 | "recordingUrl" TEXT
22 | );
23 | INSERT INTO "new_Match" ("id", "opponent", "opponentCharacter", "playerCharacter", "recordingUrl", "stage") SELECT "id", "opponent", "opponentCharacter", "playerCharacter", "recordingUrl", "stage" FROM "Match";
24 | DROP TABLE "Match";
25 | ALTER TABLE "new_Match" RENAME TO "Match";
26 | PRAGMA foreign_key_check;
27 | PRAGMA foreign_keys=ON;
28 |
--------------------------------------------------------------------------------
/tlp-webapp/src/modules/dashboard/MatchupsTable.tsx:
--------------------------------------------------------------------------------
1 | import { Loader, Table } from '@mantine/core';
2 |
3 | import Error from '@/components/common/Error';
4 | import { Matchup } from '@/lib/types';
5 |
6 | import MatchupsTableRow from './MatchupsTableRow';
7 | import useCharacterSummary from './useCharacterSummary';
8 |
9 | export interface MatchupsTableProps {}
10 |
11 | export default function MatchupsTable(props: MatchupsTableProps) {
12 | const { data: characterSummary, error, isLoading, isIdle, isError } = useCharacterSummary();
13 |
14 | if (isLoading || isIdle) {
15 | return ;
16 | }
17 |
18 | if (isError) {
19 | return ;
20 | }
21 |
22 | const { matchups } = characterSummary;
23 | const rows = matchups.map((matchup) => (
24 |
25 | ));
26 |
27 | return (
28 |
= NextPage & {
7 | pageTitle?: string;
8 | breadCrumbs?: Breadcrumb[];
9 | };
10 |
11 | export type NextComponentWithLayout = NextComponentType &
12 | Partial;
13 |
14 | export interface Breadcrumb {
15 | label: string;
16 | path: string;
17 | }
18 |
19 | export interface Rival extends MatchesPlayed, LastMatchPlayed {
20 | name: string;
21 | }
22 |
23 | export interface Matchup extends MatchesPlayed, LastMatchPlayed {
24 | character: string;
25 | }
26 |
27 | export interface Stage extends MatchesPlayed, LastMatchPlayed {
28 | name: string;
29 | }
30 |
31 | export interface Character extends MatchesPlayed, LastMatchPlayed {
32 | name: string;
33 | }
34 |
35 | export interface CharacterSummary {
36 | character: Character;
37 | latestMatches: Match[];
38 | matchups: Matchup[];
39 | stages: Stage[];
40 | }
41 |
42 | // TODO: Maybe I want to show in the future if a setting is being overriden
43 | // by the corresponding environment variable
44 | export interface Settings {
45 | recorder: RecorderSettings;
46 | overrides?: {
47 | recorder?: Partial;
48 | };
49 | }
50 |
51 | export interface RecorderSettings {
52 | enableDatabaseSync: boolean;
53 | enableNotationSync: boolean;
54 | enableVideoRecording: boolean;
55 | enableVideoUpload: boolean;
56 | enableCleanup: boolean;
57 | obsWebsocketPort: number;
58 | obsWebsocketPassword: string;
59 | recordingPath: string;
60 | matchesPerRecording: number;
61 | uploadDelay: number;
62 | cleanupDelay: number;
63 | logLevel: 'verbose' | 'info';
64 | tickInterval: number;
65 | }
66 |
67 | export interface LastMatchPlayed {
68 | lastPlayed: Date;
69 | lastPlayedId: number;
70 | }
71 |
72 | export interface MatchesPlayed {
73 | games: number;
74 | wins: number;
75 | losses: number;
76 | draws: number;
77 | }
78 |
79 | export interface CharacterMatchesPlayed extends MatchesPlayed {
80 | name: string;
81 | }
82 |
83 | export interface WeeklyPerformance extends MatchesPlayed {
84 | characters: CharacterMatchesPlayed[];
85 | }
86 |
87 | export interface WeeklyPerformanceResponse {
88 | thisWeek: WeeklyPerformance;
89 | lastWeek: WeeklyPerformance;
90 | twoWeeksAgo: WeeklyPerformance;
91 | }
92 |
--------------------------------------------------------------------------------
/tlp-recorder/src/recording/youtube/uploader.ts:
--------------------------------------------------------------------------------
1 | import fs from 'fs';
2 |
3 | import { google } from 'googleapis';
4 | import { OAuth2Client } from 'googleapis/node_modules/google-auth-library';
5 |
6 | import db from '@/database';
7 | import log from '@/helpers/log';
8 | import config from '@/config';
9 | import getLatestVideoPath, { scheduleCleanup } from '@/recording/util';
10 | import { VideoOptions } from '@/types/types';
11 |
12 | export async function uploadVideo(
13 | client: OAuth2Client,
14 | path: string,
15 | options: VideoOptions,
16 | matchIds: number[],
17 | ): Promise {
18 | try {
19 | const service = google.youtube({
20 | version: 'v3',
21 | auth: client,
22 | });
23 |
24 | service.videos.insert(
25 | {
26 | part: ['snippet', 'status'],
27 | requestBody: {
28 | snippet: {
29 | title: options.title,
30 | description: options.description,
31 | tags: options.tags,
32 | categoryId: options.categoryId ?? '24',
33 | defaultLanguage: 'en',
34 | defaultAudioLanguage: 'en',
35 | },
36 | status: {
37 | privacyStatus: options.privacyStatus ?? 'private',
38 | },
39 | },
40 | media: {
41 | body: fs.createReadStream(path),
42 | },
43 | },
44 | async (err, res) => {
45 | if (err) {
46 | log.error('Failed to upload recording', err);
47 | }
48 |
49 | const videoUrl = `https://www.youtube.com/watch?v=${res?.data.id}`;
50 | log.info(`Upload finished: ${videoUrl}`);
51 |
52 | if (matchIds && matchIds.length > 0) {
53 | await db.match.updateMany({
54 | where: {
55 | id: { in: [...matchIds] },
56 | },
57 | data: {
58 | recordingUrl: videoUrl,
59 | },
60 | });
61 | log.debug('Adding YouTube URL to matches', { matchIds });
62 | }
63 |
64 | if (config.ENABLE_CLEANUP) {
65 | scheduleCleanup(path);
66 | }
67 | },
68 | );
69 | } catch (err) {
70 | log.error('Failed to upload video', err);
71 | }
72 | }
73 |
74 | export default async function uploadLatestVideo(
75 | client: OAuth2Client,
76 | options: VideoOptions,
77 | matchIds: number[],
78 | ): Promise {
79 | const path = getLatestVideoPath();
80 |
81 | log.debug('Uploading to YouTube', { path });
82 |
83 | if (!path) {
84 | throw new Error('Did not find any video file to upload');
85 | }
86 |
87 | return uploadVideo(client, path, options, matchIds);
88 | }
89 |
--------------------------------------------------------------------------------
/tlp-recorder/src/recording/obs/broker.ts:
--------------------------------------------------------------------------------
1 | import OBSWebSocket from 'obs-websocket-js';
2 |
3 | import config from '@/config';
4 | import log from '@/helpers/log';
5 | import getNotation from '@/tekken/notation';
6 | import { TickEventData } from '@/types/types';
7 |
8 | export default class Broker {
9 | private static instance: Broker;
10 |
11 | private obs: OBSWebSocket;
12 |
13 | private constructor() {
14 | this.obs = new OBSWebSocket();
15 | }
16 |
17 | static async getInstance(): Promise {
18 | if (Broker.instance) return Broker.instance;
19 |
20 | const instance = new Broker();
21 | await instance.connect();
22 | Broker.instance = instance;
23 |
24 | return instance;
25 | }
26 |
27 | async connect(): Promise {
28 | await this.obs.connect(`ws://127.0.0.1:${config.OBS_WS_PORT}`, config.OBS_WS_PASSWORD);
29 | log.info('Connected to OBS');
30 | }
31 |
32 | async startRecording(): Promise {
33 | await this.obs.call('StartRecord');
34 | }
35 |
36 | async stopRecording(): Promise {
37 | await this.obs.call('StopRecord');
38 | }
39 |
40 | async pauseRecording(): Promise {
41 | await this.obs.call('PauseRecord');
42 | }
43 |
44 | async resumeRecording(): Promise {
45 | await this.obs.call('ResumeRecord');
46 | }
47 |
48 | async getRecordingStatus(): Promise<{
49 | outputActive: boolean;
50 | ouputPaused: boolean;
51 | outputTimecode: string;
52 | outputDuration: number;
53 | outputBytes: number;
54 | }> {
55 | return this.obs.call('GetRecordStatus');
56 | }
57 |
58 | async updateMetadataFromTick(data: TickEventData, previousTickData: TickEventData) {
59 | const { playerInput, opponentInput } = data;
60 | const { playerInput: prevPlayerInput, opponentInput: prevOpponentInput } = previousTickData;
61 |
62 | if (playerInput.attack !== '' && playerInput.attack !== prevPlayerInput.attack) {
63 | await this.updateText('p1move', getNotation(playerInput));
64 | }
65 |
66 | if (opponentInput.attack !== '' && opponentInput.attack !== prevOpponentInput.attack) {
67 | await this.updateText('p2move', getNotation(opponentInput));
68 | }
69 | }
70 |
71 | async updateText(sourceName: string, text: string): Promise {
72 | await this.obs.call('SetInputSettings', {
73 | inputName: sourceName,
74 | inputSettings: {
75 | text,
76 | },
77 | });
78 | }
79 |
80 | async clearAllText(): Promise {
81 | const sources = ['p1move', 'p2move', 'p1framedata', 'p2framedata'];
82 | const updates = sources.map((source) => this.updateText(source, ''));
83 | await Promise.all(updates);
84 | }
85 | }
86 |
--------------------------------------------------------------------------------
/tlp-recorder/.gitignore:
--------------------------------------------------------------------------------
1 | /pkg
2 | /credentials
3 | /prisma/database.db*
4 |
5 | # Logs
6 | logs
7 | *.log
8 | npm-debug.log*
9 | yarn-debug.log*
10 | yarn-error.log*
11 | lerna-debug.log*
12 | .pnpm-debug.log*
13 |
14 | # Diagnostic reports (https://nodejs.org/api/report.html)
15 | report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
16 |
17 | # Runtime data
18 | pids
19 | *.pid
20 | *.seed
21 | *.pid.lock
22 |
23 | # Directory for instrumented libs generated by jscoverage/JSCover
24 | lib-cov
25 |
26 | # Coverage directory used by tools like istanbul
27 | coverage
28 | *.lcov
29 |
30 | # nyc test coverage
31 | .nyc_output
32 |
33 | # Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
34 | .grunt
35 |
36 | # Bower dependency directory (https://bower.io/)
37 | bower_components
38 |
39 | # node-waf configuration
40 | .lock-wscript
41 |
42 | # Compiled binary addons (https://nodejs.org/api/addons.html)
43 | build/Release
44 |
45 | # Dependency directories
46 | node_modules/
47 | jspm_packages/
48 |
49 | # Snowpack dependency directory (https://snowpack.dev/)
50 | web_modules/
51 |
52 | # TypeScript cache
53 | *.tsbuildinfo
54 |
55 | # Optional npm cache directory
56 | .npm
57 |
58 | # Optional eslint cache
59 | .eslintcache
60 |
61 | # Optional stylelint cache
62 | .stylelintcache
63 |
64 | # Microbundle cache
65 | .rpt2_cache/
66 | .rts2_cache_cjs/
67 | .rts2_cache_es/
68 | .rts2_cache_umd/
69 |
70 | # Optional REPL history
71 | .node_repl_history
72 |
73 | # Output of 'npm pack'
74 | *.tgz
75 |
76 | # Yarn Integrity file
77 | .yarn-integrity
78 |
79 | # dotenv environment variable files
80 | .env
81 | .env.development.local
82 | .env.test.local
83 | .env.production.local
84 | .env.local
85 |
86 | # parcel-bundler cache (https://parceljs.org/)
87 | .cache
88 | .parcel-cache
89 |
90 | # Next.js build output
91 | .next
92 | out
93 |
94 | # Nuxt.js build / generate output
95 | .nuxt
96 | dist
97 |
98 | # Gatsby files
99 | .cache/
100 | # Comment in the public line in if your project uses Gatsby and not Next.js
101 | # https://nextjs.org/blog/next-9-1#public-directory-support
102 | # public
103 |
104 | # vuepress build output
105 | .vuepress/dist
106 |
107 | # vuepress v2.x temp and cache directory
108 | .temp
109 | .cache
110 |
111 | # Docusaurus cache and generated files
112 | .docusaurus
113 |
114 | # Serverless directories
115 | .serverless/
116 |
117 | # FuseBox cache
118 | .fusebox/
119 |
120 | # DynamoDB Local files
121 | .dynamodb/
122 |
123 | # TernJS port file
124 | .tern-port
125 |
126 | # Stores VSCode versions used for testing VSCode extensions
127 | .vscode-test
128 |
129 | # yarn v2
130 | .yarn/cache
131 | .yarn/unplugged
132 | .yarn/build-state.yml
133 | .yarn/install-state.gz
134 | .pnp.*
--------------------------------------------------------------------------------
/.github/workflows/main.yml:
--------------------------------------------------------------------------------
1 | name: Create test release
2 |
3 | on:
4 | push:
5 | tags:
6 | - "v*.*.*"
7 |
8 | # Allows you to run this workflow manually from the Actions tab
9 | workflow_dispatch:
10 |
11 | # A workflow run is made up of one or more jobs that can run sequentially or in parallel
12 | jobs:
13 | build-recorder:
14 | runs-on: windows-latest
15 | steps:
16 | - uses: actions/checkout@v3
17 | - uses: actions/setup-node@v3
18 | with:
19 | node-version: 16
20 | - name: Install commands
21 | run: |
22 | npm install -g pkg
23 | npm install -g yarn
24 | - name: Install dependencies
25 | working-directory: ./tlp-recorder
26 | run: yarn install
27 | - name: Generate Prisma client
28 | working-directory: ./tlp-recorder
29 | run: yarn prisma generate
30 | - name: Build
31 | working-directory: ./tlp-recorder
32 | run: yarn build
33 | - name: Package
34 | working-directory: ./tlp-recorder
35 | run: pkg .
36 | - uses: actions/upload-artifact@master
37 | with:
38 | name: recorder-exe
39 | path: ./tlp-recorder/pkg/tlp-recorder.exe
40 | build-webapp:
41 | runs-on: windows-latest
42 | steps:
43 | - uses: actions/checkout@v3
44 | - uses: actions/setup-node@v3
45 | with:
46 | node-version: 16
47 | - name: Install commands
48 | run: |
49 | npm install -g pkg
50 | npm install -g yarn
51 | - name: Install dependencies
52 | working-directory: ./tlp-webapp
53 | run: yarn install
54 | - name: Generate Prisma client
55 | working-directory: ./tlp-webapp
56 | run: yarn prisma generate
57 | - name: Build
58 | working-directory: ./tlp-webapp
59 | run: yarn build
60 | - name: Package
61 | working-directory: ./tlp-webapp
62 | run: pkg .
63 | - uses: actions/upload-artifact@master
64 | with:
65 | name: webapp-exe
66 | path: ./tlp-webapp/pkg/tlp-webapp.exe
67 | create-release:
68 | needs: [build-recorder, build-webapp]
69 | runs-on: ubuntu-latest
70 | steps:
71 | - uses: actions/checkout@v3
72 | - uses: actions/download-artifact@master
73 | with:
74 | name: recorder-exe
75 | path: ./bin/
76 | - uses: actions/download-artifact@master
77 | with:
78 | name: webapp-exe
79 | path: ./bin/
80 | - name: Archive Release
81 | uses: montudor/action-zip@v1
82 | with:
83 | args: zip -qq -r ./tlp_win64.zip ./bin
84 | - name: Create Release
85 | uses: softprops/action-gh-release@v1
86 | with:
87 | files: ./tlp_win64.zip
88 | token: ${{ secrets.TOKEN }}
89 |
--------------------------------------------------------------------------------
/tlp-webapp/src/modules/settings/useSettingsForm.ts:
--------------------------------------------------------------------------------
1 | import { useState } from 'react';
2 | import { useQueryClient } from 'react-query';
3 |
4 | import axios, { AxiosError } from 'axios';
5 | import { useForm } from '@mantine/form';
6 |
7 | import { RecorderSettings, Settings } from '@/lib/types';
8 |
9 | // TODO: Refactoring
10 | export default function useSettingsForm({ recorder }: Settings) {
11 | const queryClient = useQueryClient();
12 | const [loading, setLoading] = useState(false);
13 | const [success, setSuccess] = useState(false);
14 | const [error, setError] = useState(null);
15 | const form = useForm({
16 | initialValues: {
17 | enableDatabaseSync: recorder.enableDatabaseSync,
18 | enableNotationSync: recorder.enableNotationSync,
19 | enableVideoRecording: recorder.enableVideoRecording,
20 | enableVideoUpload: recorder.enableVideoUpload,
21 | enableCleanup: recorder.enableCleanup,
22 | obsWebsocketPort: recorder.obsWebsocketPort,
23 | obsWebsocketPassword: recorder.obsWebsocketPassword,
24 | recordingPath: recorder.recordingPath,
25 | matchesPerRecording: recorder.matchesPerRecording,
26 | uploadDelay: recorder.uploadDelay,
27 | cleanupDelay: recorder.cleanupDelay,
28 | logLevel: recorder.logLevel,
29 | tickInterval: recorder.tickInterval,
30 | },
31 | validate: {
32 | logLevel: (value) =>
33 | value === 'info' || value === 'verbose' ? null : 'Log level must be "info" or "verbose"',
34 | obsWebsocketPort: (value) =>
35 | value >= 0 && value <= 65535 ? null : 'OBS Websocket port must be between 0 and 65535',
36 | obsWebsocketPassword: (value) =>
37 | value.length > 0 ? null : 'OBS Websocket password cannot be empty',
38 | matchesPerRecording: (value) =>
39 | value > 0 ? null : 'Matches per recording must be greater than 0',
40 | recordingPath: (value) =>
41 | !value.includes('\\') ? null : 'Use "/" instead of "\\" for the recording path',
42 | },
43 | });
44 |
45 | async function handleSubmit(values: RecorderSettings) {
46 | const newSettings: Settings = {
47 | recorder: {
48 | ...values,
49 | },
50 | };
51 | try {
52 | setLoading(true);
53 | const response = await axios.post('/api/settings', newSettings);
54 | if (response.status === 200) {
55 | setSuccess(true);
56 | queryClient.invalidateQueries('settings');
57 | }
58 | } catch (err) {
59 | if (err instanceof AxiosError) {
60 | setError(err.response?.data ?? err.message);
61 | } else {
62 | setError('Unknown error');
63 | }
64 | } finally {
65 | setLoading(false);
66 | }
67 | }
68 |
69 | return {
70 | loading,
71 | error,
72 | setError,
73 | success,
74 | setSuccess,
75 | form,
76 | handleSubmit,
77 | };
78 | }
79 |
--------------------------------------------------------------------------------
/.github/workflows/codeql-analysis.yml:
--------------------------------------------------------------------------------
1 | # For most projects, this workflow file will not need changing; you simply need
2 | # to commit it to your repository.
3 | #
4 | # You may wish to alter this file to override the set of languages analyzed,
5 | # or to provide custom queries or build logic.
6 | #
7 | # ******** NOTE ********
8 | # We have attempted to detect the languages in your repository. Please check
9 | # the `language` matrix defined below to confirm you have the correct set of
10 | # supported CodeQL languages.
11 | #
12 | name: "CodeQL"
13 |
14 | on:
15 | push:
16 | branches: [ master ]
17 | pull_request:
18 | # The branches below must be a subset of the branches above
19 | branches: [ master ]
20 | schedule:
21 | - cron: '20 16 * * 2'
22 |
23 | jobs:
24 | analyze:
25 | name: Analyze
26 | runs-on: ubuntu-latest
27 | permissions:
28 | actions: read
29 | contents: read
30 | security-events: write
31 |
32 | strategy:
33 | fail-fast: false
34 | matrix:
35 | language: [ 'javascript' ]
36 | # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
37 | # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
38 |
39 | steps:
40 | - name: Checkout repository
41 | uses: actions/checkout@v3
42 |
43 | # Initializes the CodeQL tools for scanning.
44 | - name: Initialize CodeQL
45 | uses: github/codeql-action/init@v2
46 | with:
47 | languages: ${{ matrix.language }}
48 | # If you wish to specify custom queries, you can do so here or in a config file.
49 | # By default, queries listed here will override any specified in a config file.
50 | # Prefix the list here with "+" to use these queries and those in the config file.
51 |
52 | # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
53 | queries: +security-and-quality
54 |
55 |
56 | # Autobuild attempts to build any compiled languages (C/C++, C#, or Java).
57 | # If this step fails, then you should remove it and run the build manually (see below)
58 | - name: Autobuild
59 | uses: github/codeql-action/autobuild@v2
60 |
61 | # ℹ️ Command-line programs to run using the OS shell.
62 | # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
63 |
64 | # If the Autobuild fails above, remove it and uncomment the following three lines.
65 | # modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
66 |
67 | # - run: |
68 | # echo "Run, Build Application using script"
69 | # ./location_of_script_within_repo/buildscript.sh
70 |
71 | - name: Perform CodeQL Analysis
72 | uses: github/codeql-action/analyze@v2
73 |
--------------------------------------------------------------------------------
/tlp-webapp/src/pages/api/matches/weeklyPerformance.ts:
--------------------------------------------------------------------------------
1 | import type { NextApiRequest, NextApiResponse } from 'next';
2 |
3 | import sub from 'date-fns/sub';
4 |
5 | import db from '@/lib/database';
6 | import { WeeklyPerformanceResponse } from '@/lib/types';
7 |
8 | export default async function handler(
9 | req: NextApiRequest,
10 | res: NextApiResponse,
11 | ) {
12 | const today = new Date();
13 | const lastWeek = sub(today, { weeks: 1 });
14 | const twoWeeksAgo = sub(today, { weeks: 2 });
15 | const threeWeeksAgo = sub(today, { weeks: 3 });
16 |
17 | const matchesThisWeek = await db.match.findMany({
18 | where: {
19 | createdAt: {
20 | gte: lastWeek,
21 | },
22 | },
23 | orderBy: {
24 | createdAt: 'desc',
25 | },
26 | });
27 | const winsThisWeek = matchesThisWeek.filter(
28 | (match) => match.playerRoundWins > match.opponentRoundWins,
29 | );
30 | const lossesThisWeek = matchesThisWeek.filter(
31 | (match) => match.playerRoundWins < match.opponentRoundWins,
32 | );
33 | const drawsThisWeek = matchesThisWeek.filter(
34 | (match) => match.playerRoundWins === match.opponentRoundWins,
35 | );
36 |
37 | const matchesLastWeek = await db.match.findMany({
38 | where: {
39 | createdAt: {
40 | gte: twoWeeksAgo,
41 | lt: lastWeek,
42 | },
43 | },
44 | orderBy: {
45 | createdAt: 'desc',
46 | },
47 | });
48 | const winsLastWeek = matchesLastWeek.filter(
49 | (match) => match.playerRoundWins > match.opponentRoundWins,
50 | );
51 | const lossesLastWeek = matchesLastWeek.filter(
52 | (match) => match.playerRoundWins < match.opponentRoundWins,
53 | );
54 | const drawsLastWeek = matchesLastWeek.filter(
55 | (match) => match.playerRoundWins === match.opponentRoundWins,
56 | );
57 |
58 | const matchesTwoWeeksAgo = await db.match.findMany({
59 | where: {
60 | createdAt: {
61 | gte: threeWeeksAgo,
62 | lt: twoWeeksAgo,
63 | },
64 | },
65 | orderBy: {
66 | createdAt: 'desc',
67 | },
68 | });
69 | const winsTwoWeeksAgo = matchesTwoWeeksAgo.filter(
70 | (match) => match.playerRoundWins > match.opponentRoundWins,
71 | );
72 | const lossesTwoWeeksAgo = matchesTwoWeeksAgo.filter(
73 | (match) => match.playerRoundWins < match.opponentRoundWins,
74 | );
75 | const drawsTwoWeeksAgo = matchesTwoWeeksAgo.filter(
76 | (match) => match.playerRoundWins === match.opponentRoundWins,
77 | );
78 |
79 | const response: WeeklyPerformanceResponse = {
80 | thisWeek: {
81 | games: matchesThisWeek.length,
82 | wins: winsThisWeek.length,
83 | losses: lossesThisWeek.length,
84 | draws: drawsThisWeek.length,
85 | characters: [], // TODO: implement this
86 | },
87 | lastWeek: {
88 | games: matchesThisWeek.length,
89 | wins: winsLastWeek.length,
90 | losses: lossesLastWeek.length,
91 | draws: drawsLastWeek.length,
92 | characters: [], // TODO: implement this
93 | },
94 | twoWeeksAgo: {
95 | games: matchesTwoWeeksAgo.length,
96 | wins: winsTwoWeeksAgo.length,
97 | losses: lossesTwoWeeksAgo.length,
98 | draws: drawsTwoWeeksAgo.length,
99 | characters: [], // TODO: implement this
100 | },
101 | };
102 |
103 | res.status(200).json(response);
104 | }
105 |
--------------------------------------------------------------------------------
/tlp-webapp/src/modules/settings/SettingsForm.tsx:
--------------------------------------------------------------------------------
1 | import { Box, Title, Checkbox, TextInput, Group, Button, Notification } from '@mantine/core';
2 |
3 | import { Settings } from '@/lib/types';
4 | import useSettingsForm from './useSettingsForm';
5 | import { X, Check } from 'tabler-icons-react';
6 |
7 | export interface SettingsFormProps {
8 | settings: Settings;
9 | }
10 |
11 | export default function SettingsForm({ settings }: SettingsFormProps) {
12 | // TODO: Refactoring
13 | const { loading, success, setSuccess, error, setError, form, handleSubmit } =
14 | useSettingsForm(settings);
15 |
16 | return (
17 |
18 |
95 |
96 | {error && (
97 | }
99 | color="red"
100 | title="Something went wrong"
101 | onClose={() => setError(null)}
102 | mt={12}
103 | >
104 | {error}
105 |
106 | )}
107 |
108 | {success && (
109 | }
111 | color="teal"
112 | title="Configuration updated"
113 | onClose={() => setSuccess(false)}
114 | mt={12}
115 | >
116 | Please restart the recorder application to apply your settings.
117 |
118 | )}
119 |
120 | );
121 | }
122 |
--------------------------------------------------------------------------------
/tlp-webapp/src/pages/api/characters/[character].ts:
--------------------------------------------------------------------------------
1 | import type { NextApiRequest, NextApiResponse } from 'next';
2 |
3 | import db from '@/lib/database';
4 | import { CharacterSummary, Matchup, Stage } from '@/lib/types';
5 |
6 | // TODO: Split this up
7 | export default async function handler(req: NextApiRequest, res: NextApiResponse) {
8 | const limit = Number(req.query.limit);
9 | const characterName = req.query.character as string;
10 |
11 | const allMatches = await db.match.findMany({
12 | where: {
13 | playerCharacter: characterName,
14 | },
15 | orderBy: {
16 | createdAt: 'desc',
17 | },
18 | });
19 |
20 | const latestMatches = await db.match.findMany({
21 | where: {
22 | playerCharacter: characterName,
23 | },
24 | orderBy: {
25 | createdAt: 'desc',
26 | },
27 | take: isNaN(limit) ? 10 : limit,
28 | });
29 |
30 | const wins = allMatches.filter((match) => match.playerRoundWins > match.opponentRoundWins).length;
31 | const losses = allMatches.filter(
32 | (match) => match.playerRoundWins < match.opponentRoundWins,
33 | ).length;
34 | const draws = allMatches.length - wins - losses;
35 | const [latestMatch] = allMatches;
36 |
37 | const playedOpponentCharacters = await db.match.groupBy({
38 | by: ['opponentCharacter'],
39 | where: {
40 | playerCharacter: characterName,
41 | },
42 | _count: {
43 | id: true,
44 | },
45 | orderBy: {
46 | _count: {
47 | id: 'desc',
48 | },
49 | },
50 | });
51 |
52 | const matchups = playedOpponentCharacters.map((result) => {
53 | const relevantMatches = allMatches.filter(
54 | (match) => match.opponentCharacter === result.opponentCharacter,
55 | );
56 | const wins = relevantMatches.filter(
57 | (match) => match.playerRoundWins > match.opponentRoundWins,
58 | ).length;
59 | const losses = relevantMatches.filter(
60 | (match) => match.playerRoundWins < match.opponentRoundWins,
61 | ).length;
62 | const draws = relevantMatches.length - wins - losses;
63 | const [latestMatchForMatchup] = relevantMatches;
64 |
65 | return {
66 | character: result.opponentCharacter,
67 | games: result._count.id,
68 | wins,
69 | losses,
70 | draws,
71 | lastPlayed: latestMatchForMatchup.createdAt,
72 | lastPlayedId: latestMatchForMatchup.id,
73 | } as Matchup;
74 | });
75 |
76 | const playedStages = await db.match.groupBy({
77 | by: ['stage'],
78 | where: {
79 | playerCharacter: characterName,
80 | },
81 | _count: {
82 | id: true,
83 | },
84 | orderBy: {
85 | _count: {
86 | id: 'desc',
87 | },
88 | },
89 | });
90 |
91 | const stages = playedStages.map((result) => {
92 | const relevantMatches = allMatches.filter((match) => match.stage === result.stage);
93 | const wins = relevantMatches.filter(
94 | (match) => match.playerRoundWins > match.opponentRoundWins,
95 | ).length;
96 | const losses = relevantMatches.filter(
97 | (match) => match.playerRoundWins < match.opponentRoundWins,
98 | ).length;
99 | const draws = relevantMatches.length - wins - losses;
100 | const [latestMatchForMatchup] = relevantMatches;
101 |
102 | return {
103 | name: result.stage,
104 | games: result._count.id,
105 | wins,
106 | losses,
107 | draws,
108 | lastPlayed: latestMatchForMatchup.createdAt,
109 | lastPlayedId: latestMatchForMatchup.id,
110 | } as Stage;
111 | });
112 |
113 | const characterSummary: CharacterSummary = {
114 | character: {
115 | name: characterName,
116 | games: allMatches.length,
117 | wins,
118 | losses,
119 | draws,
120 | lastPlayed: latestMatch?.createdAt,
121 | lastPlayedId: latestMatch?.id,
122 | },
123 | latestMatches,
124 | matchups,
125 | stages,
126 | };
127 |
128 | res.status(200).json(characterSummary);
129 | }
130 |
--------------------------------------------------------------------------------
/tlp-recorder/src/recording/youtube/auth.ts:
--------------------------------------------------------------------------------
1 | import fs from 'fs';
2 | import path from 'path';
3 |
4 | import open from 'open';
5 | import express from 'express';
6 | import { google } from 'googleapis';
7 | import { OAuth2Client } from 'googleapis/node_modules/google-auth-library';
8 |
9 | import log from '@/helpers/log';
10 | import config, { isDevl } from '@/config';
11 | import { GoogleAuthConfig } from '@/types/types';
12 |
13 | const { OAuth2 } = google.auth;
14 |
15 | let credentials: GoogleAuthConfig;
16 |
17 | if (config.ENABLE_VIDEO_UPLOAD) {
18 | const credentialFilePath = isDevl()
19 | ? path.join(process.cwd(), 'credentials', 'google.keys.json')
20 | : path.join(process.cwd(), 'google.keys.json');
21 |
22 | try {
23 | const credentialsExist = fs.existsSync(credentialFilePath);
24 | if (!credentialsExist) {
25 | log.error('File google.keys.json does not exist.');
26 | log.info('https://github.com/marcelherd/TekkenLearningPlatform/wiki/YouTube-Upload-Setup');
27 | process.exit(1);
28 | }
29 |
30 | fs.accessSync(credentialFilePath, fs.constants.R_OK);
31 | } catch (err) {
32 | log.error('File google.keys.json is not readable');
33 | process.exit(1);
34 | }
35 |
36 | const credentialContents: string = fs.readFileSync(credentialFilePath, 'utf8');
37 | credentials = JSON.parse(credentialContents);
38 |
39 | if (
40 | !credentials.web ||
41 | !(typeof credentials.web.client_id === 'string') ||
42 | !(typeof credentials.web.client_secret === 'string') ||
43 | !Array.isArray(credentials.web.redirect_uris)
44 | ) {
45 | throw new Error(
46 | 'google.keys.json is corrupted, please re-download it from Google Cloud Console',
47 | );
48 | }
49 |
50 | if (credentials.web.redirect_uris.length < 1) {
51 | throw new Error(
52 | 'Add http://localhost:5431 as redirect URL in Google Cloud Console then update google.keys.json',
53 | );
54 | }
55 | }
56 |
57 | export default async function getAuthenticatedClient(): Promise {
58 | return new Promise((resolve, reject) => {
59 | const clientId = credentials.web.client_id;
60 | const clientSecret = credentials.web.client_secret;
61 | const [redirectUrl] = credentials.web.redirect_uris;
62 |
63 | const client = new OAuth2(clientId, clientSecret, redirectUrl);
64 |
65 | const authorizeUrl = client.generateAuthUrl({
66 | access_type: 'offline',
67 | scope: ['https://www.googleapis.com/auth/youtube.upload'],
68 | });
69 |
70 | const app = express();
71 |
72 | const server = app.listen(5431, async () => {
73 | log.debug('Waiting for authorization code');
74 | log.info('Please open this URL in your browser and sign in using your YouTube account:');
75 | log.info(authorizeUrl);
76 |
77 | const childProcess = await open(authorizeUrl, { wait: false });
78 | childProcess.unref();
79 | });
80 |
81 | app.get('/callback', async (req, res) => {
82 | const { code } = req.query;
83 |
84 | if (typeof code === 'string') {
85 | log.debug('Received authorization code');
86 |
87 | const result = await client.getToken(code);
88 |
89 | if (result.tokens.access_token) {
90 | client.setCredentials(result.tokens);
91 |
92 | log.debug('Retrieved access token');
93 | log.info('Signed in, recordings will be uploaded to your YouTube channel.');
94 |
95 | res.send('Authentication successful, you can close this page now.');
96 | server.close();
97 | resolve(client);
98 | } else {
99 | log.error('Failed to retrieve access token for authorization code', { code });
100 |
101 | res.status(400).send('Failed to retrieve access token');
102 | reject();
103 | }
104 | } else {
105 | log.error('Received invalid authorization code', { code });
106 |
107 | res.status(400).send('No code provided');
108 | reject();
109 | }
110 | });
111 | });
112 | }
113 |
--------------------------------------------------------------------------------
/bin/config.yaml:
--------------------------------------------------------------------------------
1 | settings:
2 | recorder:
3 | # -----------------------------------------
4 | # Enable/disable functionalities
5 | # -----------------------------------------
6 |
7 | # If enabled, the recorder will keep track of any matches you play and add
8 | # them to your match history as well as consider them when computing
9 | # your statistics.
10 | enableDatabaseSync: true
11 |
12 | # If enabled, the recorder will send any button presses you or your
13 | # opponent input to OBS Studio.
14 | # This requires OBS Studio to be running prior to starting the
15 | # recorder module. See also:
16 | # https://github.com/marcelherd/TekkenLearningPlatform/wiki/OBS-Studio-Setup
17 | enableNotationSync: false
18 |
19 | # If enabled, the recorder will automatically record your matches as
20 | # video as you're playing. It will start recording when your match
21 | # starts and automatically end the recording when it finishes.
22 | # If the setting "matchesPerRecording" is greater than one, it will
23 | # automatically pause and resume the recording in between matches.
24 | # This requires OBS Studio to be running prior to starting the
25 | # recorder module. See also:
26 | # https://github.com/marcelherd/TekkenLearningPlatform/wiki/OBS-Studio-Setup
27 | enableVideoRecording: false
28 |
29 | # If enabled, the recorder will automatically upload your video recordings
30 | # once they are saved (i.e. when "matchesPerRecording" games have been played).
31 | # Enabling this setting does not do anything unless video recordings are enabled
32 | # as well.
33 | # This requires OBS Studio to be running prior to starting the
34 | # recorder module. See also:
35 | # https://github.com/marcelherd/TekkenLearningPlatform/wiki/OBS-Studio-Setup
36 | enableVideoUpload: false
37 |
38 | # If enabled, the recorder will automatically delete any video recordings it has
39 | # saved on your local filesystem after they have been uploaded.
40 | # Enabling this setting does not do anything unless "enableVideoRecording" and
41 | # "enableVideoUpload" have both been enabled as well.
42 | # This requires OBS Studio to be running prior to starting the
43 | # recorder module. See also:
44 | # https://github.com/marcelherd/TekkenLearningPlatform/wiki/OBS-Studio-Setup
45 | enableCleanup: true
46 |
47 | # -----------------------------------------
48 | # User preferences
49 | # -----------------------------------------
50 |
51 | # The port configured in your OBS Studio Websocket settings.
52 | # See also:
53 | # https://github.com/marcelherd/TekkenLearningPlatform/wiki/OBS-Studio-Setup
54 | obsWebsocketPort: 4455
55 |
56 | # The password configured in your OBS Studio Websocket settings.
57 | # See also:
58 | # https://github.com/marcelherd/TekkenLearningPlatform/wiki/OBS-Studio-Setup
59 | obsWebsocketPassword: "change-me"
60 |
61 | # Where you instructed OBS to save your video recordings. This must be
62 | # configured if "enableVideoUpload" and "enableCleanup" are enabled.
63 | # It is recommended to configure "flv" as "Recording Format"
64 | # in OBS Studio if you plan on uploading them to YouTube automatically.
65 | recordingPath: "C:/temp/TekkenLearningPlatform"
66 |
67 | # How many matches to save per video recording.
68 | # If recordings are uploaded to YouTube, set as high as possible
69 | # as the daily maximum quota is used up per video uploaded irrelevant
70 | # of video length.
71 | # If set to 1, it will create a separate video for each match and
72 | # rename the video appropriately.
73 | matchesPerRecording: 1
74 |
75 | # How many milliseconds to wait for OBS Studio to finish
76 | # saving the video recording.
77 | # If YouTube is unable to process uploaded videos correctly, consider
78 | # increasing the delay as it might be getting uploaded before OBS
79 | # has finished writing the file properly.
80 | uploadDelay: 500
81 |
82 | # How many milliseconds to wait after a video recording has finished
83 | # uploading to YouTube, before deleting it from the local filesystem.
84 | # If YouTube is unable to process uploaded videos correctly, consider
85 | # increasing the delay as it might be getting deleted too soon.
86 | cleanupDelay: 5000
87 |
88 | # -----------------------------------------
89 | # Developer settings
90 | # -----------------------------------------
91 |
92 | # Set to "verbose" to enable debug logging.
93 | logLevel: "info"
94 |
95 | # How often the game state is updated (interval in ms).
96 | tickInterval: 1
97 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 |
TekkenLearningPlatform
3 |
Keeps track of your matches and provides statistics to help you improve as a player
4 |
Currently not functional! As of the newest update Ver. 5.00 the memory addresses are no longer correct and have to be updated. I am open to pull requests but I will not be fixing this myself anytime soon.
75 | 
76 | 
77 | 
78 | 
79 |
80 | ## Great, how do I use it?
81 |
82 | TL;DR: Download latest [tlp_win64.zip](https://github.com/marcelherd/TekkenLearningPlatform/releases), unpack it, start up Tekken 7, *then* doubleclick `start_all.bat`.
83 |
84 | Please refer to the [installation instructions](https://github.com/marcelherd/TekkenLearningPlatform/wiki/User-Guide#installation) for advanced use cases.
85 |
86 | ## Development
87 |
88 | The project is split into two modules:
89 |
90 | - `tlp-recorder` (Node.js/TypeScript): reads Tekken's process memory, keeps track of matches played and optionally communicates with OBS Studio to automatically create video recordings.
91 | - `tlp-webapp` (Next.js/React/TypeScript): Starts a web application allowing you to view your statistics.
92 |
93 | ### Prerequisites
94 |
95 | - Node.js v16.x.x (current LTS version)
96 | - Yarn (`npm install -g yarn`)
97 | - To record videos, you need OBS Studio, using either
98 | - OBS Studio 27.2.0 or above with the [obs-websocket](https://github.com/obsproject/obs-websocket/releases/tag/5.0.0-beta1) plugin installed
99 | - OBS Studio 28.0.0 or above which includes this plugin by default
100 |
101 | ### Setup
102 |
103 | Please refer to [Development environment setup](https://github.com/marcelherd/TekkenLearningPlatform/wiki/Development#development-environment-setup)
104 |
105 | ## License
106 |
107 | Source code is distributed under the [GNU GPLv3](https://choosealicense.com/licenses/gpl-3.0/) License. See LICENSE.txt for more information.
108 |
109 | ## Contributing
110 |
111 | Contributions are very welcome and much needed! As it is, the project is very barebones but functional.
112 |
113 | If you'd like to collaborate, you can find me (Sταrs) on the [Modding Zaibatsu](https://discord.gg/nCAeJE4z5U) Discord.
114 |
115 | ## Acknowledgements
116 |
117 | Huge thanks to [Kulagin](https://github.com/KulaGGin) for teaching me how to use CheatEngine and providing guidance.
118 |
--------------------------------------------------------------------------------
/tlp-recorder/src/index.ts:
--------------------------------------------------------------------------------
1 | import 'dotenv/config';
2 |
3 | import { OAuth2Client } from 'googleapis/node_modules/google-auth-library';
4 |
5 | import db from '@/database';
6 | import log from '@/helpers/log';
7 | import Broker from '@/recording/obs/broker';
8 | import { removeLatestVideo, scheduleRename } from '@/recording/util';
9 | import uploadLatestVideo, { uploadVideo } from '@/recording/youtube/uploader';
10 | import getAuthenticatedClient from '@/recording/youtube/auth';
11 | import GameState from '@/tekken/state';
12 | import {
13 | MatchEndEventData,
14 | MatchStartEventData,
15 | MatchUnresolvedEventData,
16 | TekkenEvent,
17 | TickEventData,
18 | } from '@/types/types';
19 | import config from '@/config';
20 |
21 | log.debug('Recorder loaded with configuration', { config });
22 |
23 | let state: GameState;
24 |
25 | let obs: Broker;
26 | let googleClient: OAuth2Client;
27 | let currentBatchSize: number = 0;
28 | let batchMatchIds: number[] = [];
29 | let recordingPaused: boolean = false;
30 | let previousTickData: TickEventData;
31 |
32 | const onMatchStart = async ({ match }: MatchStartEventData) => {
33 | // FIXME: Sometimes this gets called twice - once without data
34 | log.debug('onMatchStart', { match });
35 |
36 | if (config.ENABLE_VIDEO_RECORD) {
37 | if (recordingPaused) {
38 | log.debug('Resume recording');
39 | await obs.resumeRecording();
40 | recordingPaused = false;
41 | } else {
42 | log.debug('Start recording');
43 | await obs.startRecording();
44 | }
45 | }
46 | };
47 |
48 | const onMatchEnd = async ({ match, score }: MatchEndEventData) => {
49 | log.debug('onMatchEnd', { match, score });
50 |
51 | if (config.ENABLE_DB_SYNC) {
52 | const createdMatch = await db.match.create({
53 | data: {
54 | stage: match.stage,
55 | playerCharacter: match.player.character,
56 | playerRank: match.player.rank, // FIXME: not the correct memory address
57 | opponentCharacter: match.opponent.character,
58 | opponentRank: match.opponent.rank,
59 | opponent: match.opponent.name,
60 | playerRoundWins: score.playerWins,
61 | opponentRoundWins: score.opponentWins,
62 | roundWinsRequired: score.roundWinsRequired,
63 | recorded: config.ENABLE_VIDEO_RECORD,
64 | },
65 | });
66 | log.info(`Match was saved: ${match.player.character} vs ${match.opponent.character}`);
67 |
68 | // Is only used to associate YouTube URLs after upload with matches
69 | if (config.ENABLE_VIDEO_UPLOAD) {
70 | batchMatchIds.push(createdMatch.id);
71 | }
72 | }
73 |
74 | if (config.ENABLE_VIDEO_RECORD) {
75 | currentBatchSize += 1;
76 | log.info(`Recorded match ${currentBatchSize}/${config.OBS_BATCH_SIZE}`);
77 |
78 | // TODO: Add cleanup in case you want to exit early
79 | if (currentBatchSize >= config.OBS_BATCH_SIZE) {
80 | log.debug('Stop recording');
81 |
82 | await obs.stopRecording();
83 | await obs.clearAllText();
84 |
85 | let renamedFilePath: string | null = null;
86 |
87 | // If each match has its own recording, we can rename the recording file to be more descriptive
88 | if (config.OBS_BATCH_SIZE === 1) {
89 | const pChar = match.player.character;
90 | const opChar = match.opponent.character;
91 | const pRounds = score.playerWins;
92 | const opRounds = score.opponentWins;
93 | const { outcome } = score;
94 |
95 | // YYYY-MM-DD hh_mm_ss
96 | const date = new Date().toISOString().replace('T', ' ').replace(/:/g, '_').substring(0, 19);
97 | const newName = `${pChar} vs ${opChar} ${pRounds}-${opRounds} ${outcome} (${date})`;
98 | renamedFilePath = await scheduleRename(newName);
99 | }
100 |
101 | if (config.ENABLE_VIDEO_UPLOAD) {
102 | log.info('Uploading recording to YouTube. Please do not exit.');
103 |
104 | const { player, opponent } = match;
105 |
106 | // Grace period for OBS to finish saving the recording
107 | setTimeout(
108 | (matchIds: number[], path: string | null) => {
109 | const title = `Me (${player.character}) vs ${opponent.name} (${opponent.character})`;
110 | if (path) {
111 | uploadVideo(
112 | googleClient,
113 | path,
114 | {
115 | title,
116 | },
117 | matchIds, // TODO: this should not be handled here instead but whatever
118 | );
119 | } else {
120 | uploadLatestVideo(
121 | googleClient,
122 | {
123 | title,
124 | },
125 | matchIds, // TODO: this should not be handled here instead but whatever
126 | );
127 | }
128 | },
129 | config.OBS_UPLOAD_DELAY,
130 | batchMatchIds,
131 | renamedFilePath,
132 | );
133 | }
134 |
135 | currentBatchSize = 0;
136 | batchMatchIds = [];
137 | } else {
138 | const { outputActive } = await obs.getRecordingStatus();
139 |
140 | if (outputActive) {
141 | log.debug('Pause recording');
142 | await obs.pauseRecording();
143 | recordingPaused = true;
144 | }
145 | }
146 | }
147 | };
148 |
149 | const onMatchUnresolved = async (data: MatchUnresolvedEventData) => {
150 | log.debug('onMatchUnresolved', data);
151 |
152 | if (config.ENABLE_VIDEO_RECORD) {
153 | log.debug('Match ended early, stop recording');
154 | await obs.stopRecording();
155 | await obs.clearAllText();
156 |
157 | // Grace period for OBS to finish saving the recording
158 | setTimeout(() => {
159 | removeLatestVideo();
160 | }, config.OBS_CLEANUP_DELAY);
161 | }
162 | };
163 |
164 | const onGameTick = async (data: TickEventData) => {
165 | log.silly('onGameTick', data);
166 |
167 | if (config.ENABLE_NOTATION_SYNC) {
168 | if (previousTickData) {
169 | await obs.updateMetadataFromTick(data, previousTickData);
170 | }
171 |
172 | previousTickData = data;
173 | }
174 | };
175 |
176 | async function tick() {
177 | state.update();
178 | }
179 |
180 | async function main() {
181 | if (config.ENABLE_VIDEO_RECORD || config.ENABLE_NOTATION_SYNC) {
182 | log.info('Attempting to connect to OBS...');
183 | try {
184 | obs = await Broker.getInstance();
185 |
186 | if (config.ENABLE_NOTATION_SYNC) {
187 | await obs.clearAllText();
188 | }
189 | } catch (err) {
190 | log.error('Failed to connect to OBS. Please ensure OBS is running and set up.');
191 | log.info('See: https://github.com/marcelherd/TekkenLearningPlatform/wiki/OBS-Studio-Setup');
192 | process.exit(1);
193 | }
194 | }
195 |
196 | if (config.ENABLE_VIDEO_UPLOAD) {
197 | googleClient = await getAuthenticatedClient();
198 | }
199 |
200 | try {
201 | state = GameState.getInstance();
202 | } catch (err) {
203 | log.error('Please start up Tekken 7 before running this application.');
204 | process.exit(1);
205 | }
206 |
207 | state.on(TekkenEvent.MATCH_START, onMatchStart);
208 | state.on(TekkenEvent.MATCH_END, onMatchEnd);
209 | state.on(TekkenEvent.MATCH_UNRESOLVED, onMatchUnresolved);
210 | state.on(TekkenEvent.TICK, onGameTick);
211 |
212 | log.info('Application is ready to record matches.');
213 | if (config.ENABLE_VIDEO_UPLOAD) {
214 | log.info(`Recording ${config.OBS_BATCH_SIZE} matches per video`);
215 | }
216 |
217 | setInterval(tick, config.TICK_INTERVAL);
218 | }
219 |
220 | main();
221 |
--------------------------------------------------------------------------------
/tlp-recorder/src/tekken/parser.ts:
--------------------------------------------------------------------------------
1 | export function parseDirection(direction: number): string {
2 | switch (direction) {
3 | case 2:
4 | return 'd/b';
5 | case 4:
6 | return 'd';
7 | case 8:
8 | return 'd/f';
9 | case 16:
10 | return 'b';
11 | case 32:
12 | return 'n';
13 | case 64:
14 | return 'f';
15 | case 128:
16 | return 'u/b';
17 | case 256:
18 | return 'u';
19 | case 512:
20 | return 'u/f';
21 | default:
22 | return '';
23 | }
24 | }
25 |
26 | export function parseAttack(attack: number): string {
27 | switch (attack) {
28 | case 512:
29 | return '1';
30 | case 1024:
31 | return '2';
32 | case 2048:
33 | return '3';
34 | case 4096:
35 | return '4';
36 | case 1536:
37 | return '1+2';
38 | case 2560:
39 | return '1+3';
40 | case 4608:
41 | return '1+4';
42 | case 3072:
43 | return '2+3';
44 | case 6144:
45 | return '3+4';
46 | case 3584:
47 | return '1+2+3';
48 | case 6656:
49 | return '1+3+4';
50 | case 7168:
51 | return '2+3+4';
52 | case 7680:
53 | return '1+2+3+4';
54 | case 8192:
55 | return 'RAGE';
56 | default:
57 | return '';
58 | }
59 | }
60 |
61 | export function parseCharacter(characterId: number): string {
62 | switch (characterId) {
63 | case 0:
64 | return 'Paul';
65 | case 1:
66 | return 'Law';
67 | case 2:
68 | return 'King';
69 | case 3:
70 | return 'Yoshimitsu';
71 | case 4:
72 | return 'Hwoarang';
73 | case 5:
74 | return 'Xiaoyu';
75 | case 6:
76 | return 'Jin';
77 | case 7:
78 | return 'Bryan';
79 | case 8:
80 | return 'Heihachi';
81 | case 9:
82 | return 'Kazuya';
83 | case 10:
84 | return 'Steve';
85 | case 11:
86 | return 'Jack 7';
87 | case 12:
88 | return 'Asuka';
89 | case 13:
90 | return 'Devil Jin';
91 | case 14:
92 | return 'Feng';
93 | case 15:
94 | return 'Lili';
95 | case 16:
96 | return 'Dragunov';
97 | case 17:
98 | return 'Leo';
99 | case 18:
100 | return 'Lars';
101 | case 19:
102 | return 'Alisa';
103 | case 20:
104 | return 'Claudio';
105 | case 21:
106 | return 'Katarina';
107 | case 22:
108 | return 'Lucky Chloe';
109 | case 23:
110 | return 'Shaheen';
111 | case 24:
112 | return 'Josie';
113 | case 25:
114 | return 'Gigas';
115 | case 26:
116 | return 'Kazumi';
117 | case 27:
118 | return 'Devil Kazumi';
119 | case 28:
120 | return 'Nina';
121 | case 29:
122 | return 'Master Raven';
123 | case 30:
124 | return 'Lee';
125 | case 31:
126 | return 'Bob';
127 | case 32:
128 | return 'Akuma';
129 | case 33:
130 | return 'Kuma';
131 | case 34:
132 | return 'Panda';
133 | case 35:
134 | return 'Eddy';
135 | case 36:
136 | return 'Eliza';
137 | case 37:
138 | return 'Miguel';
139 | case 38:
140 | return 'Tekken Force';
141 | case 39:
142 | return 'Kid Kazuya';
143 | case 40:
144 | return 'Jack 4';
145 | case 41:
146 | return 'Young Heihachi';
147 | case 42:
148 | return 'Training Dummy';
149 | case 43:
150 | return 'Geese';
151 | case 44:
152 | return 'Noctis';
153 | case 45:
154 | return 'Anna';
155 | case 46:
156 | return 'Lei';
157 | case 47:
158 | return 'Marduk';
159 | case 48:
160 | return 'Armor King';
161 | case 49:
162 | return 'Julia';
163 | case 50:
164 | return 'Negan';
165 | case 51:
166 | return 'Zafina';
167 | case 52:
168 | return 'Ganryu';
169 | case 53:
170 | return 'Leroy';
171 | case 54:
172 | return 'Fahkumram';
173 | case 55:
174 | return 'Kunimitsu';
175 | case 56:
176 | return 'Lidia';
177 | case 71:
178 | return 'NOT_YET_LOADED';
179 | case 255:
180 | return 'NO_SELECTION';
181 | default:
182 | return 'Unknown';
183 | }
184 | }
185 |
186 | export function parseStage(stage: number): string {
187 | switch (stage) {
188 | case 0:
189 | return 'Mishima Dojo';
190 | case 1:
191 | return 'Forgotten Realm';
192 | case 2:
193 | case 53: // Jungle Outpost 2
194 | return 'Jungle Outpost';
195 | case 3:
196 | return 'Arctic Snowfall';
197 | case 4:
198 | case 54: // Twilight Conflict 2
199 | return 'Twilight Conflict';
200 | case 5:
201 | return "Dragon's Nest";
202 | case 6:
203 | return 'Souq';
204 | case 7:
205 | return "Devil's Pit";
206 | case 8:
207 | return 'Mishima Building';
208 | case 9:
209 | return 'Abandoned Temple';
210 | case 30:
211 | return 'Duomo Di Sirio';
212 | case 31:
213 | return 'Arena';
214 | case 32:
215 | case 33: // G Corp. Helipad (Night)
216 | return 'G Corp. Helipad';
217 | case 35:
218 | return 'Brimstone & Fire';
219 | case 36:
220 | return 'Precipice of Fate';
221 | case 37:
222 | return 'Violet Systems';
223 | case 39:
224 | return 'Kinder Gym';
225 | case 40:
226 | case 55: // Infinite Azure 2
227 | return 'Infinite Azure';
228 | case 41:
229 | return 'Geometric Plane';
230 | case 51:
231 | return 'Howard Estate';
232 | case 52:
233 | return 'Hammerhead';
234 | case 56:
235 | return 'Last Day on Earth';
236 | case 57:
237 | return 'Cave of Enlightenment';
238 | case 58:
239 | return 'Vermilion Gates';
240 | case 59:
241 | return 'Island Paradise';
242 | default:
243 | return 'Unknown';
244 | }
245 | }
246 |
247 | export function parseRank(rank: number): string {
248 | switch (rank) {
249 | case 0:
250 | return 'Beginner';
251 | case 1:
252 | return '9th Kyu';
253 | case 2:
254 | return '8th Kyu';
255 | case 3:
256 | return '7th Kyu';
257 | case 4:
258 | return '6th Kyu';
259 | case 5:
260 | return '5th Kyu';
261 | case 6:
262 | return '4th Kyu';
263 | case 7:
264 | return '3rd Kyu';
265 | case 8:
266 | return '2nd Kyu';
267 | case 9:
268 | return '1st Kyu';
269 | case 10:
270 | return '1st Dan';
271 | case 11:
272 | return '2nd Dan';
273 | case 12:
274 | return '3rd Dan';
275 | case 13:
276 | return 'Initiate';
277 | case 14:
278 | return 'Mentor';
279 | case 15:
280 | return 'Expert';
281 | case 16:
282 | return 'Grandmaster';
283 | case 17:
284 | return 'Brawler';
285 | case 18:
286 | return 'Marauder';
287 | case 19:
288 | return 'Fighter';
289 | case 20:
290 | return 'Vanguard';
291 | case 21:
292 | return 'Warrior';
293 | case 22:
294 | return 'Vindicator';
295 | case 23:
296 | return 'Juggernaut';
297 | case 24:
298 | return 'Usurper';
299 | case 25:
300 | return 'Vanquisher';
301 | case 26:
302 | return 'Destroyer';
303 | case 27:
304 | return 'Savior';
305 | case 28:
306 | return 'Overlord';
307 | case 29:
308 | return 'Genbu';
309 | case 30:
310 | return 'Byakko';
311 | case 31:
312 | return 'Seiryu';
313 | case 32:
314 | return 'Suzaku';
315 | case 33:
316 | return 'Mighty Ruler';
317 | case 34:
318 | return 'Revered Ruler';
319 | case 35:
320 | return 'Divine Ruler';
321 | case 36:
322 | return 'Eternal Ruler';
323 | case 37:
324 | return 'Fujin';
325 | case 38:
326 | return 'Raijin';
327 | case 39:
328 | return 'Yaksa';
329 | case 40:
330 | return 'Ryujin';
331 | case 41:
332 | return 'Emperor';
333 | case 42:
334 | return 'Tekken King';
335 | case 43:
336 | return 'Tekken God';
337 | case 44:
338 | return 'True Tekken God';
339 | case 45:
340 | return 'Tekken God Prime';
341 | case 46:
342 | return 'Tekken God Omega';
343 | default:
344 | return 'Unknown';
345 | }
346 | }
347 |
--------------------------------------------------------------------------------
/tlp-recorder/src/tekken/state.ts:
--------------------------------------------------------------------------------
1 | import memoryjs, { Process } from 'memoryjs';
2 | import { TypedEmitter } from 'tiny-typed-emitter';
3 |
4 | import log from '@/helpers/log';
5 | import dereferencePointerChain from '@/helpers/memory';
6 | import * as offsets from '@/tekken/offsets';
7 | import {
8 | parseCharacter,
9 | parseAttack,
10 | parseDirection,
11 | parseRank,
12 | parseStage,
13 | } from '@/tekken/parser';
14 | import {
15 | InputData,
16 | MatchData,
17 | MatchResult,
18 | MatchScore,
19 | PlayerOffsets,
20 | TekkenEvent,
21 | TekkenEvents,
22 | } from '@/types/types';
23 |
24 | export default class GameState extends TypedEmitter