ਅਸੀਂ ਡੋਟਾ 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) ਇਹ ਗੇਟਵੇ ਰੂਮਸਰਵਿਸ 'ਤੇ ਜਾਂਦਾ ਹੈ ਅਤੇ ਕਹਿੰਦਾ ਹੈ ਕਿ "ਡਿਸਕੋਰਡ ਤੋਂ ਇੱਕ ਉਪਭੋਗਤਾ ਕਤਾਰ ਵਿੱਚ ਦਾਖਲ ਹੋਣਾ ਚਾਹੁੰਦਾ ਹੈ, ਮੋਡ: ਅਨਰੇਟਿਡ ਗੇਮ।"

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. ਅਸੀਂ ਕਿਰਾਏ 'ਤੇ ਬਚਤ ਕਰਦੇ ਹਾਂ

ਕੰਮ ਲੀਨਕਸ ਉੱਤੇ ਇੱਕ VPS ਤੋਂ VDS ਉੱਤੇ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਚਲਾਉਣਾ ਹੈ। ਮੈਂ ਫਲਾਸਕ ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਸਰਵਰ ਲਿਖਿਆ. ਹਾਂ, ਮੈਨੂੰ ਪਾਈਥਨ ਪਸੰਦ ਨਹੀਂ ਹੈ, ਪਰ ਮੈਂ ਕੀ ਕਰ ਸਕਦਾ ਹਾਂ? ਇਸ ਸਰਵਰ ਨੂੰ ਇਸ 'ਤੇ ਲਿਖਣਾ ਤੇਜ਼ ਅਤੇ ਆਸਾਨ ਹੈ।

ਇਹ 3 ਫੰਕਸ਼ਨ ਕਰਦਾ ਹੈ:

1. ਇੱਕ ਸੰਰਚਨਾ ਦੇ ਨਾਲ ਇੱਕ ਸਰਵਰ ਸ਼ੁਰੂ ਕਰਨਾ - ਇੱਕ ਨਕਸ਼ਾ ਚੁਣਨਾ, ਗੇਮ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਖਿਡਾਰੀਆਂ ਦੀ ਗਿਣਤੀ, ਅਤੇ ਪਲੱਗਇਨਾਂ ਦਾ ਇੱਕ ਸੈੱਟ। ਮੈਂ ਹੁਣ ਪਲੱਗਇਨਾਂ ਬਾਰੇ ਨਹੀਂ ਲਿਖਾਂਗਾ - ਇਹ ਰਾਤ ਨੂੰ ਹੰਝੂਆਂ ਅਤੇ ਫਟੇ ਵਾਲਾਂ ਨਾਲ ਲੀਟਰ ਕੌਫੀ ਦੇ ਨਾਲ ਇੱਕ ਵੱਖਰੀ ਕਹਾਣੀ ਹੈ।
2. ਅਸਫ਼ਲ ਕੁਨੈਕਸ਼ਨਾਂ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਸਰਵਰ ਨੂੰ ਰੋਕਣਾ/ਮੁੜ ਚਾਲੂ ਕਰਨਾ, ਜਿਸ ਨੂੰ ਅਸੀਂ ਸਿਰਫ਼ ਹੱਥੀਂ ਸੰਭਾਲ ਸਕਦੇ ਹਾਂ।

ਇੱਥੇ ਸਭ ਕੁਝ ਸਧਾਰਨ ਹੈ, ਕੋਡ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਵੀ ਉਚਿਤ ਨਹੀਂ ਹਨ। 100 ਲਾਈਨ ਸਕ੍ਰਿਪਟ

ਇਸ ਲਈ, ਜਦੋਂ 10 ਲੋਕਾਂ ਨੇ ਇਕੱਠੇ ਹੋ ਕੇ ਗੇਮ ਨੂੰ ਸਵੀਕਾਰ ਕੀਤਾ, ਸਰਵਰ ਲਾਂਚ ਕੀਤਾ ਗਿਆ ਅਤੇ ਹਰ ਕੋਈ ਖੇਡਣ ਲਈ ਉਤਸੁਕ ਸੀ, ਨਿੱਜੀ ਸੰਦੇਸ਼ਾਂ ਵਿੱਚ ਗੇਮ ਨਾਲ ਜੁੜਨ ਲਈ ਇੱਕ ਲਿੰਕ ਭੇਜਿਆ ਗਿਆ।

ਲਿੰਕ 'ਤੇ ਕਲਿੱਕ ਕਰਨ ਨਾਲ, ਖਿਡਾਰੀ ਗੇਮ ਸਰਵਰ ਨਾਲ ਜੁੜਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਇਹ ਹੋ ਗਿਆ। ~25 ਮਿੰਟਾਂ ਬਾਅਦ, ਖਿਡਾਰੀਆਂ ਵਾਲਾ ਵਰਚੁਅਲ “ਕਮਰਾ” ਸਾਫ਼ ਹੋ ਜਾਂਦਾ ਹੈ।

ਮੈਂ ਲੇਖ ਦੀ ਅਜੀਬਤਾ ਲਈ ਪਹਿਲਾਂ ਤੋਂ ਮੁਆਫੀ ਮੰਗਦਾ ਹਾਂ, ਮੈਂ ਇੱਥੇ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਨਹੀਂ ਲਿਖਿਆ ਹੈ, ਅਤੇ ਮਹੱਤਵਪੂਰਨ ਭਾਗਾਂ ਨੂੰ ਉਜਾਗਰ ਕਰਨ ਲਈ ਬਹੁਤ ਜ਼ਿਆਦਾ ਕੋਡ ਹੈ। ਨੂਡਲਜ਼, ਸੰਖੇਪ ਵਿੱਚ.

ਜੇ ਮੈਂ ਵਿਸ਼ੇ ਵਿੱਚ ਦਿਲਚਸਪੀ ਵੇਖਦਾ ਹਾਂ, ਤਾਂ ਇੱਕ ਦੂਜਾ ਭਾਗ ਹੋਵੇਗਾ - ਇਸ ਵਿੱਚ srcds (ਸਰੋਤ ਸਮਰਪਿਤ ਸਰਵਰ) ਲਈ ਪਲੱਗਇਨਾਂ ਦੇ ਨਾਲ ਮੇਰੀ ਤਸੀਹੇ ਸ਼ਾਮਲ ਹੋਣਗੇ, ਅਤੇ, ਸੰਭਵ ਤੌਰ 'ਤੇ, ਇੱਕ ਰੇਟਿੰਗ ਸਿਸਟਮ ਅਤੇ ਮਿੰਨੀ-ਡੋਟਾਬਫ, ਗੇਮ ਦੇ ਅੰਕੜਿਆਂ ਵਾਲੀ ਇੱਕ ਸਾਈਟ.

ਕੁਝ ਲਿੰਕ:

1. ਸਾਡੀ ਵੈੱਬਸਾਈਟ (ਅੰਕੜੇ, ਲੀਡਰਬੋਰਡ, ਛੋਟਾ ਲੈਂਡਿੰਗ ਪੰਨਾ ਅਤੇ ਕਲਾਇੰਟ ਡਾਊਨਲੋਡ)
2. ਡਿਸਕਾਰਡ ਸਰਵਰ

ਸਰੋਤ: www.habr.com