અમે Dota 2014 માટે મેચમેકિંગ લખી રહ્યા છીએ

બધા ને નમસ્કાર.

આ વસંતમાં મને એક પ્રોજેક્ટ મળ્યો જેમાં લોકોએ ડોટા 2 સર્વર સંસ્કરણ 2014 કેવી રીતે ચલાવવું તે શીખ્યા અને તે મુજબ, તેના પર રમો. હું આ રમતનો મોટો ચાહક છું, અને હું મારા બાળપણમાં મારી જાતને લીન કરવાની આ અનન્ય તકને પસાર કરી શક્યો નથી.

મેં ખૂબ જ ઊંડાણપૂર્વક કબૂતર કર્યું, અને એવું બન્યું કે મેં એક ડિસ્કોર્ડ બૉટ લખ્યો જે લગભગ તમામ કાર્યક્ષમતા માટે જવાબદાર છે જે રમતના જૂના સંસ્કરણમાં સપોર્ટેડ નથી, એટલે કે મેચમેકિંગ.
બૉટ સાથેની તમામ નવીનતાઓ પહેલાં, લોબી મેન્યુઅલી બનાવવામાં આવી હતી. અમે એક સંદેશ પર 10 પ્રતિક્રિયાઓ એકત્રિત કરી અને મેન્યુઅલી સર્વર એસેમ્બલ કર્યું, અથવા સ્થાનિક લોબીનું આયોજન કર્યું.

પ્રોગ્રામર તરીકેનો મારો સ્વભાવ આટલા મેન્યુઅલ વર્કનો સામનો કરી શક્યો નહીં, અને રાતોરાત મેં બૉટનું સૌથી સરળ સંસ્કરણ સ્કેચ કર્યું, જેણે 10 લોકો હતા ત્યારે સર્વરને આપમેળે વધારી દીધું.

મેં તરત જ નોડજમાં લખવાનું નક્કી કર્યું, કારણ કે મને ખરેખર પાયથોન પસંદ નથી, અને હું આ વાતાવરણમાં વધુ આરામદાયક અનુભવું છું.

ડિસ્કોર્ડ માટે બોટ લખવાનો આ મારો પહેલો અનુભવ છે, પરંતુ તે ખૂબ જ સરળ બન્યું. અધિકૃત npm મોડ્યુલ discord.js સંદેશાઓ સાથે કામ કરવા, પ્રતિક્રિયાઓ એકત્રિત કરવા વગેરે માટે અનુકૂળ ઈન્ટરફેસ પૂરું પાડે છે.

અસ્વીકરણ: બધા કોડ ઉદાહરણો "વર્તમાન" છે, જેનો અર્થ છે કે તેઓ રાત્રે પુનઃલેખનના ઘણા પુનરાવર્તનોમાંથી પસાર થયા છે.

મેચમેકિંગનો આધાર એ "કતાર" છે જેમાં જે ખેલાડીઓ રમવા માંગે છે તેમને મૂકવામાં આવે છે અને જ્યારે તેઓ રમત ન કરવા માંગતા હોય અથવા શોધી શકતા નથી ત્યારે તેમને દૂર કરવામાં આવે છે.

"ખેલાડી" નો સાર આ જેવો દેખાય છે. શરૂઆતમાં તે ડિસ્કોર્ડમાં માત્ર એક યુઝર આઈડી હતું, પરંતુ સાઇટ પરથી ગેમ્સને લૉન્ચ/સર્ચ કરવાની યોજના છે, પરંતુ પ્રથમ વસ્તુઓ.

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);
  }
}

અને અહીં કતાર ઇન્ટરફેસ છે. અહીં, "ખેલાડીઓ" ને બદલે "જૂથ" ના રૂપમાં અમૂર્તતાનો ઉપયોગ થાય છે. એક ખેલાડી માટે, જૂથમાં પોતાને અને જૂથના ખેલાડીઓ માટે, અનુક્રમે, જૂથના તમામ ખેલાડીઓનો સમાવેશ થાય છે.

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
}

