हम Dota 2014 के लिए मैचमेकिंग लिख रहे हैं

नमस्कार.

इस वसंत में मुझे एक प्रोजेक्ट मिला जिसमें लोगों ने सीखा कि Dota 2 सर्वर संस्करण 2014 कैसे चलाया जाता है और, तदनुसार, उस पर खेला जाता है। मैं इस खेल का बहुत बड़ा प्रशंसक हूं, और मैं अपने बचपन में डूबने का यह अनूठा अवसर नहीं छोड़ सकता।

मैंने बहुत गहराई से विचार किया, और ऐसा हुआ कि मैंने एक डिस्कॉर्ड बॉट लिखा जो लगभग सभी कार्यक्षमताओं के लिए ज़िम्मेदार है जो गेम के पुराने संस्करण में समर्थित नहीं है, अर्थात् मैचमेकिंग।
बॉट के साथ सभी नवाचारों से पहले, लॉबी मैन्युअल रूप से बनाई गई थी। हमने एक संदेश पर 10 प्रतिक्रियाएं एकत्र कीं और मैन्युअल रूप से एक सर्वर इकट्ठा किया, या एक स्थानीय लॉबी की मेजबानी की।

एक प्रोग्रामर के रूप में मेरा स्वभाव इतने सारे मैन्युअल काम का सामना नहीं कर सका, और रात भर में मैंने बॉट का सबसे सरल संस्करण तैयार किया, जो 10 लोगों के होने पर स्वचालित रूप से सर्वर को ऊपर उठा देता था।

मैंने तुरंत नोडज में लिखने का फैसला किया, क्योंकि मुझे वास्तव में पायथन पसंद नहीं है, और मैं इस माहौल में अधिक सहज महसूस करता हूं।

डिस्कोर्ड के लिए बॉट लिखने का यह मेरा पहला अनुभव है, लेकिन यह बहुत सरल निकला। आधिकारिक एनपीएम मॉड्यूल 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) यह गेटवे रूमसर्विस पर जाता है और कहता है, "डिस्कॉर्ड से एक उपयोगकर्ता कतार में प्रवेश करना चाहता है, मोड: अनरेटेड गेम।"

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) इस प्रकार हम "सर्वोच्च" अधिकारी - वर्ग तक पहुँच गये बीओटी. सामान्य तौर पर, वह गेटवे (मैं समझ नहीं पाता कि यह रूसी में कितना अजीब लगता है) और मैचमेकिंग के व्यावसायिक तर्क के बीच संबंध से निपटता है। बॉट घटना को सुनता है और डिस्कॉर्डगेटवे को सभी उपयोगकर्ताओं को तत्परता जांच भेजने का आदेश देता है।

8) यदि कोई 3 मिनट के भीतर खेल को अस्वीकार कर देता है या स्वीकार नहीं करता है, तो हम उन्हें कतार में वापस नहीं करते हैं। हम बाकी सभी को कतार में लौटाते हैं और तब तक प्रतीक्षा करते हैं जब तक कि फिर से 10 लोग न आ जाएँ। यदि सभी खिलाड़ियों ने खेल को स्वीकार कर लिया है, तो दिलचस्प हिस्सा शुरू होता है।

समर्पित सर्वर कॉन्फ़िगरेशन

हमारे गेम विंडोज सर्वर 2012 के साथ वीडीएस पर होस्ट किए गए हैं। इससे हम कई निष्कर्ष निकाल सकते हैं:

1. इस पर कोई डॉकटर नहीं है, जो मेरे दिल पर लगा
2. हम किराए पर बचत करते हैं

कार्य Linux पर VPS से VDS पर एक प्रक्रिया चलाना है। मैंने फ्लास्क में एक साधारण सर्वर लिखा। हां, मुझे पायथन पसंद नहीं है, लेकिन आप क्या कर सकते हैं? इस सर्वर पर इस सर्वर को लिखना तेज़ और आसान है।

यह 3 कार्य करता है:

1. एक कॉन्फ़िगरेशन के साथ एक सर्वर शुरू करना - एक मानचित्र का चयन करना, गेम शुरू करने के लिए खिलाड़ियों की संख्या और प्लगइन्स का एक सेट। मैं अब प्लगइन्स के बारे में नहीं लिखूंगा - रात में आंसुओं और फटे बालों के साथ मिली लीटर कॉफी की यह एक अलग कहानी है।
2. असफल कनेक्शन के मामले में सर्वर को रोकना/पुनः आरंभ करना, जिसे हम केवल मैन्युअल रूप से संभाल सकते हैं।

यहां सब कुछ सरल है, कोड उदाहरण भी उपयुक्त नहीं हैं। 100 लाइन की स्क्रिप्ट

इसलिए, जब 10 लोग एकत्र हुए और गेम स्वीकार किया, तो सर्वर लॉन्च हुआ और हर कोई खेलने के लिए उत्सुक था, गेम से जुड़ने के लिए एक लिंक निजी संदेशों में भेजा गया था।

लिंक पर क्लिक करके, प्लेयर गेम सर्वर से कनेक्ट हो जाता है और बस इतना ही। ~25 मिनट के बाद, खिलाड़ियों वाला आभासी "कमरा" साफ़ हो जाता है।

मैं लेख की अजीबता के लिए पहले से माफी मांगता हूं, मैंने यहां लंबे समय से नहीं लिखा है, और महत्वपूर्ण अनुभागों को उजागर करने के लिए बहुत अधिक कोड है। नूडल्स, संक्षेप में।

यदि मुझे विषय में रुचि दिखाई देती है, तो दूसरा भाग होगा - इसमें srcds (स्रोत समर्पित सर्वर) के लिए प्लगइन्स के साथ मेरी पीड़ा शामिल होगी, और, शायद, एक रेटिंग प्रणाली और मिनी-डॉटबफ, गेम आंकड़ों वाली एक साइट होगी।

कुछ लिंक:

1. हमारी वेबसाइट (सांख्यिकी, लीडरबोर्ड, छोटा लैंडिंग पृष्ठ और क्लाइंट डाउनलोड)
2. कलह सर्वर

स्रोत: www.habr.com