Kirjutame matchmaking'i Dota 2014. aastaks

Tere kõigile.

Sel kevadel leidsin projekti, kus seltskond õppis käivitama Dota 2 serverit 2014. aasta versioonis ning seega mängima sellel. Olen suur selle mängu fänn ja ei saanud mööda vaadata ainulaadsest võimalusest naasta oma lapsepõlve.

Sukeldusin sügavale ja lõpuks kirjutasin Discordi boti, mis vastutab praktiliselt kogu funktsionaalsuse eest, mida ei toetata vanas mänguversioonis, nimelt matšide leidmine.
Kuni kõikide uuendusteni moodustati lobby käsitsi. Koguti 10 reaktsiooni sõnumile ja koguti server käsitsi või korraldati kohalik lobby.

Minu programmeerija loomus ei pidanud vastu nii suurele hulgale käsitööle ja öö jooksul viskasin kokku kõige lihtsama boti versiooni, mis tõstis serveri automaatselt üles, kui 10 inimest sai kokku.

Otsustasin kirjutada Node.js-is, sest ma ei armasta pythonit väga ning tunnen end selles keskkonnas mugavamalt.

See on minu esimene kogemus Discordi boti kirjutamisel, kuid osutus kõik väga lihtsaks. Ametlik npm moodul discord.js pakub mugavat liidest sõnumite, reaktsioonide kogumise jne jaoks.

Klausel: kõik koodi näited on „aktuaalsed“, see tähendab, et need on läbinud mitu öist ümberkirjutamist.

Matšide leidmise aluseks on „järjekord“, kuhu paigutatakse mängijad, kes soovivad mängida, ja kust nad eemaldatakse, kui nad enam ei soovi või on mängu leidnud.

Nii näeb välja „mängija“ entiteet. Alguses oli see lihtsalt Discordi kasutaja id, kuid plaanis on ka launcher/mänguotsing veebisaidilt, aga kõigest järgemööda.

export enum Realm {
  DISCORD,
  EXTERNAL,
}

export default class QueuePlayer {
  constructor(public readonly realm: Realm, public readonly id: string) {}

  public is(qp: QueuePlayer): boolean {
    return this.realm === qp.realm && this.id === qp.id;
  }

  static Discord(id: string) {
    return new QueuePlayer(Realm.DISCORD, id);
  }

  static External(id: string) {
    return new QueuePlayer(Realm.EXTERNAL, id);
  }
}

Ja siin on järjekorra liides. Siin kasutatakse „mängijate“ asemel abstraktsiooni „grupp“. Ühe tagamängija jaoks koosneb grupp temast endast, grupimängijate jaoks aga grupi kõigist mängijatest.

export default interface IQueue extends EventEmitter {
  inQueue: QueuePlayer[]
  put(uid: Party): boolean;
  remove(uid: Party): boolean;
  removeAll(ids: Party[]): void;

  mode: MatchmakingMode
  roomSize: number;
  clear(): void
}

Otsustasin kasutada sündmusi konteksti edastamiseks. See sobis juhtumitega — sündmuse „mäng leitud 10 inimesele” korral saab saata mängijatele vajaliku sõnumi ning täita peamise äriloogika — alustada ülesande täitmist valmisoleku kontrollimiseks, valmistada lobby käivitamiseks jne.

IOC jaoks kasutan InversifyJS-i. Mul on selle teegiga meeldiv kogemus. Kiire ja lihtne!

Meil on serveris mitmeid järjekordi — on lisandunud 1x1 režiimid, tavaline/reitingu ning paar kohandatud režiimi. Seetõttu on olemas singleton RoomService, mis asub kasutaja ja mänguotsimise vahel.

constructor(
    @inject(GameServers) private gameServers: GameServers,
    @inject(MatchStatsService) private stats: MatchStatsService,
    @inject(PartyService) private partyService: PartyService
  ) {
    super();
    this.initQueue(MatchmakingMode.RANKED);
    this.initQueue(MatchmakingMode.UNRANKED);
    this.initQueue(MatchmakingMode.SOLOMID);
    this.initQueue(MatchmakingMode.DIRETIDE);
    this.initQueue(MatchmakingMode.GREEVILING);
    this.partyService.addListener(
      "party-update",
      (event: PartyUpdatedEvent) => {
        this.queues.forEach((q) => {
          if (has(q.queue, (t) => t.is(event.party))) {
            // if the queue has this party, we re-add the party
            this.leaveQueue(event.qp, q.mode)
            this.enterQueue(event.qp, q.mode)
          }
        });
      }
    );

    this.partyService.addListener(
      "party-removed",
      (event: PartyUpdatedEvent) => {
        this.queues.forEach((q) => {
          if (has(q.queue, (t) => t.is(event.party))) {
            // if the queue has this party, we re-add the party
            q.remove(event.party)
          }
        });
      }
    );
  }

