feat: implement multiplayer puzzle challenges #47 #126

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged

Mkalbani merged 3 commits into MindFlowInteractive:main from Nanle-code:Multiplayer

Jan 27, 2026

package-lock.json

Large diffs are not rendered by default.

package.json

-Original file line number
+Diff line change
@@ -1,7 +1,67 @@
-    "amqp-connection-manager": "^5.0.0",
-    "amqplib": "^0.10.9",
-    "cache-manager": "^7.2.8",
-    "class-transformer": "^0.5.1",
-    "class-validator": "^0.14.1",
-    "date-fns": "^4.1.0",
-    "firebase-admin": "^13.6.0",
+    {
+        "name": "quest-service",
+        "version": "0.0.1",
+        "description": "Quest Service Backend",
+        "private": true,
+        "license": "MIT",
+        "scripts": {
+            "build": "nest build",
+            "format": "prettier --write \"src/**/*.ts\"",
+            "start": "nest start",
+            "start:dev": "nest start --watch",
+            "start:debug": "nest start --debug --watch",
+            "start:prod": "node dist/main",
+            "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+            "test": "jest",
+            "test:watch": "jest --watch",
+            "test:cov": "jest --coverage",
+            "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
+            "test:e2e": "jest --config ./test/jest-e2e.json"
+        },
+        "dependencies": {
+            "@nestjs/common": "^10.0.0",
+            "@nestjs/config": "^3.0.0",
+            "@nestjs/core": "^10.0.0",
+            "@nestjs/platform-express": "^10.0.0",
+            "@nestjs/platform-socket.io": "^10.0.0",
+            "@nestjs/websockets": "^10.0.0",
+            "@nestjs/throttler": "^5.0.0",
+            "@nestjs/typeorm": "^10.0.0",
+            "@nestjs/cache-manager": "^2.0.0",
+            "cache-manager": "^5.0.0",
+            "@sentry/node": "^7.0.0",
+            "class-transformer": "^0.5.1",
+            "class-validator": "^0.14.0",
+            "helmet": "^7.0.0",
+            "nest-winston": "^1.9.0",
+            "pg": "^8.11.0",
+            "reflect-metadata": "^0.1.13",
+            "rxjs": "^7.8.1",
+            "socket.io": "^4.7.0",
+            "typeorm": "^0.3.17",
+            "uuid": "^9.0.0",
+            "winston": "^3.10.0",
+            "amqplib": "^0.10.3",
+            "amqp-connection-manager": "^4.1.14"
+        },
+        "devDependencies": {
+            "@nestjs/cli": "^10.0.0",
+            "@nestjs/schematics": "^10.0.0",
+            "@nestjs/testing": "^10.0.0",
+            "@types/express": "^4.17.17",
+            "@types/jest": "^29.5.2",
+            "@types/node": "^20.3.1",
+            "@types/socket.io": "^3.0.2",
+            "@types/supertest": "^2.0.12",
+            "@types/uuid": "^9.0.2",
+            "jest": "^29.5.0",
+            "prettier": "^2.8.8",
+            "source-map-support": "^0.5.21",
+            "supertest": "^6.3.3",
+            "ts-jest": "^29.1.0",
+            "ts-loader": "^9.4.3",
+            "ts-node": "^10.9.1",
+            "tsconfig-paths": "^4.2.0",
+            "typescript": "^5.1.3"
+        }
+    }

src/app.module.ts

            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -35,6 +35,7 @@ import { RewardsModule } from './rewards/rewards.module';
  
    import { PuzzleModule } from './puzzle/puzzle.module';

    import { EventModule } from './event/event.module';

    import { SeasonalEventsModule } from './seasonal-events/seasonal-events.module';

    import { MultiplayerModule } from './multiplayer/multiplayer.module';

    import { RecommendationsModule } from './recommendations/recommendations.module';

    @Module({

    @@ -46,7 +47,7 @@ import { RecommendationsModule } from './recommendations/recommendations.module'
  
          load: [appConfig],

          envFilePath: ['.env.local', '.env'],

        }),

        RabbitMQModule,

        // Logging

    @@ -68,7 +69,7 @@ import { RecommendationsModule } from './recommendations/recommendations.module'
  
          inject: [ConfigService],

        }),

        // Feature modules

        UsersModule,

        PlayerProfileModule,

    @@ -91,6 +92,7 @@ import { RecommendationsModule } from './recommendations/recommendations.module'
  
        PuzzleModule,

        EventModule,

        SeasonalEventsModule,

        MultiplayerModule,

        RecommendationsModule,

      ],

      controllers: [AppController],

    @@ -102,4 +104,4 @@ import { RecommendationsModule } from './recommendations/recommendations.module'
  
        },

      ],

    })

    export class AppModule {}

    export class AppModule { }

src/leaderboard/leaderboard.module.ts

