Lobby support

Author: enchantinggg4

src/core.controller.ts

@@ -17,6 +17,7 @@ import { StartFakeMatchEvent } from 'gateway/events/start-fake-match.event';
 import { ServerStatusEvent } from 'gateway/events/gs/server-status.event';
 import { MatchFailedEvent } from 'gateway/events/match-failed.event';
 import { PlayerAbandonedEvent } from 'gateway/events/bans/player-abandoned.event';
+import { LobbyReadyEvent } from 'gateway/events/lobby-ready.event';
 
 
 @Controller()
@@ -29,11 +30,16 @@ export class CoreController {
     buff.__proto__ = constructor.prototype;
     if (!isDev) this.ebus.publish(buff);
   }
+
   @EventPattern(RoomReadyEvent.name)
   async RoomReadyEvent(data: RoomReadyEvent) {
     this.event(RoomReadyEvent, data);
   }
 
+  @EventPattern(LobbyReadyEvent.name)
+  async LobbyReadyEvent(data: LobbyReadyEvent) {
+    this.event(LobbyReadyEvent, data);
+  }
 
   @EventPattern(TournamentGameReadyEvent.name)
   async TournamentGameReadyEvent(data: TournamentGameReadyEvent) {

src/gameserver/command/FindGameServer/find-game-server.command.ts

@@ -1,8 +1,8 @@
-import { MatchInfo } from 'gateway/events/room-ready.event';
+import { GamePreparedEvent } from 'gameserver/event/game-prepared.event';
 
 export class FindGameServerCommand {
   constructor(
-    public readonly matchInfo: MatchInfo,
+    public readonly info: GamePreparedEvent,
     public readonly tries: number
   ) {}
 }

src/gameserver/command/FindGameServer/find-game-server.handler.ts

@@ -31,6 +31,7 @@ import { MatchmakingMode } from 'gateway/shared-types/matchmaking-mode';
 import { Dota_GameMode } from 'gateway/shared-types/dota-game-mode';
 import { MatchmakingModeMappingEntity } from 'gameserver/model/matchmaking-mode-mapping.entity';
 import { Dota_Map } from 'gateway/shared-types/dota-map';
+import { GamePreparedEvent } from 'gameserver/event/game-prepared.event';
 
 @CommandHandler(FindGameServerCommand)
 export class FindGameServerHandler
@@ -96,7 +97,9 @@ export class FindGameServerHandler
     return mapping.dotaGameMode;
   }
 
