Dota 2014-നായി ഞങ്ങൾ മാച്ച് മേക്കിംഗ് എഴുതുകയാണ്

എല്ലാവർക്കും ഹലോ.

ഈ വസന്തകാലത്ത് ഞാൻ ഒരു പ്രോജക്റ്റ് കണ്ടു, അതിൽ ആൺകുട്ടികൾ Dota 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) തിരയൽ ആരംഭിക്കുന്നതിന്, അവൻ ഗേറ്റ്‌വേ=ഡിസ്‌കോർഡ് ഉപയോഗിക്കുന്നു, അതായത്, സന്ദേശത്തോട് ഒരു പ്രതികരണം നൽകുന്നു:

3) ഈ ഗേറ്റ്‌വേ RoomService-ലേക്ക് പോയി, "വ്യത്യാസത്തിൽ നിന്നുള്ള ഒരു ഉപയോക്താവ് ക്യൂ, മോഡ്: റേറ്റുചെയ്യാത്ത ഗെയിമിൽ പ്രവേശിക്കാൻ ആഗ്രഹിക്കുന്നു" എന്ന് പറയുന്നു.

4) RoomService ഗേറ്റ്‌വേയുടെ അഭ്യർത്ഥന സ്വീകരിക്കുകയും ഉപയോക്താവിനെ (കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, ഉപയോക്തൃ ഗ്രൂപ്പ്) ആവശ്യമുള്ള ക്യൂവിലേക്ക് തള്ളുകയും ചെയ്യുന്നു.

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) അതിനാൽ ഞങ്ങൾ "ഉയർന്ന" അധികാരത്തിലെത്തി - ക്ലാസ് ബോട്ടം. പൊതുവേ, ഗേറ്റ്‌വേകൾ തമ്മിലുള്ള ബന്ധവും (റഷ്യൻ ഭാഷയിൽ ഇത് എത്ര രസകരമാണെന്ന് എനിക്ക് മനസ്സിലാകുന്നില്ല) മാച്ച് മേക്കിംഗിന്റെ ബിസിനസ്സ് യുക്തിയും അദ്ദേഹം കൈകാര്യം ചെയ്യുന്നു. ബോട്ട് ഇവന്റ് കേൾക്കുകയും എല്ലാ ഉപയോക്താക്കൾക്കും ഒരു റെഡിനെസ് ചെക്ക് അയയ്‌ക്കാൻ ഡിസ്‌കോർഡ് ഗേറ്റ്‌വേയോട് ഉത്തരവിടുകയും ചെയ്യുന്നു.

8) ആരെങ്കിലും 3 മിനിറ്റിനുള്ളിൽ ഗെയിം നിരസിക്കുകയോ സ്വീകരിക്കുകയോ ചെയ്തില്ലെങ്കിൽ, ഞങ്ങൾ അവരെ ക്യൂവിലേക്ക് തിരിച്ചയക്കില്ല. ഞങ്ങൾ എല്ലാവരെയും ക്യൂവിലേക്ക് തിരിച്ച് വീണ്ടും 10 പേർ വരുന്നത് വരെ കാത്തിരിക്കുക. എല്ലാ കളിക്കാരും ഗെയിം അംഗീകരിച്ചിട്ടുണ്ടെങ്കിൽ, രസകരമായ ഭാഗം ആരംഭിക്കുന്നു.

സമർപ്പിത സെർവർ കോൺഫിഗറേഷൻ

വിൻഡോസ് സെർവർ 2012 ഉള്ള VDS-ലാണ് ഞങ്ങളുടെ ഗെയിമുകൾ ഹോസ്റ്റ് ചെയ്തിരിക്കുന്നത്. ഇതിൽ നിന്ന് നമുക്ക് നിരവധി നിഗമനങ്ങളിൽ എത്തിച്ചേരാനാകും:

1. അതിൽ ഒരു ഡോക്കറും ഇല്ല, അത് എന്റെ ഹൃദയത്തിൽ തട്ടി
2. ഞങ്ങൾ വാടകയിൽ ലാഭിക്കുന്നു

Linux-ലെ VPS-ൽ നിന്ന് VDS-ൽ ഒരു പ്രക്രിയ പ്രവർത്തിപ്പിക്കുക എന്നതാണ് ചുമതല. ഞാൻ ഫ്ലാസ്കിൽ ഒരു ലളിതമായ സെർവർ എഴുതി. അതെ, എനിക്ക് പൈത്തൺ ഇഷ്ടമല്ല, പക്ഷേ എനിക്ക് എന്തുചെയ്യാൻ കഴിയും? ഈ സെർവർ അതിൽ എഴുതുന്നത് വേഗത്തിലും എളുപ്പത്തിലും ആണ്.

