10 m ban for not loading

enchantinggg4 · enchantinggg4 · commit 2a41cda7216a · 2024-12-21T17:48:45.000+03:00
new matchmaking mode: lobby
pass map into launch server
diff --git a/src/@test/values.ts b/src/@test/values.ts
@@ -7,6 +7,7 @@ import { getRepositoryToken } from '@nestjs/typeorm';
 import { MatchmakingModeMappingEntity } from 'gameserver/model/matchmaking-mode-mapping.entity';
 import { Repository } from 'typeorm';
 import { NestApplicationContext } from '@nestjs/core/nest-application-context';
+import { Dota_Map } from 'gateway/shared-types/dota-map';
 import Mock = jest.Mock;
 
 export const randomUser = () => {
@@ -23,16 +24,24 @@ export function printCalls(bus: EventBus) {
   console.log(inspect(p.mock.calls));
 }
 
-
-export function arrayOf(size: number){
-  return new Array(size).fill(null)
+export function arrayOf(size: number) {
+  return new Array(size).fill(null);
 }
 
-export function createGameMode(app: NestApplicationContext, lobby: MatchmakingMode, mode: Dota_GameMode, enabled: boolean): Promise<MatchmakingModeMappingEntity> {
-  const rep: Repository<MatchmakingModeMappingEntity> = app.get(getRepositoryToken(MatchmakingModeMappingEntity))
+export function createGameMode(
+  app: NestApplicationContext,
+  lobby: MatchmakingMode,
+  mode: Dota_GameMode,
+  map: Dota_Map,
+  enabled: boolean,
+): Promise<MatchmakingModeMappingEntity> {
+  const rep: Repository<MatchmakingModeMappingEntity> = app.get(
+    getRepositoryToken(MatchmakingModeMappingEntity),
+  );
   return rep.save({
     lobbyType: lobby,
     dotaGameMode: mode,
-    enabled
-  })
+    dotaMap: map,
+    enabled,
+  } satisfies MatchmakingModeMappingEntity);
 }
diff --git a/src/gameserver/command/FindGameServer/find-game-server.handler.ts b/src/gameserver/command/FindGameServer/find-game-server.handler.ts
@@ -30,48 +30,67 @@ import { MatchEntity } from 'gameserver/model/match.entity';
 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';
 
 @CommandHandler(FindGameServerCommand)
 export class FindGameServerHandler
-  implements ICommandHandler<FindGameServerCommand> {
+  implements ICommandHandler<FindGameServerCommand>
+{
   private readonly logger = new Logger(FindGameServerHandler.name);
 
-  private pendingGamesPool: Subject<FindGameServerCommand> = new Subject<
-    FindGameServerCommand
-  >();
+  private pendingGamesPool: Subject<FindGameServerCommand> =
+    new Subject<FindGameServerCommand>();
 
   constructor(
     private readonly gsSessionRepository: GameServerSessionRepository,
     @InjectRepository(GameServerSessionEntity)
-    private readonly gameServerSessionModelRepository: Repository<
-      GameServerSessionEntity
-    >,
+    private readonly gameServerSessionModelRepository: Repository<GameServerSessionEntity>,
     private readonly ebus: EventBus,
     @InjectRepository(MatchEntity)
     private readonly matchEntityRepository: Repository<MatchEntity>,
     private readonly qbus: QueryBus,
-    @Inject('QueryCore') private readonly redisEventQueue: ClientProxy,
+    @Inject("QueryCore") private readonly redisEventQueue: ClientProxy,
     @InjectRepository(MatchmakingModeMappingEntity)
     private readonly matchmakingModeMappingEntityRepository: Repository<MatchmakingModeMappingEntity>,
   ) {
     this.pendingGamesPool
-      .pipe(asyncMap(cmd => this.findServer(cmd), 1))
+      .pipe(asyncMap((cmd) => this.findServer(cmd), 1))
       .subscribe();
   }
 
   async execute(command: FindGameServerCommand) {
     this.pendingGamesPool.next(command);
   }
 
-  private async getGameModeForMatchMode(mode: MatchmakingMode): Promise<Dota_GameMode> {
+  private async getMapForMatchMode(mode: MatchmakingMode): Promise<Dota_Map> {
     const mapping = await this.matchmakingModeMappingEntityRepository.findOne({
       where: {
-        lobbyType: mode
-      }
+        lobbyType: mode,
+      },
+    });
+
+    if (!mapping) {
+      this.logger.error(
+        `No mapping found for lobby type ${mode}! Returning all pick`,
+      );
+      return Dota_Map.DOTA;
+    }
+    return mapping.dotaMap;
+  }
+
+  private async getGameModeForMatchMode(
+    mode: MatchmakingMode,
+  ): Promise<Dota_GameMode> {
+    const mapping = await this.matchmakingModeMappingEntityRepository.findOne({
+      where: {
+        lobbyType: mode,
+      },
     });
 
-    if(!mapping){
-      this.logger.error(`No mapping found for lobby type ${mode}! Returning all pick`);
+    if (!mapping) {
+      this.logger.error(
+        `No mapping found for lobby type ${mode}! Returning all pick`,
+      );
       return Dota_GameMode.ALLPICK;
     }
     return mapping.dotaGameMode;
@@ -81,7 +100,7 @@ export class FindGameServerHandler
     const players: FullMatchPlayer[] = [];
 
     // TODO: i dont like it and want to move username resolving into operator
-    const resolves = matchInfo.players.map(async t => {
+    const resolves = matchInfo.players.map(async (t) => {
       const res = await this.qbus.execute<
         GetUserInfoQuery,
         GetUserInfoQueryResult
@@ -95,6 +114,7 @@ export class FindGameServerHandler
 
     return new GSMatchInfo(
       matchInfo.mode,
+      await this.getMapForMatchMode(matchInfo.mode),
       await this.getGameModeForMatchMode(matchInfo.mode),
       matchInfo.roomId,
       players,
@@ -110,7 +130,7 @@ export class FindGameServerHandler
 
     const gsInfo = await this.extendMatchInfo(command.matchInfo);
 
-    console.log('FindServer called, pool', freeServerPool);
+    console.log("FindServer called, pool", freeServerPool);
 
     const m = new MatchEntity();
     m.server = MatchEntity.NOT_DECIDED_SERVER;
@@ -126,18 +146,18 @@ export class FindGameServerHandler
     let i = 0;
     let foundServer: GameServerEntity | undefined;
 
-    console.log('Free pool:', freeServerPool.length);
+    console.log("Free pool:", freeServerPool.length);
     while (i < freeServerPool.length) {
       const candidate = freeServerPool[i];
       const stackUrl = candidate.url;
       try {
         const cmd = new LaunchGameServerCommand(candidate.url, m.id, gsInfo);
         console.log(JSON.stringify(cmd, null, 2));
         const req = await this.redisEventQueue
-          .send<LaunchGameServerResponse, LaunchGameServerCommand>(
-            LaunchGameServerCommand.name,
-            cmd,
-          )
+          .send<
+            LaunchGameServerResponse,
+            LaunchGameServerCommand
+          >(LaunchGameServerCommand.name, cmd)
           .pipe(timeout(15000))
           .toPromise();
 
@@ -152,7 +172,7 @@ export class FindGameServerHandler
           // i guess we skip? just try next server
         }
       } catch (e) {
-        console.log('Sadkek?', e);
+        console.log("Sadkek?", e);
         console.error(e.stack);
         // timeout means server is DEAD
         this.ebus.publish(new ServerNotRespondingEvent(stackUrl));
@@ -163,7 +183,7 @@ export class FindGameServerHandler
       i++;
     }
 
-    console.log('So: ', inspect(foundServer));
+    console.log("So: ", inspect(foundServer));
 
     if (foundServer) {
       m.server = foundServer.url;
diff --git a/src/gameserver/model/matchmaking-mode-mapping.entity.ts b/src/gameserver/model/matchmaking-mode-mapping.entity.ts
@@ -1,17 +1,19 @@
 import { Column, Entity, PrimaryColumn } from 'typeorm';
 import { MatchmakingMode } from 'gateway/shared-types/matchmaking-mode';
 import { Dota_GameMode } from 'gateway/shared-types/dota-game-mode';
+import { Dota_Map } from 'gateway/shared-types/dota-map';
 
-@Entity('matchmaking_mode_mapping_entity')
+@Entity("matchmaking_mode_mapping_entity")
 export class MatchmakingModeMappingEntity {
-
   @PrimaryColumn({ name: "lobby_type" })
-  public lobbyType: MatchmakingMode
-
+  public lobbyType: MatchmakingMode;
 
-  @Column({ name: "enabled"})
+  @Column({ name: "enabled" })
   public enabled: boolean;
 
   @Column({ name: "dota_game_mode" })
-  public dotaGameMode: Dota_GameMode
+  public dotaGameMode: Dota_GameMode;
+
+  @Column({ name: "dota_map", default: Dota_Map.DOTA })
+  public dotaMap: Dota_Map;
 }
diff --git a/src/rest/dto/info.dto.ts b/src/rest/dto/info.dto.ts
@@ -2,6 +2,7 @@ import { Dota2Version } from 'gateway/shared-types/dota2version';
 import { MatchmakingMode } from 'gateway/shared-types/matchmaking-mode';
 import { Dota_GameMode } from 'gateway/shared-types/dota-game-mode';
 import { ApiProperty } from '@nestjs/swagger';
+import { Dota_Map } from 'gateway/shared-types/dota-map';
 
 export class GameServerDto {
   url: string;
@@ -30,11 +31,17 @@ export class MatchmakingModeInfoDto {
   @ApiProperty({ enum: Dota_GameMode, enumName: "Dota_GameMode" })
   game_mode: Dota_GameMode;
 
+  @ApiProperty({ enum: Dota_Map, enumName: "Dota_Map" })
+  dota_map: Dota_Map;
+
   enabled: boolean;
 }
 
 export class UpdateGamemodeDto {
   enabled: boolean;
   @ApiProperty({ enum: Dota_GameMode, enumName: "Dota_GameMode" })
   game_mode: Dota_GameMode;
+
+  @ApiProperty({ enum: Dota_Map, enumName: "Dota_Map" })
+  dota_map: Dota_Map;
 }
diff --git a/src/rest/info/info-controller.spec.ts b/src/rest/info/info-controller.spec.ts
@@ -15,6 +15,7 @@ import { Dota_GameMode } from 'gateway/shared-types/dota-game-mode';
 import { GameServerEntity } from 'gameserver/model/game-server.entity';
 import { UpdateGamemodeDto } from 'rest/dto/info.dto';
 import { Repository } from 'typeorm';
+import { Dota_Map } from 'gateway/shared-types/dota-map';
 
 describe("InfoController", () => {
   jest.setTimeout(60000);
@@ -79,6 +80,7 @@ describe("InfoController", () => {
         app,
         MatchmakingMode.UNRANKED,
         Dota_GameMode.GREEVILING,
+        Dota_Map.DOTA_WINTER,
         true,
       );
 
@@ -89,19 +91,21 @@ describe("InfoController", () => {
     });
   });
 
-  describe("/PATCH /gamemode/:mode", () => {
+  describe("/PUT /gamemode/:mode", () => {
     it(`should update gamemode`, async () => {
       const mode = await createGameMode(
         app,
         MatchmakingMode.UNRANKED,
         Dota_GameMode.GREEVILING,
+        Dota_Map.DOTA_AUTUMN,
         true,
       );
 
       await request(app.getHttpServer())
         .put(`/info/gamemode/${mode.lobbyType}`)
         .send({
           game_mode: Dota_GameMode.RANKED_AP,
+          dota_map: Dota_Map.DOTA681,
           enabled: false,
         } satisfies UpdateGamemodeDto)
         .expect(200);
@@ -117,7 +121,8 @@ describe("InfoController", () => {
         lobbyType: MatchmakingMode.UNRANKED,
         enabled: false,
         dotaGameMode: Dota_GameMode.RANKED_AP,
-      });
+        dotaMap: Dota_Map.DOTA681,
+      } satisfies MatchmakingModeMappingEntity);
     });
   });
 });
diff --git a/src/rest/info/info.controller.ts b/src/rest/info/info.controller.ts
@@ -51,7 +51,7 @@ export class InfoController {
     @Param("mode", ParseIntPipe) mode: MatchmakingMode,
     @Body() dto: UpdateGamemodeDto,
   ) {
-    await this.infoService.updateGamemode(mode, dto.game_mode, dto.enabled);
+    await this.infoService.updateGamemode(mode, dto.game_mode, dto.dota_map, dto.enabled);
   }
 
   @Get("current_online")
diff --git a/src/rest/info/info.mapper.ts b/src/rest/info/info.mapper.ts
@@ -34,6 +34,7 @@ export class InfoMapper {
   ): MatchmakingModeInfoDto => ({
     lobby_type: it.lobbyType,
     game_mode: it.dotaGameMode,
+    dota_map: it.dotaMap,
     enabled: it.enabled,
   });
 }
diff --git a/src/rest/info/info.service.ts b/src/rest/info/info.service.ts
@@ -4,6 +4,7 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { MatchmakingMode } from 'gateway/shared-types/matchmaking-mode';
 import { Dota_GameMode } from 'gateway/shared-types/dota-game-mode';
+import { Dota_Map } from 'gateway/shared-types/dota-map';
 
 @Injectable()
 export class InfoService {
@@ -15,12 +16,14 @@ export class InfoService {
   public async updateGamemode(
     mode: MatchmakingMode,
     game_mode: Dota_GameMode,
+    dota_map: Dota_Map,
     enabled: boolean,
   ) {
     await this.matchmakingModeMappingEntityRepository.upsert(
       {
         lobbyType: mode,
         dotaGameMode: game_mode,
+        dotaMap: dota_map,
         enabled,
       },
       ["lobbyType"],

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ export class InfoController {`
`51`	`51`	`@Param("mode", ParseIntPipe) mode: MatchmakingMode,`
`52`	`52`	`@Body() dto: UpdateGamemodeDto,`
`53`	`53`	`) {`
`54`		`- await this.infoService.updateGamemode(mode, dto.game_mode, dto.enabled);`
	`54`	`+ await this.infoService.updateGamemode(mode, dto.game_mode, dto.dota_map, dto.enabled);`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`@Get("current_online")`
Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,7 @@ export class InfoMapper {`
`34`	`34`	`): MatchmakingModeInfoDto => ({`
`35`	`35`	`lobby_type: it.lobbyType,`
`36`	`36`	`game_mode: it.dotaGameMode,`
	`37`	`+ dota_map: it.dotaMap,`
`37`	`38`	`enabled: it.enabled,`
`38`	`39`	`});`
`39`	`40`	`}`