យើងកំពុងសរសេរការផ្គូផ្គងសម្រាប់ Dota 2014

សួស្តីអ្នករាល់គ្នា។

រដូវផ្ការីកនេះខ្ញុំបានឆ្លងកាត់គម្រោងមួយដែលបុរសបានរៀនពីរបៀបដំណើរការ Dota 2 server version 2014 ហើយតាមនោះ លេងលើវា។ ខ្ញុំជាអ្នកគាំទ្រដ៏ធំនៃហ្គេមនេះ ហើយខ្ញុំមិនអាចរំលងឱកាសពិសេសនេះ ដើម្បីជ្រមុជខ្លួនខ្ញុំក្នុងវ័យកុមារភាពរបស់ខ្ញុំបានទេ។

ខ្ញុំចូលជ្រៅណាស់ ហើយវាបានកើតឡើងដែលខ្ញុំសរសេរ Discord bot ដែលទទួលខុសត្រូវចំពោះមុខងារស្ទើរតែទាំងអស់ដែលមិនត្រូវបានគាំទ្រនៅក្នុងកំណែចាស់នៃហ្គេម ពោលគឺការផ្គូផ្គង។
មុនពេលការច្នៃប្រឌិតទាំងអស់ជាមួយ bot កន្លែងទទួលភ្ញៀវត្រូវបានបង្កើតដោយដៃ។ យើងប្រមូលបាន 10 ប្រតិកម្មចំពោះសារមួយ ហើយប្រមូលផ្តុំម៉ាស៊ីនមេដោយដៃ ឬរៀបចំកន្លែងទទួលភ្ញៀវក្នុងស្រុក។

ធម្មជាតិរបស់ខ្ញុំក្នុងនាមជាអ្នកសរសេរកម្មវិធីមិនអាចទប់ទល់នឹងការងារដោយដៃច្រើននោះទេ ហើយពេញមួយយប់ខ្ញុំបានគូសវាសនូវកំណែសាមញ្ញបំផុតរបស់ bot ដែលដំឡើងម៉ាស៊ីនមេដោយស្វ័យប្រវត្តិនៅពេលមានមនុស្ស 10 នាក់។

ខ្ញុំសម្រេចចិត្តសរសេរក្នុង nodej ភ្លាមៗ ព្រោះខ្ញុំពិតជាមិនចូលចិត្ត Python ហើយខ្ញុំមានអារម្មណ៍ស្រួលជាងនៅក្នុងបរិយាកាសនេះ។

នេះជាបទពិសោធន៍ដំបូងរបស់ខ្ញុំក្នុងការសរសេរ bot សម្រាប់ Discord ប៉ុន្តែវាប្រែទៅជាសាមញ្ញណាស់។ ម៉ូឌុល npm ផ្លូវការ discord.js ផ្តល់នូវចំណុចប្រទាក់ងាយស្រួលសម្រាប់ធ្វើការជាមួយសារ ការប្រមូលប្រតិកម្ម។ល។

ការបដិសេធ៖ ឧទាហរណ៍កូដទាំងអស់គឺ "បច្ចុប្បន្ន" មានន័យថាពួកគេបានឆ្លងកាត់ការសរសេរឡើងវិញជាច្រើនដងនៅពេលយប់។

មូលដ្ឋាននៃការផ្គូផ្គងគឺជា "ជួរ" ដែលអ្នកលេងដែលចង់លេងត្រូវបានដាក់ចូល និងដកចេញនៅពេលដែលពួកគេមិនចង់ ឬស្វែងរកហ្គេម។

នេះគឺជាអ្វីដែលខ្លឹមសារនៃ "អ្នកលេង" មើលទៅ។ ដំបូងវាគ្រាន់តែជាលេខសម្គាល់អ្នកប្រើប្រាស់នៅក្នុង Discord ប៉ុន្តែមានគម្រោងបើកដំណើរការ/ស្វែងរកហ្គេមពីគេហទំព័រ ប៉ុន្តែជាដំបូង។

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, ធម្មតា/វាយតម្លៃ និងរបៀបផ្ទាល់ខ្លួនពីរបី។ ដូច្នេះហើយ មាន RoomService តែមួយ ដែលស្ថិតនៅចន្លោះអ្នកប្រើប្រាស់ និងការស្វែងរកហ្គេម។

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) RoomService ទទួលយកសំណើរបស់ច្រកផ្លូវ ហើយរុញអ្នកប្រើប្រាស់ (កាន់តែច្បាស់ ក្រុមអ្នកប្រើប្រាស់) ចូលទៅក្នុងជួរដែលចង់បាន។

5) ជួរត្រួតពិនិត្យរាល់ពេលដែលមានអ្នកលេងគ្រប់គ្រាន់ដើម្បីលេង។ បើអាចធ្វើបាន សូមបញ្ចេញព្រឹត្តិការណ៍មួយ៖

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

6) RoomService ច្បាស់ជារីករាយក្នុងការស្តាប់គ្រប់ជួរក្នុងការទន្ទឹងរង់ចាំយ៉ាងអន្ទះសារនៃព្រឹត្តិការណ៍នេះ។ យើងទទួលបានបញ្ជីអ្នកលេងជាធាតុបញ្ចូល បង្កើតជា "បន្ទប់" និម្មិតពីពួកគេ ហើយជាការពិតណាស់ ចេញព្រឹត្តិការណ៍មួយ៖

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) ដូច្នេះយើងបានទៅដល់អាជ្ញាធរ "ខ្ពស់បំផុត" - ថ្នាក់ bot. ជាទូទៅ គាត់ទាក់ទងនឹងការតភ្ជាប់រវាងច្រកផ្លូវ (ខ្ញុំមិនអាចយល់ថាតើវាមើលទៅគួរឱ្យអស់សំណើចជាភាសារុស្សីទេ) និងតក្កវិជ្ជាអាជីវកម្មនៃការផ្គូផ្គង។ bot ស្តាប់ឮព្រឹត្តិការណ៍នេះ ហើយបញ្ជាឱ្យ DiscordGateway ផ្ញើការត្រួតពិនិត្យការត្រៀមខ្លួនទៅកាន់អ្នកប្រើប្រាស់ទាំងអស់។

