wip

packages/backend/src/core/ReversiService.ts

@@ -5,7 +5,7 @@
 
 import { Inject, Injectable } from '@nestjs/common';
 import * as Redis from 'ioredis';
-import { In } from 'typeorm';
+import * as CRC32 from 'crc-32';
 import { ModuleRef } from '@nestjs/core';
 import * as Reversi from 'misskey-reversi';
 import type {
@@ -36,15 +36,6 @@ export class ReversiService implements OnApplicationShutdown, OnModuleInit {
 	constructor(
 		private moduleRef: ModuleRef,
 
-		@Inject(DI.redis)
-		private redisClient: Redis.Redis,
-
-		@Inject(DI.redisForTimelines)
-		private redisForTimelines: Redis.Redis,
-
-		@Inject(DI.redisForSub)
-		private redisForSub: Redis.Redis,
-
 		@Inject(DI.usersRepository)
 		private usersRepository: UsersRepository,
 
@@ -54,7 +45,6 @@ export class ReversiService implements OnApplicationShutdown, OnModuleInit {
 		@Inject(DI.reversiMatchingsRepository)
 		private reversiMatchingsRepository: ReversiMatchingsRepository,
 
-		private metaService: MetaService,
 		private cacheService: CacheService,
 		private userEntityService: UserEntityService,
 		private globalEventService: GlobalEventService,
@@ -96,7 +86,8 @@ export class ReversiService implements OnApplicationShutdown, OnModuleInit {
 				isLlotheo: false,
 			}).then(x => this.reversiGamesRepository.findOneByOrFail(x.identifiers[0]));
 
-			publishReversiStream(exist.parentId, 'matched', await this.reversiGameEntityService.pack(game, { id: exist.parentId }));
+			const packed = await this.reversiGameEntityService.pack(game, { id: exist.parentId });
+			this.globalEventService.publishReversiStream(exist.parentId, 'matched', { game: packed });
 
 			const other = await this.reversiMatchingsRepository.countBy({
 				childId: me.id,
@@ -121,7 +112,7 @@ export class ReversiService implements OnApplicationShutdown, OnModuleInit {
 			}).then(x => this.reversiMatchingsRepository.findOneByOrFail(x.identifiers[0]));
 
 			const packed = await this.reversiMatchingsEntityService.pack(matching, child);
-			publishReversiStream(child.id, 'invited', packed);
+			this.globalEventService.publishReversiStream(child.id, 'invited', { game: packed });
 			publishMainStream(child.id, 'reversiInvited', packed);
 
 			return null;
@@ -135,6 +126,169 @@ export class ReversiService implements OnApplicationShutdown, OnModuleInit {
 		});
 	}
 
+	@bindThis
+	public async matchAccept(game: MiReversiGame, user: MiUser, isAccepted: boolean) {
+		if (game.isStarted) return;
+
+		let bothAccepted = false;
+
+		if (game.user1Id === user.id) {
+			await this.reversiGamesRepository.update(game.id, {
+				user1Accepted: isAccepted,
+			});
+
+			this.globalEventService.publishReversiGameStream(game.id, 'changeAccepts', {
+				user1: isAccepted,
+				user2: game.user2Accepted,
+			});
+
+			if (isAccepted && game.user2Accepted) bothAccepted = true;
+		} else if (game.user2Id === user.id) {
+			await this.reversiGamesRepository.update(game.id, {
+				user2Accepted: isAccepted,
+			});
+
+			this.globalEventService.publishReversiGameStream(game.id, 'changeAccepts', {
+				user1: game.user1Accepted,
+				user2: isAccepted,
+			});
+
+			if (isAccepted && game.user1Accepted) bothAccepted = true;
+		} else {
+			return;
+		}
+
+		if (bothAccepted) {
+			// 3秒後、まだacceptされていたらゲーム開始
+			setTimeout(async () => {
+				const freshGame = await this.reversiGamesRepository.findOneBy({ id: game.id });
+				if (freshGame == null || freshGame.isStarted || freshGame.isEnded) return;
+				if (!freshGame.user1Accepted || !freshGame.user2Accepted) return;
+
+				let bw: number;
+				if (freshGame.bw === 'random') {
+					bw = Math.random() > 0.5 ? 1 : 2;
+				} else {
+					bw = parseInt(freshGame.bw, 10);
+				}
+
+				function getRandomMap() {
+					const mapCount = Object.entries(maps).length;
+					const rnd = Math.floor(Math.random() * mapCount);
+					return Object.values(maps)[rnd].data;
+				}
+
+				const map = freshGame.map != null ? freshGame.map : getRandomMap();
+
+				await this.reversiGamesRepository.update(game.id, {
+					startedAt: new Date(),
+					isStarted: true,
+					black: bw,
+					map: map,
+				});
+
+				//#region 盤面に最初から石がないなどして始まった瞬間に勝敗が決定する場合があるのでその処理
+				const o = new Reversi.Game(map, {
+					isLlotheo: freshGame.isLlotheo,
+					canPutEverywhere: freshGame.canPutEverywhere,
+					loopedBoard: freshGame.loopedBoard,
+				});
+
+				if (o.isEnded) {
+					let winner;
+					if (o.winner === true) {
+						winner = freshGame.black == 1 ? freshGame.user1Id : freshGame.user2Id;
+					} else if (o.winner === false) {
+						winner = freshGame.black == 1 ? freshGame.user2Id : freshGame.user1Id;
+					} else {
+						winner = null;
+					}
+
+					await this.reversiGamesRepository.update(game.id, {
+						isEnded: true,
+						winnerId: winner,
+					});
+
+					this.globalEventService.publishReversiGameStream(game.id, 'ended', {
+						winnerId: winner,
+						game: await this.reversiGameEntityService.pack(game.id, user),
+					});
+				}
+				//#endregion
+
+				this.globalEventService.publishReversiGameStream(game.id, 'started',
+					await this.reversiGameEntityService.pack(game.id, user));
+			}, 3000);
+		}
+	}
+
+	@bindThis
+	public async putStoneToGame(game: MiReversiGame, user: MiUser, pos: number) {
+		if (!game.isStarted) return;
+		if (game.isEnded) return;
+		if ((game.user1Id !== user.id) && (game.user2Id !== user.id)) return;
+
+		const myColor =
+			((game.user1Id === user.id) && game.black === 1) || ((game.user2Id === user.id) && game.black === 2)
+				? true
+				: false;
+
+		const o = new Reversi.Game(game.map, {
+			isLlotheo: game.isLlotheo,
+			canPutEverywhere: game.canPutEverywhere,
+			loopedBoard: game.loopedBoard,
+		});
+
+		// 盤面の状態を再生
+		for (const log of game.logs) {
+			o.put(log.color, log.pos);
+		}
+
+		if (o.turn !== myColor) return;
+
+		if (!o.canPut(myColor, pos)) return;
+		o.put(myColor, pos);
+
+		let winner;
+		if (o.isEnded) {
+			if (o.winner === true) {
+				winner = game.black === 1 ? game.user1Id : game.user2Id;
+			} else if (o.winner === false) {
+				winner = game.black === 1 ? game.user2Id : game.user1Id;
+			} else {
+				winner = null;
+			}
+		}
+
+		const log = {
+			at: new Date(),
+			color: myColor,
+			pos,
+		};
+
+		const crc32 = CRC32.str(game.logs.map(x => x.pos.toString()).join('') + pos.toString()).toString();
+
+		game.logs.push(log);
+
+		await this.reversiGamesRepository.update(game.id, {
+			crc32,
+			isEnded: o.isEnded,
+			winnerId: winner,
+			logs: game.logs,
+		});
+
+		this.globalEventService.publishReversiGameStream(game.id, 'set', Object.assign(log, {
+			next: o.turn,
+		}));
+
+		if (o.isEnded) {
+			this.globalEventService.publishReversiGameStream(game.id, 'ended', {
+				winnerId: winner,
+				game: await this.reversiGameEntityService.pack(game.id, user),
+			});
+		}
+	}
+
 	@bindThis
 	public async get(id: MiReversiGame['id']) {
 		return this.reversiGamesRepository.findOneBy({ id });