[공통] Release -> main

BE/src/InitDB/InitDB.controller.ts

@@ -1,12 +1,13 @@
-import { Controller, Post } from '@nestjs/common';
 import { InitDBService } from './InitDB.Service';
+import { Controller, HttpException, Post } from '@nestjs/common';
 
 @Controller('/api/initDB')
 export class InitDBController {
   constructor(private readonly initDBService: InitDBService) {}
 
   @Post()
   create() {
-    return this.initDBService.create();
+    throw new HttpException('test용 api 입니다.', 501);
+    // return this.initDBService.create();
   }
 }

BE/src/common/constants/game-mode.ts → BE/src/common/constants/game.ts

@@ -2,3 +2,8 @@ export enum GameMode {
   RANKING = 'RANKING',
   SURVIVAL = 'SURVIVAL',
 }
+
+export enum SurvivalStatus {
+  ALIVE = '1',
+  DEAD = '0',
+}

BE/src/game/dto/create-game.dto.ts

@@ -1,7 +1,7 @@
 import { IsIn, IsInt, IsString, Max, MaxLength, Min, MinLength } from 'class-validator';
 import { Transform, Type } from 'class-transformer';
 import { WsException } from '@nestjs/websockets';
-import { GameMode } from '../../common/constants/game-mode';
+import { GameMode } from '../../common/constants/game';
 
 export class CreateGameDto {
   @IsString()

BE/src/game/dto/update-room-option.dto.ts

@@ -1,7 +1,7 @@
 import { IsIn, IsInt, IsString, Length, Max, MaxLength, Min, MinLength } from 'class-validator';
 import { Transform, Type } from 'class-transformer';
 import { WsException } from '@nestjs/websockets';
-import { GameMode } from '../../common/constants/game-mode';
+import { GameMode } from '../../common/constants/game';
 
 export class UpdateRoomOptionDto {
   @IsString()

BE/src/game/game.gateway.ts

@@ -35,7 +35,8 @@ import { ExceptionMessage } from '../common/constants/exception-message';
     origin: [
       'https://news.taskify.shop',
       'https://quizground.duckdns.org',
-      'https://admin.socket.io'
+      'https://admin.socket.io',
+      'https://quizground.site'
     ],
     credentials: true
   },

BE/src/game/redis/game-redis-memory.service.ts

@@ -1,13 +1,14 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { InjectRedis } from '@nestjs-modules/ioredis';
 import Redis from 'ioredis';
-import { Cron, CronExpression } from '@nestjs/schedule';
 import { REDIS_KEY } from '../../common/constants/redis-key.constant';
+import { Cron, CronExpression } from '@nestjs/schedule';
 
 @Injectable()
 export class GameRedisMemoryService {
   private readonly logger = new Logger(GameRedisMemoryService.name);
   private readonly BATCH_SIZE = 100; // 한 번에 처리할 배치 크기
+  private readonly INACTIVE_THRESHOLD = 30 * 60 * 1000; // 30분 30 * 60 * 1000;
 
   private readonly TTL = {
     ROOM: 3 * 60 * 60,
@@ -18,11 +19,61 @@ export class GameRedisMemoryService {
 
   constructor(@InjectRedis() private readonly redis: Redis) {}
 
+  /**
+   * 비활성 방 체크 (주기적으로 실행)
+   */
+  /**
+   * 비활성 방을 체크하고 정리하는 크론 작업
+   * SCAN을 사용하여 대규모 방 목록도 안전하게 처리
+   */
+  @Cron(CronExpression.EVERY_10_MINUTES)
+  async checkInactiveRooms(): Promise<void> {
+    this.logger.verbose('비활성 방 체크 시작');
+    try {
+      const now = Date.now();
+      let cursor = '0';
+      let processedCount = 0;
+
+      do {
+        // SCAN을 사용하여 배치 단위로 처리
+        const [nextCursor, rooms] = await this.redis.sscan(
+          REDIS_KEY.ACTIVE_ROOMS,
+          cursor,
+          'COUNT',
+          this.BATCH_SIZE
+        );
+        cursor = nextCursor;
+
+        // 병렬로 방 상태 체크 및 처리
+        await Promise.all(
+          rooms.map(async (roomId) => {
+            try {
+              const lastActivity = await this.redis.hget(REDIS_KEY.ROOM(roomId), 'lastActivityAt');
+
+              if (lastActivity && now - parseInt(lastActivity) > this.INACTIVE_THRESHOLD) {
+                await this.redis.publish('room:cleanup', roomId);
+                this.logger.verbose(`비활성으로 인해 방 ${roomId} 정리 시작`);
+                processedCount++;
+              }
+            } catch (error) {
+              this.logger.error(`방 ${roomId} 처리 중 오류 발생: ${error.message}`);
+            }
+          })
+        );
+      } while (cursor !== '0');
+
+      this.logger.verbose(`비활성 방 체크 완료: ${processedCount}개 방 정리됨`);
+    } catch (error) {
+      this.logger.error(`비활성 방 체크 중 오류 발생: ${error.message}`);
+    }
+  }
+
   /**
    * TTL 관리를 위한 스케줄러
    * 배치 처리로 블로킹 최소화
    */
-  @Cron(CronExpression.EVERY_MINUTE)
+
+  // @Cron(CronExpression.EVERY_MINUTE)
   async manageTTL(): Promise<void> {
     try {
       // SCAN으로 활성 방 목록을 배치로 처리

BE/src/game/redis/subscribers/player.subscriber.ts

@@ -5,6 +5,7 @@ import Redis from 'ioredis';
 import { Namespace } from 'socket.io';
 import SocketEvents from '../../../common/constants/socket-events';
 import { REDIS_KEY } from '../../../common/constants/redis-key.constant';
+import { SurvivalStatus } from '../../../common/constants/game';
 
 @Injectable()
 export class PlayerSubscriber extends RedisSubscriber {
@@ -84,27 +85,34 @@ export class PlayerSubscriber extends RedisSubscriber {
 
     const isAlivePlayer = await this.redis.hget(REDIS_KEY.PLAYER(playerId), 'isAlive');
 
-    if (isAlivePlayer === '1') {
+    if (isAlivePlayer === SurvivalStatus.ALIVE) {
       server.to(gameId).emit(SocketEvents.UPDATE_POSITION, updateData);
-    } else if (isAlivePlayer === '0') {
+    } else if (isAlivePlayer === SurvivalStatus.DEAD) {
       const players = await this.redis.smembers(REDIS_KEY.ROOM_PLAYERS(gameId));
-      const deadPlayers = await Promise.all(
-        players.map(async (id) => {
-          const isAlive = await this.redis.hget(REDIS_KEY.PLAYER(id), 'isAlive');
-          return { id, isAlive };
-        })
-      );
-
-      deadPlayers
+      const pipeline = this.redis.pipeline();
+
+      players.forEach((id) => {
+        pipeline.hmget(REDIS_KEY.PLAYER(id), 'isAlive', 'socketId');
+      });
+
+      type Result = [Error | null, [string, string] | null];
+      const results = await pipeline.exec();
+
+      (results as Result[])
+        .map(([err, data], index) => ({
+          id: players[index],
+          isAlive: err ? null : data?.[0],
+          socketId: err ? null : data?.[1]
+        }))
         .filter((player) => player.isAlive === '0')
         .forEach((player) => {
-          server.to(player.id).emit(SocketEvents.UPDATE_POSITION, updateData);
+          const socket = server.sockets.get(player.socketId);
+          if (!socket) {
+            return;
+          }
+          socket.emit(SocketEvents.UPDATE_POSITION, updateData);
         });
     }
-
-    this.logger.verbose(
-      `[updatePosition] RoomId: ${gameId} | playerId: ${playerId} | isAlive: ${isAlivePlayer === '1' ? '생존자' : '관전자'} | position: [${positionX}, ${positionY}]`
-    );
   }
 
   private async handlePlayerDisconnect(playerId: string, playerData: any, server: Namespace) {

BE/src/game/redis/subscribers/room.cleanup.subscriber.ts

@@ -37,6 +37,15 @@ export class RoomCleanupSubscriber extends RedisSubscriber {
     try {
       const pipeline = this.redis.pipeline();
 
+      // 1. 방에 속한 플레이어 목록 가져오기, 200명미만 -> smembers 사용!
+      const players = await this.redis.smembers(REDIS_KEY.ROOM_PLAYERS(roomId));
+
+      // 2. 플레이어 데이터 삭제
+      for (const playerId of players) {
+        pipeline.del(REDIS_KEY.PLAYER(playerId)); // 플레이어 기본 데이터
+        pipeline.del(`${REDIS_KEY.PLAYER(playerId)}:Changes`); // 플레이어 Changes 데이터
+      }
+
       // 1. 방 관련 기본 데이터 삭제
       pipeline.del(REDIS_KEY.ROOM(roomId));
       pipeline.del(REDIS_KEY.ROOM_PLAYERS(roomId));

BE/src/game/redis/subscribers/timer.subscriber.ts

@@ -5,7 +5,7 @@ import Redis from 'ioredis';
 import { Namespace } from 'socket.io';
 import { REDIS_KEY } from '../../../common/constants/redis-key.constant';
 import SocketEvents from '../../../common/constants/socket-events';
-import { GameMode } from '../../../common/constants/game-mode';
+import { GameMode, SurvivalStatus } from '../../../common/constants/game';
 
 @Injectable()
 export class TimerSubscriber extends RedisSubscriber {
@@ -28,6 +28,7 @@ export class TimerSubscriber extends RedisSubscriber {
       const currentQuiz = await this.redis.get(REDIS_KEY.ROOM_CURRENT_QUIZ(gameId));
       const [quizNum, state] = currentQuiz.split(':');
 
+      // REFACTOR: start, end 상수화
       if (state === 'start') {
         await this.handleQuizScoring(gameId, parseInt(quizNum), server);
       } else {
@@ -65,7 +66,7 @@ export class TimerSubscriber extends RedisSubscriber {
       const selectAnswer = this.calculateAnswer(
         player.positionX,
         player.positionY,
-        quizList.length
+        parseInt(quiz.choiceCount)
       );
       // this.logger.verbose(selectAnswer);
 
@@ -113,12 +114,18 @@ export class TimerSubscriber extends RedisSubscriber {
 
     // 생존 모드에서 모두 탈락하진 않았는지 체크
     const players = await this.redis.smembers(REDIS_KEY.ROOM_PLAYERS(gameId));
-    const alivePlayers = players.filter(async (id) => {
-      const isAlive = await this.redis.hget(REDIS_KEY.PLAYER(id), 'isAlive');
-      return isAlive === '1';
-    });
+    const aliveCount = (
+      await Promise.all(players.map((id) => this.redis.hget(REDIS_KEY.PLAYER(id), 'isAlive')))
+    ).filter((isAlive) => isAlive === SurvivalStatus.ALIVE).length;
+
+    // 게임 끝을 알림
+    if (this.hasNoMoreQuiz(quizList, newQuizNum) || this.checkSurvivalEnd(players.length, aliveCount)) {
+      // 모든 플레이어를 생존자로 변경
+      const players = await this.redis.smembers(REDIS_KEY.ROOM_PLAYERS(gameId));
+      players.forEach((id) => {
+        this.redis.hset(REDIS_KEY.PLAYER(id), { isAlive: SurvivalStatus.ALIVE });
+      });
 
-    if (quizList.length <= newQuizNum || alivePlayers.length === 0) {
       const leaderboard = await this.redis.zrange(
         REDIS_KEY.ROOM_LEADERBOARD(gameId),
         0,
@@ -128,13 +135,13 @@ export class TimerSubscriber extends RedisSubscriber {
 
       this.redis.set(`${REDIS_KEY.ROOM(gameId)}:Changes`, 'End');
       this.redis.hset(REDIS_KEY.ROOM(gameId), {
-        host: leaderboard[0],
+        host: leaderboard.at(-2),
         status: 'waiting',
         isWaiting: '1'
       });
 
       server.to(gameId).emit(SocketEvents.END_GAME, {
-        hostId: leaderboard[0]
+        hostId: leaderboard.at(-2)
       });
       this.logger.verbose(`[endGame]: ${gameId}`);
       return;
@@ -167,8 +174,8 @@ export class TimerSubscriber extends RedisSubscriber {
   }
 
   private calculateAnswer(positionX: string, positionY: string, quizLen: number): number {
-    const x = parseFloat(positionX);
-    const y = parseFloat(positionY);
+    const x = parseFloat(positionY);
+    const y = parseFloat(positionX);
 
     // 행의 개수 계산 (2열 고정이므로 총 개수의 절반을 올림)
     const rows = Math.ceil(quizLen / 2);
@@ -177,21 +184,20 @@ export class TimerSubscriber extends RedisSubscriber {
     const rowIndex = Math.floor(y * rows);
 
     // X 좌표로 왼쪽/오른쪽 결정
-    const colIndex = x < 0.5 ? 0 : 1;
+    const colIndex = Math.round(x);
 
     // 최종 선택지 번호 계산
     const answer = rowIndex * 2 + colIndex + 1;
 
     // 실제 선택지 범위를 벗어나지 않도록 보정
     return Math.min(answer, quizLen);
-    // return (
-    //   Math.round(
-    //     parseFloat(positionX) + Math.floor(parseFloat(positionY) * Math.ceil(quizLen / 2))
-    //   ) * 2
-    // );
-    // if (parseFloat(positionY) < 0.5) {
-    //   return parseFloat(positionX) < 0.5 ? 1 : 2;
-    // }
-    // return parseFloat(positionX) < 0.5 ? 3 : 4;
+  }
+
+  private hasNoMoreQuiz(quizList, newQuizNum: number) {
+    return quizList.length <= newQuizNum;
+  }
+
+  private checkSurvivalEnd(playerCount: number, aliveCount: number) {
+    return playerCount > 1 && aliveCount <= 1;
   }
 }

BE/src/game/service/game.chat.service.ts

@@ -7,6 +7,7 @@ import { REDIS_KEY } from '../../common/constants/redis-key.constant';
 import SocketEvents from '../../common/constants/socket-events';
 import { Namespace } from 'socket.io';
 import { TraceClass } from '../../common/interceptor/SocketEventLoggerInterceptor';
+import { SurvivalStatus } from '../../common/constants/game';
 
 @TraceClass()
 @Injectable()
@@ -56,7 +57,8 @@ export class GameChatService {
       const playerKey = REDIS_KEY.PLAYER(chatMessage.playerId);
       const isAlivePlayer = await this.redis.hget(playerKey, 'isAlive');
 
-      if (isAlivePlayer === '1') {
+      // 생존한 사람이라면 전체 브로드캐스팅
+      if (isAlivePlayer === SurvivalStatus.ALIVE) {
         server.to(gameId).emit(SocketEvents.CHAT_MESSAGE, chatMessage);
         return;
       }
@@ -65,11 +67,16 @@ export class GameChatService {
       const players = await this.redis.smembers(REDIS_KEY.ROOM_PLAYERS(gameId));
       await Promise.all(
         players.map(async (playerId) => {
-          const playerKey = REDIS_KEY.PLAYER(playerId);
-          const isAlive = await this.redis.hget(playerKey, 'isAlive');
+          const socketId = await this.redis.hget(REDIS_KEY.PLAYER(playerId), 'socketId');
+          const socket = server.sockets.get(socketId);
 
-          if (isAlive === '0') {
-            server.to(playerId).emit(SocketEvents.CHAT_MESSAGE, chatMessage);
+          if (!socket) {
+            return;
+          }
+
+          const isAlive = await this.redis.hget(REDIS_KEY.PLAYER(playerId), 'isAlive');
+          if (isAlive === SurvivalStatus.DEAD) {
+            socket.emit(SocketEvents.CHAT_MESSAGE, chatMessage);
           }
         })
       );