-  private async extendMatchInfo(matchInfo: MatchInfo): Promise<GSMatchInfo> {
+  private async extendMatchInfo(
+    matchInfo: GamePreparedEvent,
+  ): Promise<GSMatchInfo> {
     const players: FullMatchPlayer[] = [];
 
     // TODO: i dont like it and want to move username resolving into operator
@@ -119,22 +122,22 @@ export class FindGameServerHandler
       matchInfo.roomId,
       players,
       matchInfo.version,
-      matchInfo.averageMMR,
+      0,
     );
   }
 
   private async findServer(command: FindGameServerCommand) {
     const freeServerPool = await this.gsSessionRepository.getAllFree(
-      command.matchInfo.version,
+      command.info.version,
     );
 
-    const gsInfo = await this.extendMatchInfo(command.matchInfo);
+    const gsInfo = await this.extendMatchInfo(command.info);
 
     console.log("FindServer called, pool", freeServerPool);
 
     const m = new MatchEntity();
     m.server = MatchEntity.NOT_DECIDED_SERVER;
-    m.mode = command.matchInfo.mode;
+    m.mode = command.info.mode;
     m.started = false;
     m.finished = false;
     m.matchInfoJson = {
@@ -190,7 +193,18 @@ export class FindGameServerHandler
       await this.matchEntityRepository.save(m);
     } else {
       // cancel match : no servers free :sadkek:
-      this.ebus.publish(new MatchCancelledEvent(m.id, command.matchInfo));
+      this.ebus.publish(
+        new MatchCancelledEvent(
+          m.id,
+          new MatchInfo(
+            command.info.mode,
+            command.info.roomId,
+            command.info.players,
+            0,
+            command.info.version,
+          ),
+        ),
+      );
       return;
     }
     // ok here we launch server

src/gameserver/command/PrepareGame/prepare-game.command.ts

@@ -0,0 +1,12 @@
+import { MatchmakingMode } from 'gateway/shared-types/matchmaking-mode';
+import { Dota2Version } from 'gateway/shared-types/dota2version';
+import { MatchPlayer } from 'gateway/events/room-ready.event';
+
+export class PrepareGameCommand {
+  constructor(
+    public readonly lobbyType: MatchmakingMode,
+    public readonly roomId: string,
+    public readonly players: MatchPlayer[],
+    public readonly version: Dota2Version,
+  ) {}
+}

src/gameserver/command/PrepareGame/prepare-game.handler.ts

@@ -0,0 +1,48 @@
+import { CommandHandler, EventBus, ICommandHandler, QueryBus } from '@nestjs/cqrs';
+import { Logger } from '@nestjs/common';
+import { PrepareGameCommand } from 'gameserver/command/PrepareGame/prepare-game.command';
+import { GamePreparedEvent } from 'gameserver/event/game-prepared.event';
+import { MatchmakingMode } from 'gateway/shared-types/matchmaking-mode';
+import { Dota_Map } from 'gateway/shared-types/dota-map';
+import { Dota_GameMode } from 'gateway/shared-types/dota-game-mode';
+import { MatchmakingModeMappingEntity } from 'gameserver/model/matchmaking-mode-mapping.entity';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Dota2Version } from 'gateway/shared-types/dota2version';
+
+@CommandHandler(PrepareGameCommand)
+export class PrepareGameHandler implements ICommandHandler<PrepareGameCommand> {
+  private readonly logger = new Logger(PrepareGameHandler.name);
+
+  constructor(
+    private readonly ebus: EventBus,
+    private readonly qbus: QueryBus,
+    @InjectRepository(MatchmakingModeMappingEntity)
+    private readonly matchmakingModeMappingEntityRepository: Repository<MatchmakingModeMappingEntity>,
+  ) {}
+
+  async execute(command: PrepareGameCommand) {
+    const mapping = await this.getMappingForLobbyType(command.lobbyType);
+
+    this.ebus.publish(
+      new GamePreparedEvent(
+        command.lobbyType,
+        mapping?.dotaGameMode || Dota_GameMode.ALLPICK,
+        mapping?.dotaMap || Dota_Map.DOTA,
+        Dota2Version.Dota_684,
+        command.roomId,
+        command.players,
+      ),
+    );
+  }
+
+  private async getMappingForLobbyType(
+    lobby: MatchmakingMode,
+  ): Promise<MatchmakingModeMappingEntity | undefined> {
+    return await this.matchmakingModeMappingEntityRepository.findOne({
+      where: {
+        lobbyType: lobby,
+      },
+    });
+  }
+}

src/gameserver/event-handler/lobby-ready.handler.ts

@@ -0,0 +1,21 @@
+import { EventBus, EventsHandler, IEventHandler } from '@nestjs/cqrs';
+import { LobbyReadyEvent } from 'gateway/events/lobby-ready.event';
+import { GamePreparedEvent } from 'gameserver/event/game-prepared.event';
+
+@EventsHandler(LobbyReadyEvent)
+export class LobbyReadyHandler implements IEventHandler<LobbyReadyEvent> {
+  constructor(private readonly ebus: EventBus) {}
+
+  async handle(event: LobbyReadyEvent) {
+    this.ebus.publish(
+      new GamePreparedEvent(
+        event.mode,
+        event.gameMode,
+        event.map,
+        event.version,
+        event.roomId,
+        event.players,
+      ),
+    );
+  }
+}

src/gameserver/event/game-prepared.event.ts

@@ -0,0 +1,16 @@
+import { MatchmakingMode } from 'gateway/shared-types/matchmaking-mode';
+import { Dota2Version } from 'gateway/shared-types/dota2version';
+import { Dota_GameMode } from 'gateway/shared-types/dota-game-mode';
+import { Dota_Map } from 'gateway/shared-types/dota-map';
+import { MatchPlayer } from 'gateway/events/room-ready.event';
+
+export class GamePreparedEvent {
+  constructor(
+    public readonly mode: MatchmakingMode,
+    public readonly gameMode: Dota_GameMode,
+    public readonly map: Dota_Map,
+    public readonly version: Dota2Version,
+    public readonly roomId: string,
+    public readonly players: MatchPlayer[],
+  ) {}
+}

src/gameserver/index.ts

@@ -30,12 +30,15 @@ import { ProcessAchievementsHandler } from 'gameserver/command/ProcessAchievemen
 import { AchievementService } from 'gameserver/achievement.service';
 import { MatchFailedHandler } from 'gameserver/event-handler/match-failed.handler';
 import { PlayerAbandonedHandler } from 'gameserver/event-handler/player-abandoned.handler';