៨) ប្រសិនបើនរណាម្នាក់បដិសេធ ឬមិនទទួលយកហ្គេមក្នុងរយៈពេល 8 នាទី នោះយើងមិនបញ្ជូនពួកគេទៅជួរនោះទេ។ យើង​ត្រឡប់​អ្នក​ផ្សេង​ទៅ​ជួរ​វិញ ហើយ​រង់ចាំ​រហូត​ដល់​មាន​មនុស្ស​១០​នាក់​ទៀត​។ ប្រសិនបើអ្នកលេងទាំងអស់បានទទួលយកហ្គេមនោះ ផ្នែកគួរឱ្យចាប់អារម្មណ៍នឹងចាប់ផ្តើម។

ការកំណត់រចនាសម្ព័ន្ធម៉ាស៊ីនមេពិសេស

ហ្គេមរបស់យើងត្រូវបានបង្ហោះនៅលើ VDS ជាមួយនឹង Windows server 2012។ ពីនេះយើងអាចទាញការសន្និដ្ឋានជាច្រើន៖

1. គ្មាន​អ្នក​ចត​នៅ​លើ​វា​ដែល​វាយ​ខ្ញុំ​ក្នុង​ចិត្ត
2. យើងសន្សំលើការជួល

ភារកិច្ចគឺដើម្បីដំណើរការដំណើរការនៅលើ VDS ពី VPS នៅលើលីនុច។ ខ្ញុំបានសរសេរម៉ាស៊ីនមេសាមញ្ញមួយនៅក្នុង Flask ។ បាទ/ចាស ខ្ញុំមិនចូលចិត្ត Python ទេ ប៉ុន្តែតើអ្នកអាចធ្វើអ្វីបាន? វាលឿន និងងាយស្រួលជាងក្នុងការសរសេរម៉ាស៊ីនមេនេះនៅលើវា។

វាអនុវត្តមុខងារ ៣៖

1. ការចាប់ផ្តើមម៉ាស៊ីនមេជាមួយនឹងការកំណត់រចនាសម្ព័ន្ធ - ការជ្រើសរើសផែនទី ចំនួនអ្នកលេងដែលត្រូវចាប់ផ្តើមហ្គេម និងសំណុំនៃកម្មវិធីជំនួយ។ ខ្ញុំនឹងមិនសរសេរអំពីកម្មវិធីជំនួយទេឥឡូវនេះ - នោះជារឿងខុសគ្នាជាមួយកាហ្វេមួយលីត្រនៅពេលយប់ លាយឡំដោយទឹកភ្នែក និងសក់រហែក។
2. ការបញ្ឈប់/ចាប់ផ្តើមម៉ាស៊ីនមេឡើងវិញ ក្នុងករណីការតភ្ជាប់មិនជោគជ័យ ដែលយើងអាចដោះស្រាយដោយដៃតែប៉ុណ្ណោះ។

អ្វីគ្រប់យ៉ាងគឺសាមញ្ញនៅទីនេះ ឧទាហរណ៍កូដក៏មិនសមរម្យដែរ។ 100 អក្សរកាត់

ដូច្នេះ នៅពេលដែលមនុស្ស 10 នាក់បានជួបជុំគ្នា និងទទួលយកហ្គេម នោះម៉ាស៊ីនមេត្រូវបានបើកដំណើរការ ហើយគ្រប់គ្នាចង់លេង តំណភ្ជាប់ដើម្បីភ្ជាប់ទៅហ្គេមត្រូវបានផ្ញើជាសារឯកជន។

ដោយចុចលើតំណ អ្នកលេងភ្ជាប់ទៅម៉ាស៊ីនមេហ្គេម ហើយបន្ទាប់មកនោះជាវា។ បន្ទាប់ពី ~ 25 នាទី "បន្ទប់" និម្មិតជាមួយអ្នកលេងត្រូវបានសម្អាត។

ខ្ញុំសូមអភ័យទោសទុកជាមុនចំពោះភាពឆ្គាំឆ្គងនៃអត្ថបទ ខ្ញុំមិនបានសរសេរនៅទីនេះយូរទេ ហើយវាមានកូដច្រើនពេកដើម្បីរំលេចផ្នែកសំខាន់ៗ។ គុយទាវ, និយាយឱ្យខ្លី។

ប្រសិនបើខ្ញុំឃើញចំណាប់អារម្មណ៍លើប្រធានបទនេះ នឹងមានផ្នែកទីពីរ - វានឹងមានការដាក់ទណ្ឌកម្មរបស់ខ្ញុំជាមួយនឹងកម្មវិធីជំនួយសម្រាប់ srcds (Source dedicated server) ហើយប្រហែលជាប្រព័ន្ធវាយតម្លៃ និង mini-dotabuff ដែលជាគេហទំព័រដែលមានស្ថិតិហ្គេម។

តំណភ្ជាប់មួយចំនួន៖

1. គេហទំព័ររបស់យើង (ស្ថិតិ តារាងពិន្ទុ ទំព័រចុះចតតូច និងការទាញយកអតិថិជន)
2. ម៉ាស៊ីនមេមិនចុះសម្រុង

ប្រភព: www.habr.com