ഇത് 3 പ്രവർത്തനങ്ങൾ ചെയ്യുന്നു:

1. ഒരു കോൺഫിഗറേഷൻ ഉപയോഗിച്ച് ഒരു സെർവർ ആരംഭിക്കുന്നു - ഒരു മാപ്പ് തിരഞ്ഞെടുക്കൽ, ഗെയിം ആരംഭിക്കേണ്ട കളിക്കാരുടെ എണ്ണം, ഒരു കൂട്ടം പ്ലഗിനുകൾ. ഞാൻ ഇപ്പോൾ പ്ലഗിന്നുകളെ കുറിച്ച് എഴുതില്ല - രാത്രിയിൽ ലിറ്ററുകണക്കിന് കാപ്പിയും കണ്ണീരും കീറിയ മുടിയും കലർന്ന മറ്റൊരു കഥയാണിത്.
2. വിജയിക്കാത്ത കണക്ഷനുകളുടെ കാര്യത്തിൽ സെർവർ നിർത്തുന്നു/പുനരാരംഭിക്കുന്നു, അത് ഞങ്ങൾക്ക് സ്വമേധയാ മാത്രമേ കൈകാര്യം ചെയ്യാൻ കഴിയൂ.

ഇവിടെ എല്ലാം ലളിതമാണ്, കോഡ് ഉദാഹരണങ്ങൾ പോലും ഉചിതമല്ല. 100 വരി സ്ക്രിപ്റ്റ്

അങ്ങനെ, 10 പേർ ഒത്തുചേർന്ന് ഗെയിം സ്വീകരിച്ചപ്പോൾ, സെർവർ ലോഞ്ച് ചെയ്തു, എല്ലാവരും കളിക്കാൻ ഉത്സുകരായി, ഗെയിമിലേക്ക് കണക്റ്റുചെയ്യാനുള്ള ലിങ്ക് സ്വകാര്യ സന്ദേശങ്ങളിൽ അയച്ചു.

ലിങ്കിൽ ക്ലിക്കുചെയ്യുന്നതിലൂടെ, പ്ലെയർ ഗെയിം സെർവറിലേക്ക് കണക്റ്റുചെയ്യുന്നു, തുടർന്ന് അത്രമാത്രം. ~25 മിനിറ്റിന് ശേഷം, കളിക്കാരുള്ള വെർച്വൽ "റൂം" മായ്‌ക്കുന്നു.

ലേഖനത്തിന്റെ അസ്വാസ്ഥ്യത്തിന് ഞാൻ മുൻകൂട്ടി ക്ഷമ ചോദിക്കുന്നു, വളരെക്കാലമായി ഞാൻ ഇവിടെ എഴുതിയിട്ടില്ല, പ്രധാനപ്പെട്ട വിഭാഗങ്ങൾ ഹൈലൈറ്റ് ചെയ്യാൻ വളരെയധികം കോഡ് ഉണ്ട്. നൂഡിൽസ്, ചുരുക്കത്തിൽ.

വിഷയത്തിൽ ഞാൻ താൽപ്പര്യം കാണുകയാണെങ്കിൽ, ഒരു രണ്ടാം ഭാഗം ഉണ്ടാകും - അതിൽ srcds (സോഴ്സ് ഡെഡിക്കേറ്റഡ് സെർവർ) എന്നതിനായുള്ള പ്ലഗിനുകൾ ഉള്ള എന്റെ പീഡനം അടങ്ങിയിരിക്കും, കൂടാതെ, ഒരുപക്ഷേ, ഒരു റേറ്റിംഗ് സിസ്റ്റവും മിനി-ഡോട്ടബഫും, ഗെയിം സ്ഥിതിവിവരക്കണക്കുകളുള്ള ഒരു സൈറ്റും.

ചില ലിങ്കുകൾ:

1. ഞങ്ങളുടെ വെബ്സൈറ്റ് (സ്ഥിതിവിവരക്കണക്കുകൾ, ലീഡർബോർഡ്, ചെറിയ ലാൻഡിംഗ് പേജ്, ക്ലയന്റ് ഡൗൺലോഡ്)
2. ഡിസ്കോർഡ് സെർവർ

അവലംബം: www.habr.com