(Koodi makaronid, et illustreerida, kuidas protsessid välja näevad)

Siin ma initsialiseerin järjekorra iga rakendatud mängurežiimi jaoks ning jälgin grupimuudatusi, et kohandada järjekordi ja vältida teatud konflikte.

Noh, ma olen tubli, lisasin koodikillud, mis ei kuulu teema juurde, ja nüüd liigume juba matšide leidmiseni.

Vaatame juhtumit:

1) Kasutaja soovib mängida.

2) Mänguotsingu alustamiseks kasutab ta Gateway=Discord, st annab reaktsiooni sõnumile:

3) See värav läheb RoomService'i ja ütleb: „Discordi kasutaja soovib järjekorda siseneda, režiim: mitte-reitingu mäng.”

4) RoomService vastu võtab värava taotluse ja paneb kasutaja (täpsemalt kasutaja grupi) sobivasse järjekorda.

5) Iga muudatuse korral kontrollib järjekord, kas mängijad mängimiseks piisavad. Kui nii — emiteerime sündmuse:

private onRoomFound(players: Party[]) {
    this.emit("room-found", {
      players,
    });
  }

6) RoomService, mõistagi, kuulab igat järjekorda selle sündmuse järele, oodates suure elevusega. Me saame sisendina nimekirja mängijatest, loome neist virtuaalse „toa” ja emiteerime loomulikult sündmuse:

queue.addListener("room-found", (event: RoomFoundEvent) => {
      console.log(
        `Tuba leiti režiimi: [${mode}]. Aeg on nende tüüpide jaoks tasuta tuba leida`
      );
      const room = this.getFreeRoom(mode);
      room.fill(event.players);

      this.onRoomFormed(room);
    });

7) Nüüd oleme jõudnud "kõrgeimasse" astmesse — klassi Bot. Üldiselt tegeleb see väravate (kuidas see eesti keeles kõlab) ja matšimängu äriloogika vahelise ühenduse loomisega. Bot kõrvutab sündmust ja käseb DiscordGateway'il kõigile kasutajatele valmisoleku kontrolli saata.

8) Kui keegi on mängu 3 minuti jooksul tagasi lükanud või aktsepteerinud, siis EI naase me neid järjekorda. Kõiki teisi naaseme järjekorda ja ootame, kuni jälle 10 inimest kokku tuleb. Kui kõik mängijad on mängu kinnitanud, algab huvitav osa.

Pühendatud serveri konfiguratsioon

Meie mängud on hostitud VDS-l, millel on Windows server 2012. Selle põhjal saab teha mitmeid järeldusi:

1. Seal pole Dockerit, mis lõi mu südamesse viga
2. Me säästame üüri pealt

Ülesanne on: VPS-il Linuxis käivitada protsess VDS-il. Kirjutasin lihtsa serveri Flaskis. Jah, ma ei armasta Pythoni, aga mis teha — selle serveri kirjutamine on kiirem ja lihtsam.

See täidab 3 funktsiooni:

1. Serveri käivitamine konfiguratsiooniga — kaardi valik, mängijate arvu määramine mängu alustamiseks ja pluginate komplekt. Plaginadest ei hakka hetkel rääkima — see on eraldi lugu, mis vajab liitrit kohvi ja pisaraid, segatuna juuste välja tõmbamisega.
2. Serveri peatamine/taaskäivitamine, kui meil on ebaõnnestunud ühendusi, mida me saame käsitleda ainult käsitsi.

Siin on kõik lihtne, koodinäidete toomine ei ole asjakohane. Skript on 100 rida

Nii et kui 10 inimest on koos ja on mängu aktsepteerinud, käivitatakse server ja kõik ootavad mängimist, saadetakse isiklikele sõnumitele link mänguühendusele.

Lingile klikates ühendab mängija end mänguserveriga ja edasine läheb juba ise. Umbes 25 minuti pärast tühjeneb virtuaalne "tuba" mängijatega.

Vabandust, et artikkel on kohmakas, olen kaua siia kirjutanud ja koodi on liiga palju, et olulisi osi välja tuua. Lihtsalt nuud.

Kui näen huvi teema vastu, siis tuleb teine osa — seal räägin oma kannatustest pluginate osas srcds (Source dedicated server) jaoks, ja suur tõenäosus on, et süsteemist, mis hindab ja mini-dotabuff, veebileht mängustatistika jaoks.

Mõningad lingid:

1. Meie veebileht (statistika, liidrite tabel, väike leht ja kliendi allalaadimine)
2. Discord server

Allikas: habr.com