-Original file line number
+Diff line change
@@ Expand Up @@
       ],
       controllers: [LeaderboardController],
       providers: [LeaderboardService],
+      exports: [LeaderboardService],
     })
     export class LeaderboardModule { }

src/multiplayer/gateways/multiplayer.gateway.ts

-Original file line number
+Diff line change
@@ -0,0 +1,199 @@
+    import {
+        WebSocketGateway,
+        SubscribeMessage,
+        MessageBody,
+        ConnectedSocket,
+        WebSocketServer,
+        OnGatewayInit,
+        OnGatewayConnection,
+        OnGatewayDisconnect,
+    } from '@nestjs/websockets';
+    import { Server, Socket } from 'socket.io';
+    import { Logger } from '@nestjs/common';
+    import { MultiplayerService } from '../services/multiplayer.service';
+    import { RoomType, Player, RoomStatus } from '../interfaces/multiplayer.interface';
+    import { ValidationService } from '../../game-engine/services/validation.service';
+    import { LeaderboardService } from '../../leaderboard/leaderboard.service';
+    import { PuzzlesService } from '../../puzzles/puzzles.service';
+    import { v4 as uuidv4 } from 'uuid';
+    @WebSocketGateway({
+        cors: {
+            origin: '*',
+        },
+        namespace: 'multiplayer',
+    })
+    export class MultiplayerGateway implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect {
+        @WebSocketServer() server: Server;
+        private logger: Logger = new Logger('MultiplayerGateway');
+        constructor(
+            private readonly multiplayerService: MultiplayerService,
+            private readonly validationService: ValidationService,
+            private readonly leaderboardService: LeaderboardService,
+            private readonly puzzlesService: PuzzlesService,
+        ) { }
+        afterInit(server: Server) {
+            this.logger.log('Multiplayer Gateway Initialized');
+        }
+        handleConnection(client: Socket, ...args: any[]) {
+            this.logger.log(`Client connected: ${client.id}`);
+        }
+        handleDisconnect(client: Socket) {
+            this.logger.log(`Client disconnected: ${client.id}`);
+            const userId = client.data.userId;
+            if (userId) {
+                this.multiplayerService.removeFromQueue(userId);
+            }
+        }
+        @SubscribeMessage('createRoom')
+        handleCreateRoom(
+            @ConnectedSocket() client: Socket,
+            @MessageBody() data: { userId: string; username: string; skillLevel: number; type: RoomType; settings: any }
+        ) {
+            const player: Player = {
+                id: data.userId,
+                username: data.username,
+                skillLevel: data.skillLevel,
+                ready: false,
+                score: 0,
+                solvedPuzzles: [],
+            };
+            const room = this.multiplayerService.createRoom(data.type, player, data.settings);
+            client.join(room.id);
+            client.data.userId = data.userId;
+            return { event: 'roomCreated', data: room };
+        }
+        @SubscribeMessage('joinRoom')
+        handleJoinRoom(
+            @ConnectedSocket() client: Socket,
+            @MessageBody() data: { roomId: string; userId: string; username: string; skillLevel: number }
+        ) {
+            const player: Player = {
+                id: data.userId,
+                username: data.username,
+                skillLevel: data.skillLevel,
+                ready: false,
+                score: 0,
+                solvedPuzzles: [],
+            };
+            const room = this.multiplayerService.joinRoom(data.roomId, player);
+            if (room) {
+                client.join(data.roomId);
+                client.data.userId = data.userId;
+                this.server.to(data.roomId).emit('playerJoined', { player, room });
+                return { event: 'joinedRoom', data: room };
+            }
+            return { event: 'error', data: 'Could not join room' };
+        }
+        @SubscribeMessage('ready')
+        handleReady(
+            @ConnectedSocket() client: Socket,
+            @MessageBody() data: { roomId: string; userId: string; ready: boolean }
+        ) {
+            const room = this.multiplayerService.setPlayerReady(data.roomId, data.userId, data.ready);
+            if (room) {
+                this.server.to(data.roomId).emit('roomUpdated', room);
+                if (room.status === RoomStatus.PLAYING) {
+                    this.server.to(data.roomId).emit('gameStarted', { startTime: room.startTime, puzzleId: room.puzzleId });
+                }
+            }
+        }
+        @SubscribeMessage('updatePuzzleState')
+        handleUpdatePuzzleState(
+            @ConnectedSocket() client: Socket,
+            @MessageBody() data: { roomId: string; state: any }
+        ) {
+            const room = this.multiplayerService.updatePuzzleState(data.roomId, data.state);
+            if (room) {
+                client.to(data.roomId).emit('puzzleStateUpdated', data.state);
+            }
+        }
+        @SubscribeMessage('submitSolution')
+        async handleSubmitSolution(
+            @ConnectedSocket() client: Socket,
+            @MessageBody() data: { roomId: string; userId: string; puzzleId: string; solution: any }
+        ) {
+            const room = this.multiplayerService.getRoom(data.roomId);
+            if (!room || room.status !== RoomStatus.PLAYING) return;
+            try {
+                const puzzle = await this.puzzlesService.findOne(data.puzzleId);
+                if (!puzzle) {
+                    client.emit('error', 'Puzzle not found');
+                    return;
+                }
+                // Adapt Puzzle entity to IPuzzle interface expected by ValidationService
+                const adaptedPuzzle: any = {
+                    id: puzzle.id,
+                    type: puzzle.content.type,
+                    difficulty: puzzle.difficulty,
+                    timeLimit: puzzle.timeLimit,
+                    content: puzzle.content,
+                    isComplete: () => false, // Placeholder as we validate solution directly
+                };
+                const result = await this.validationService.validateSolution(adaptedPuzzle, data.solution);
+                if (result.isValid) {
+                    const player = room.players.find(p => p.id === data.userId);
+                    if (player) {
+                        player.score += result.score;
+                        player.solvedPuzzles.push(data.puzzleId);
+                    }
+                    this.server.to(data.roomId).emit('solutionVerified', {
+                        userId: data.userId,
+                        correct: true,
+                        score: result.score,
+                        totalScore: player?.score
+                    });
+                    if (room.type === RoomType.COMPETITIVE) {
+                        await this.leaderboardService.createEntry({
+                            leaderboardId: 1,
+                            userId: parseInt(data.userId) || 0,
+                            score: player?.score || 0,
+                        } as any);
+                    }
+                } else {
+                    client.emit('solutionVerified', { userId: data.userId, correct: false, errors: result.errors });
+                }
+            } catch (error) {
+                this.logger.error(`Error validating solution: ${error.message}`);
+                client.emit('error', 'Failed to validate solution');
+            }
+        }
+        @SubscribeMessage('startMatchmaking')
+        handleStartMatchmaking(
+            @ConnectedSocket() client: Socket,
+            @MessageBody() data: { userId: string; skillLevel: number; type: RoomType }
+        ) {
+            client.data.userId = data.userId;
+            this.multiplayerService.addToQueue(data.userId, data.skillLevel, data.type);
+            const matchedPlayers = this.multiplayerService.findMatch();
+            if (matchedPlayers) {
+                const matchedRoomId = uuidv4();
+                this.server.emit('matchFound', { roomId: matchedRoomId, players: matchedPlayers });
+            }
+            return { event: 'matchmakingStarted' };
+        }
+        @SubscribeMessage('getLobbies')
+        handleGetLobbies() {
+            const lobbies = this.multiplayerService.getPublicLobbies();
+            return { event: 'lobbiesList', data: lobbies };
+        }
+    }