+import { PrepareGameHandler } from 'gameserver/command/PrepareGame/prepare-game.handler';
+import { LobbyReadyHandler } from 'gameserver/event-handler/lobby-ready.handler';
 
 const CommandHandlers = [
   FindGameServerHandler,
   ProcessRankedMatchHandler,
   MakeSureExistsHandler,
-  ProcessAchievementsHandler
+  ProcessAchievementsHandler,
+  PrepareGameHandler
 ];
 const EventHandlers = [
   StartFakeMatchHandler,
@@ -52,6 +55,7 @@ const EventHandlers = [
 
   GameResultsHandler,
   PlayerBanHammeredHandler,
+  LobbyReadyHandler,
 
   ServerStatusHandler,
   PlayerNotLoadedHandler,

src/gameserver/saga/gameserver.saga.ts

@@ -2,40 +2,41 @@ import { Injectable } from '@nestjs/common';
 import { ICommand, ofType, Saga } from '@nestjs/cqrs';
 import { Observable } from 'rxjs';
 import { filter, map } from 'rxjs/operators';
-import { FindGameServerCommand } from 'gameserver/command/FindGameServer/find-game-server.command';
-import { MatchInfo, RoomReadyEvent } from 'gateway/events/room-ready.event';
+import { RoomReadyEvent } from 'gateway/events/room-ready.event';
 import { MatchmakingMode } from 'gateway/shared-types/matchmaking-mode';
 import { ProcessRankedMatchCommand } from 'gameserver/command/ProcessRankedMatch/process-ranked-match.command';
 import { PlayerId } from 'gateway/shared-types/player-id';
 import * as uuidr from 'uuid';
 import { ProcessAchievementsCommand } from 'gameserver/command/ProcessAchievements/process-achievements.command';
 import { MatchRecordedEvent } from 'gameserver/event/match-recorded.event';
+import { PrepareGameCommand } from 'gameserver/command/PrepareGame/prepare-game.command';
+import { GamePreparedEvent } from 'gameserver/event/game-prepared.event';
+import { FindGameServerCommand } from 'gameserver/command/FindGameServer/find-game-server.command';
 
 export const uuid = (): string => uuidr.v4();
 
-
 @Injectable()
 export class GameserverSaga {
   @Saga()
-  listenReactions = (events$: Observable<any>): Observable<ICommand> => {
+  prepareRoomGame = (events$: Observable<any>): Observable<ICommand> => {
     return events$.pipe(
       ofType(RoomReadyEvent),
       map(
-        e =>
-          new FindGameServerCommand(
-            new MatchInfo(
-              e.mode,
-              e.roomId,
-              e.players,
-              0,
-              e.version,
-            ),
-            0,
-          ),
+        (e: RoomReadyEvent) =>
+          new PrepareGameCommand(e.mode, e.roomId, e.players, e.version),
       ),
     );
   };
 
+  @Saga()
+  findServer = (events$: Observable<any>): Observable<ICommand> => {
+    return events$.pipe(
+      ofType(GamePreparedEvent),
+      map((e: GamePreparedEvent) => new FindGameServerCommand(e, 0)),
+    );
+  };
+
+  // GamePreparedEvent
 
   // @Saga()
   // tournamentGameReady = (events$: Observable<any>): Observable<ICommand> => {
@@ -76,17 +77,25 @@ export class GameserverSaga {
   processRanked = (events$: Observable<any>): Observable<ICommand> => {
     return events$.pipe(
       ofType(MatchRecordedEvent),
-      filter((t: MatchRecordedEvent) => t.type === MatchmakingMode.RANKED || t.type === MatchmakingMode.UNRANKED),
+      filter(
+        (t: MatchRecordedEvent) =>
+          t.type === MatchmakingMode.RANKED ||
+          t.type === MatchmakingMode.UNRANKED,
+      ),
       map((e: MatchRecordedEvent) => {
-
         const losers = e.players
-          .filter(p => p.team !== e.winner)
-          .map(t => new PlayerId(t.steam_id));
+          .filter((p) => p.team !== e.winner)
+          .map((t) => new PlayerId(t.steam_id));
         const winners = e.players
-          .filter(p => p.team === e.winner)
-          .map(t => new PlayerId(t.steam_id));
+          .filter((p) => p.team === e.winner)
+          .map((t) => new PlayerId(t.steam_id));
 
-        return new ProcessRankedMatchCommand(e.matchId, winners, losers, e.type);
+        return new ProcessRankedMatchCommand(
+          e.matchId,
+          winners,
+          losers,
+          e.type,
+        );
       }),
     );
   };