મેં સંદર્ભની આપલે કરવા માટે ઇવેન્ટ્સનો ઉપયોગ કરવાનું નક્કી કર્યું. તે કેસો માટે યોગ્ય હતું - ઇવેન્ટ પર "10 લોકો માટે એક રમત મળી આવી હતી", તમે ખાનગી સંદેશાઓમાં ખેલાડીઓને જરૂરી સંદેશ મોકલી શકો છો, અને મૂળભૂત વ્યવસાયિક તર્ક કરી શકો છો - તત્પરતા તપાસવા, લોબી તૈયાર કરવા માટે એક કાર્ય શરૂ કરો. લોન્ચ માટે, અને તેથી વધુ.

IOC માટે હું InversifyJS નો ઉપયોગ કરું છું. મને આ પુસ્તકાલય સાથે કામ કરવાનો આનંદદાયક અનુભવ છે. ઝડપી અને સરળ!

અમારી પાસે અમારા સર્વર પર ઘણી કતાર છે - અમે 1x1, સામાન્ય/રેટેડ અને કેટલાક કસ્ટમ મોડ ઉમેર્યા છે. તેથી, ત્યાં એક સિંગલટન રૂમસર્વિસ છે જે વપરાશકર્તા અને રમત શોધ વચ્ચે આવેલું છે.

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 queue has this party, we re-add 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 queue has this party, we re-add party
            q.remove(event.party)
          }
        });
      }
    );
  }

(પ્રક્રિયાઓ લગભગ કેવી દેખાય છે તેનો ખ્યાલ આપવા માટે કોડ નૂડલ્સ)

અહીં હું દરેક અમલી રમત મોડ્સ માટે કતાર શરૂ કરું છું, અને કતારોને સમાયોજિત કરવા અને કેટલાક તકરારને ટાળવા માટે "જૂથો" માં ફેરફારો માટે પણ સાંભળું છું.

તેથી, સારું કર્યું, મેં કોડના ટુકડાઓ દાખલ કર્યા કે જેનો વિષય સાથે કોઈ લેવાદેવા નથી, અને હવે ચાલો સીધા મેચમેકિંગ તરફ આગળ વધીએ.

ચાલો કેસ ધ્યાનમાં લઈએ:

1) વપરાશકર્તા રમવા માંગે છે.

2) શોધ શરૂ કરવા માટે, તે Gateway=Discord નો ઉપયોગ કરે છે, એટલે કે, સંદેશ પર પ્રતિક્રિયા આપે છે:

3) આ ગેટવે RoomService પર જાય છે અને કહે છે કે "વિવાદમાંથી વપરાશકર્તા કતારમાં દાખલ થવા માંગે છે, મોડ: અનરેટેડ ગેમ."

4) રૂમસર્વિસ ગેટવેની વિનંતી સ્વીકારે છે અને વપરાશકર્તા (વધુ સ્પષ્ટ રીતે, વપરાશકર્તા જૂથ) ને ઇચ્છિત કતારમાં ધકેલે છે.

5) દર વખતે જ્યારે રમવા માટે પૂરતા ખેલાડીઓ હોય ત્યારે કતાર તપાસે છે. જો શક્ય હોય તો, એક ઘટના બહાર કાઢો:

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

6) રૂમસર્વિસ દેખીતી રીતે આ ઇવેન્ટની બેચેન અપેક્ષામાં દરેક કતારને ખુશીથી સાંભળી રહી છે. અમે ઇનપુટ તરીકે ખેલાડીઓની સૂચિ પ્રાપ્ત કરીએ છીએ, તેમની પાસેથી વર્ચ્યુઅલ "રૂમ" બનાવીએ છીએ અને, અલબત્ત, એક ઇવેન્ટ જારી કરીએ છીએ:

queue.addListener("room-found", (event: RoomFoundEvent) => {
      console.log(
        `Room found mode: [${mode}]. Time to get free room for these guys`
      );
      const room = this.getFreeRoom(mode);
      room.fill(event.players);

      this.onRoomFormed(room);
    });

7) તેથી અમે "ઉચ્ચ" સત્તા - વર્ગ સુધી પહોંચ્યા બોટ. સામાન્ય રીતે, તે ગેટવે વચ્ચેના જોડાણ સાથે વ્યવહાર કરે છે (હું સમજી શકતો નથી કે તે રશિયનમાં કેટલું રમુજી લાગે છે) અને મેચમેકિંગના વ્યવસાયિક તર્ક. બૉટ ઇવેન્ટને સાંભળે છે અને તમામ વપરાશકર્તાઓને રેડીનેસ ચેક મોકલવા માટે DiscordGateway ને આદેશ આપે છે.