src/multiplayer/interfaces/multiplayer.interface.ts

-Original file line number
+Diff line change
@@ -0,0 +1,42 @@
+    export enum RoomStatus {
+        LOBBY = 'lobby',
+        PLAYING = 'playing',
+        FINISHED = 'finished',
+    }
+    export enum RoomType {
+        COMPETITIVE = 'competitive',
+        COLLABORATIVE = 'collaborative',
+    }
+    export interface Player {
+        id: string;
+        username: string;
+        skillLevel: number;
+        ready: boolean;
+        score: number;
+        solvedPuzzles: string[];
+    }
+    export interface MultiplayerRoom {
+        id: string;
+        type: RoomType;
+        status: RoomStatus;
+        players: Player[];
+        puzzleId?: string;
+        startTime?: Date;
+        endTime?: Date;
+        puzzleState?: any;
+        settings: {
+            maxPlayers: number;
+            minPlayers: number;
+            timeLimit: number;
+            difficulty: string;
+        };
+    }
+    export interface MatchmakingMatch {
+        players: string[];
+        puzzleId: string;
+        type: RoomType;
+    }

src/multiplayer/multiplayer.module.ts

-Original file line number
+Diff line change
@@ -0,0 +1,19 @@
+    import { Module } from '@nestjs/common';
+    import { MultiplayerService } from './services/multiplayer.service';
+    import { MultiplayerGateway } from './gateways/multiplayer.gateway';
+    import { LeaderboardModule } from '../leaderboard/leaderboard.module';
+    import { CacheModule } from '@nestjs/cache-manager';
+    import { GameEngineModule } from '../game-engine/game-engine.module';
+    import { PuzzlesModule } from '../puzzles/puzzles.module';
+    @Module({
+        imports: [
+            LeaderboardModule,
+            CacheModule.register(),
+            GameEngineModule,
+            PuzzlesModule,
+        ],
+        providers: [MultiplayerService, MultiplayerGateway],
+        exports: [MultiplayerService],
+    })
+    export class MultiplayerModule { }

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

feat: implement multiplayer puzzle challenges #47 #126

Uh oh!

Diff view

Diff view

There are no files selected for viewing

Uh oh!

Uh oh!