Merge pull request #268 from NewCodes7/feature-be-#264

[BE] feat#264 서바이벌 모드 구현 및 테스트 코드 개선

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

@@ -0,0 +1,4 @@
+export enum GameMode {
+  RANKING = 'RANKING',
+  SURVIVAL = 'SURVIVAL',
+}

BE/src/common/filters/ws-exception.filter.ts

@@ -11,7 +11,7 @@ export class WsExceptionFilter extends BaseWsExceptionFilter {
 
     // ValidationPipe에서 발생한 에러 처리
     if (exception instanceof GameWsException) {
-      this.logger.error(`Validation Error: ${JSON.stringify(exception.message)}`);
+      this.logger.error(`Validation Error: ${JSON.stringify(exception.message)}`, exception.stack);
 
       client.emit('exception', {
         eventName: exception.eventName,

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

@@ -1,6 +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';
 
 export class CreateGameDto {
   @IsString()
@@ -9,7 +10,7 @@ export class CreateGameDto {
   title: string;
 
   @IsString()
-  @IsIn(['RANKING', 'SURVIVAL'])
+  @IsIn([GameMode.RANKING, GameMode.SURVIVAL])
   gameMode: string;
 
   @Type(() => Number)

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

@@ -1,14 +1,15 @@
 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';
 
 export class UpdateRoomOptionDto {
   @IsString()
   @Length(6, 6, { message: 'PIN번호는 6자리이어야 합니다.' })
   gameId: string;
 
   @IsString()
-  @IsIn(['RANKING', 'SURVIVAL'])
+  @IsIn([GameMode.RANKING, GameMode.SURVIVAL])
   gameMode: string;
 
   @IsString()

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

@@ -70,11 +70,33 @@ export class PlayerSubscriber extends RedisSubscriber {
   }
 
   private async handlePlayerPosition(playerId: string, playerData: any, server: Server) {
-    server.to(playerData.gameId).emit(SocketEvents.UPDATE_POSITION, {
-      playerId,
-      playerPosition: [parseFloat(playerData.positionX), parseFloat(playerData.positionY)]
-    });
-    this.logger.verbose(`Player position updated: ${playerId}`);
+    const { gameId, positionX, positionY } = playerData;
+    const playerPosition = [parseFloat(positionX), parseFloat(positionY)];
+    const updateData = { playerId, playerPosition };
+
+    const isAlivePlayer = await this.redis.hget(REDIS_KEY.PLAYER(playerId), 'isAlive');
+
+    if (isAlivePlayer === '1') {
+      server.to(gameId).emit(SocketEvents.UPDATE_POSITION, updateData);
+    } else if (isAlivePlayer === '0') {
+      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
+        .filter(player => player.isAlive === '0')
+        .forEach(player => {
+          server.to(player.id).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: Server) {

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

@@ -48,11 +48,11 @@ export class ScoringSubscriber extends RedisSubscriber {
     });
 
     await this.updateQuizState(gameId, quiz.quizNum);
-    this.logger.verbose(`endQuizTime: ${gameId} - ${quiz.quizNum}`);
+    this.logger.verbose(`[endQuizTime] RoomId: ${gameId} | quizNum: ${quiz.quizNum}`);
   }
 
   private async updateQuizState(gameId: string, quizNum: number) {
-    await this.redis.set(REDIS_KEY.ROOM_CURRENT_QUIZ(gameId), `${quizNum}:end`);
+    await this.redis.set(REDIS_KEY.ROOM_CURRENT_QUIZ(gameId), `${quizNum}:end`); // timer.subscriber.ts 구독 핸들러 실행
     await this.redis.set(REDIS_KEY.ROOM_TIMER(gameId), 'timer', 'EX', '10', 'NX');
   }
 }

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

@@ -5,6 +5,7 @@ import Redis from 'ioredis';
 import { Server } 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';
 
 @Injectable()
 export class TimerSubscriber extends RedisSubscriber {
@@ -46,40 +47,68 @@ export class TimerSubscriber extends RedisSubscriber {
 
     const sockets = await server.in(gameId).fetchSockets();
     const clients = sockets.map((socket) => socket.id);
+
     const correctPlayers = [];
+    const inCorrectPlayers = [];
 
     // 플레이어 답안 처리
     for (const clientId of clients) {
       const player = await this.redis.hgetall(REDIS_KEY.PLAYER(clientId));
+
+      if (player.isAlive === '0') {
+        continue;
+      }
+
       const selectAnswer = this.calculateAnswer(player.positionX, player.positionY);
 
       await this.redis.set(`${REDIS_KEY.PLAYER(clientId)}:Changes`, 'AnswerCorrect');
       if (selectAnswer.toString() === quiz.answer) {
         correctPlayers.push(clientId);
-        await this.redis.hmset(REDIS_KEY.PLAYER(clientId), { isAnswerCorrect: '1' });
+        await this.redis.hset(REDIS_KEY.PLAYER(clientId), { isAnswerCorrect: '1' });
       } else {
-        await this.redis.hmset(REDIS_KEY.PLAYER(clientId), { isAnswerCorrect: '0' });
+        inCorrectPlayers.push(clientId);
+        await this.redis.hset(REDIS_KEY.PLAYER(clientId), { isAnswerCorrect: '0' });
       }
     }
 
     // 점수 업데이트
-    for (const clientId of correctPlayers) {
-      await this.redis.zincrby(
-        REDIS_KEY.ROOM_LEADERBOARD(gameId),
-        1000 / correctPlayers.length,
-        clientId
-      );
+    const gameMode = await this.redis.hget(REDIS_KEY.ROOM(gameId), 'gameMode');
+    const leaderboardKey = REDIS_KEY.ROOM_LEADERBOARD(gameId);
+
+    if (gameMode === GameMode.RANKING) {
+      const score = 1000 / correctPlayers.length;
+      correctPlayers.forEach(clientId => {
+        this.redis.zincrby(leaderboardKey, score, clientId);
+      });
+    } else if (gameMode === GameMode.SURVIVAL) {
+      correctPlayers.forEach(clientId => {
+        this.redis.zadd(leaderboardKey, 1, clientId);
+      });
+      inCorrectPlayers.forEach(clientId => {
+        this.redis.zadd(leaderboardKey, 0, clientId);
+        this.redis.hset(REDIS_KEY.PLAYER(clientId), { isAlive: '0' });
+      });
     }
 
     await this.redis.publish(`scoring:${gameId}`, clients.length.toString());
-    this.logger.verbose(`채점: ${gameId} - ${clients.length}`);
+
+    this.logger.verbose(
+      `[Quiz] Room: ${gameId} | gameMode: ${gameMode === GameMode.SURVIVAL ? '서바이벌' : '랭킹'} | totalPlayers: ${clients.length} | ${gameMode === GameMode.SURVIVAL ? `생존자: ${correctPlayers.length}명` : `정답자: ${correctPlayers.length}명`}`
+    );
   }
 
   private async handleNextQuiz(gameId: string, currentQuizNum: number, server: Server) {
     const newQuizNum = currentQuizNum + 1;
     const quizList = await this.redis.smembers(REDIS_KEY.ROOM_QUIZ_SET(gameId));
 
-    if (quizList.length <= newQuizNum) {
+    // 생존 모드에서 모두 탈락하진 않았는지 체크
+    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';
+    });
+
+    if (quizList.length <= newQuizNum || alivePlayers.length === 0) {
       const leaderboard = await this.redis.zrange(
         REDIS_KEY.ROOM_LEADERBOARD(gameId),
         0,
@@ -90,7 +119,7 @@ export class TimerSubscriber extends RedisSubscriber {
       server.to(gameId).emit(SocketEvents.END_GAME, {
         host: leaderboard[0]
       });
-      this.logger.verbose(`endGame: ${leaderboard[0]}`);
+      this.logger.verbose(`[endGame]: ${gameId}`);
       return;
     }
 

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

@@ -37,19 +37,38 @@ export class GameChatService {
         timestamp: new Date()
       })
     );
-    this.logger.verbose(`채팅 전송: ${gameId} - ${clientId} (${player.playerName}) = ${message}`);
+
+    this.logger.verbose(
+      `[chatMessage] Room: ${gameId} | playerId: ${clientId} | playerName: ${player.playerName} | isAlive: ${player.isAlive ? '생존자' : '관전자'} | Message: ${message}`
+    );
   }
 
   async subscribeChatEvent(server: Server) {
     const chatSubscriber = this.redis.duplicate();
     chatSubscriber.psubscribe('chat:*');
 
     chatSubscriber.on('pmessage', async (_pattern, channel, message) => {
-      console.log(`channel: ${channel}`); // channel: chat:317172
-      console.log(`message: ${message}`); //  message: {"playerId":"8CT28Iw5FgjgPHNyAAAs","playerName":"Player1","message":"Hello, everyone!","timestamp":"2024-11-14T08:32:38.617Z"}
-      const gameId = channel.split(':')[1];
+      const gameId = channel.split(':')[1]; // ex. channel: chat:317172
       const chatMessage = JSON.parse(message);
-      server.to(gameId).emit(SocketEvents.CHAT_MESSAGE, chatMessage);
+
+      const playerKey = REDIS_KEY.PLAYER(chatMessage.playerId);
+      const isAlivePlayer = await this.redis.hget(playerKey, 'isAlive');
+
+      if (isAlivePlayer === '1') {
+        server.to(gameId).emit(SocketEvents.CHAT_MESSAGE, chatMessage);
+        return;
+      }
+
+      // 죽은 사람의 채팅은 죽은 사람끼리만 볼 수 있도록 처리
+      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');
+
+        if (isAlive === '0') {
+          server.to(playerId).emit(SocketEvents.CHAT_MESSAGE, chatMessage);
+        }
+      }));
     });
   }
 }

BE/src/game/service/game.room.service.ts

@@ -28,7 +28,7 @@ export class GameRoomService {
     const currentRoomPins = await this.redis.smembers(REDIS_KEY.ACTIVE_ROOMS);
     const roomId = generateUniquePin(currentRoomPins);
 
-    await this.redis.hmset(REDIS_KEY.ROOM(roomId), {
+    await this.redis.hset(REDIS_KEY.ROOM(roomId), {
       host: clientId,
       status: 'waiting',
       title: gameConfig.title,
@@ -69,12 +69,13 @@ export class GameRoomService {
     const positionY = Math.random();
 
     await this.redis.set(`${playerKey}:Changes`, 'Join');
-    await this.redis.hmset(playerKey, {
+    await this.redis.hset(playerKey, {
       playerName: dto.playerName,
       positionX: positionX.toString(),
       positionY: positionY.toString(),
       disconnected: '0',
-      gameId: dto.gameId
+      gameId: dto.gameId,
+      isAlive: '1'
     });
 
     await this.redis.zadd(REDIS_KEY.ROOM_LEADERBOARD(dto.gameId), 0, clientId);
@@ -113,7 +114,7 @@ export class GameRoomService {
     this.gameValidator.validatePlayerIsHost(SocketEvents.UPDATE_ROOM_OPTION, room, clientId);
 
     await this.redis.set(`${roomKey}:Changes`, 'Option');
-    await this.redis.hmset(roomKey, {
+    await this.redis.hset(roomKey, {
       title: title,
       gameMode: gameMode,
       maxPlayerCount: maxPlayerCount.toString(),
@@ -132,7 +133,7 @@ export class GameRoomService {
     this.gameValidator.validatePlayerIsHost(SocketEvents.UPDATE_ROOM_QUIZSET, room, clientId);
 
     await this.redis.set(`${roomKey}:Changes`, 'Quizset');
-    await this.redis.hmset(roomKey, {
+    await this.redis.hset(roomKey, {
       quizSetId: quizSetId.toString(),
       quizCount: quizCount.toString()
     });
@@ -152,7 +153,7 @@ export class GameRoomService {
     // 플레이어 제거
     pipeline.srem(REDIS_KEY.ROOM_PLAYERS(roomId), clientId);
     // 1. 플레이어 상태를 'disconnected'로 변경하고 TTL 설정
-    pipeline.hmset(REDIS_KEY.PLAYER(clientId), {
+    pipeline.hset(REDIS_KEY.PLAYER(clientId), {
       disconnected: '1',
       disconnectedAt: Date.now().toString()
     });

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

@@ -31,7 +31,7 @@ export class GameService {
     this.gameValidator.validatePlayerInRoom(SocketEvents.UPDATE_POSITION, gameId, player);
 
     await this.redis.set(`${playerKey}:Changes`, 'Position');
-    await this.redis.hmset(playerKey, {
+    await this.redis.hset(playerKey, {
       positionX: newPosition[0].toString(),
       positionY: newPosition[1].toString()
     });
@@ -87,13 +87,13 @@ export class GameService {
       ...selectedQuizList.map((quiz) => quiz.id)
     );
     for (const quiz of selectedQuizList) {
-      await this.redis.hmset(REDIS_KEY.ROOM_QUIZ(gameId, quiz.id), {
+      await this.redis.hset(REDIS_KEY.ROOM_QUIZ(gameId, quiz.id), {
         quiz: quiz.quiz,
         answer: quiz.choiceList.find((choice) => choice.isAnswer).order,
         limitTime: quiz.limitTime.toString(),
         choiceCount: quiz.choiceList.length.toString()
       });
-      await this.redis.hmset(
+      await this.redis.hset(
         REDIS_KEY.ROOM_QUIZ_CHOICES(gameId, quiz.id),
         quiz.choiceList.reduce(
           (acc, choice) => {
@@ -113,15 +113,15 @@ export class GameService {
 
     // 게임이 시작되었음을 알림
     await this.redis.set(`${roomKey}:Changes`, 'Start');
-    await this.redis.hmset(roomKey, {
+    await this.redis.hset(roomKey, {
       status: 'playing'
     });
 
     // 첫 퀴즈 걸어주기
     await this.redis.set(REDIS_KEY.ROOM_CURRENT_QUIZ(gameId), '-1:end'); // 0:start, 0:end, 1:start, 1:end
     await this.redis.set(REDIS_KEY.ROOM_TIMER(gameId), 'timer', 'EX', 3);
 
-    this.logger.verbose(`게임 시작: ${gameId}`);
+    this.logger.verbose(`게임 시작 (gameId: ${gameId}) (gameMode: ${room.gameMode})`);
   }
 
   async subscribeRedisEvent(server: Server) {
@@ -143,12 +143,12 @@ export class GameService {
     const players = await this.redis.smembers(roomPlayersKey);
     if (host === clientId && players.length > 0) {
       const newHost = await this.redis.srandmember(REDIS_KEY.ROOM_PLAYERS(playerData.gameId));
-      await this.redis.hmset(roomKey, {
+      await this.redis.hset(roomKey, {
         host: newHost
       });
     }
     await this.redis.set(`${playerKey}:Changes`, 'Disconnect', 'EX', 600); // 해당플레이어의 변화정보 10분 후에 삭제
-    await this.redis.hmset(playerKey, {
+    await this.redis.hset(playerKey, {
       disconnected: '1'
     });
 

BE/src/user/entities/user-quiz-archive.entity.ts

@@ -2,11 +2,7 @@ import { Column, Entity, JoinColumn, ManyToOne } from 'typeorm';
 import { BaseModel } from '../../common/entity/base.entity';
 import { QuizSetModel } from '../../quiz-set/entities/quiz-set.entity';
 import { UserModel } from './user.entity';
-
-export enum GameMode {
-  SURVIVAL = 'SURVIVAL',
-  RANKING = 'RANKING'
-}
+import { GameMode } from '../../common/constants/game-mode';
 
 @Entity('user_quiz_archive')
 export class UserQuizArchiveModel extends BaseModel {