8) જો કોઈ વ્યક્તિ 3 મિનિટની અંદર રમતને નકારે અથવા સ્વીકારે નહીં, તો અમે તેમને કતારમાં પાછા નહીં આપીએ. અમે બીજા બધાને કતારમાં પાછા આપીએ છીએ અને 10 લોકો ફરીથી ન થાય ત્યાં સુધી રાહ જુઓ. જો બધા ખેલાડીઓએ રમત સ્વીકારી લીધી હોય, તો પછી રસપ્રદ ભાગ શરૂ થાય છે.

સમર્પિત સર્વર ગોઠવણી

અમારી રમતો વિન્ડોઝ સર્વર 2012 સાથે VDS પર હોસ્ટ કરવામાં આવી છે. આના પરથી આપણે ઘણા તારણો કાઢી શકીએ છીએ:

1. તેના પર કોઈ ડોકર નથી, જે મારા હૃદયમાં અથડાય છે
2. અમે ભાડા પર બચત કરીએ છીએ

કાર્ય Linux પર VPS માંથી VDS પર પ્રક્રિયા ચલાવવાનું છે. મેં ફ્લાસ્કમાં એક સરળ સર્વર લખ્યું. હા, મને પાયથોન પસંદ નથી, પણ હું શું કરી શકું? આ સર્વર પર લખવું વધુ ઝડપી અને સરળ છે.

તે 3 કાર્યો કરે છે:

1. રૂપરેખાંકન સાથે સર્વર શરૂ કરવું - નકશો પસંદ કરવો, રમત શરૂ કરવા માટે ખેલાડીઓની સંખ્યા અને પ્લગઇનનો સમૂહ. હું હમણાં પ્લગઇન્સ વિશે લખીશ નહીં - તે આંસુ અને ફાટેલા વાળ સાથે મિશ્રિત રાત્રે લિટર કોફી સાથેની એક અલગ વાર્તા છે.
2. અસફળ કનેક્શન્સના કિસ્સામાં સર્વરને રોકવું/પુનઃપ્રારંભ કરવું, જેને આપણે ફક્ત મેન્યુઅલી હેન્ડલ કરી શકીએ છીએ.

અહીં બધું સરળ છે, કોડ ઉદાહરણો પણ યોગ્ય નથી. 100 લીટીની સ્ક્રિપ્ટ

તેથી, જ્યારે 10 લોકો ભેગા થયા અને રમત સ્વીકારી, સર્વર શરૂ થયું અને દરેક જણ રમવા માટે ઉત્સુક હતા, ખાનગી સંદેશાઓમાં રમત સાથે જોડાવા માટેની લિંક મોકલવામાં આવી.

લિંક પર ક્લિક કરીને, પ્લેયર ગેમ સર્વર સાથે જોડાય છે, અને પછી બસ. ~25 મિનિટ પછી, ખેલાડીઓ સાથેનો વર્ચ્યુઅલ "રૂમ" સાફ થઈ જાય છે.

લેખની અણઘડતા માટે હું અગાઉથી માફી માંગુ છું, મેં અહીં લાંબા સમયથી લખ્યું નથી, અને મહત્વપૂર્ણ વિભાગોને પ્રકાશિત કરવા માટે ખૂબ કોડ છે. નૂડલ્સ, ટૂંકમાં.

જો હું વિષયમાં રસ જોઉં, તો બીજો ભાગ હશે - તેમાં srcds (સોર્સ ડેડિકેટેડ સર્વર) માટેના પ્લગઈન્સ સાથેની મારી યાતના અને કદાચ, રેટિંગ સિસ્ટમ અને મિની-ડોટાબફ, ગેમના આંકડા સાથેની સાઇટ હશે.

કેટલીક લિંક્સ:

1. અમારી વેબસાઇટ (આંકડા, લીડરબોર્ડ, નાનું લેન્ડિંગ પૃષ્ઠ અને ક્લાયંટ ડાઉનલોડ)
2. ડિસ્કોર્ડ સર્વર

સોર્સ: www.habr.com