ಎಲ್ಲರಿಗೂ ನಮಸ್ಕಾರ.
ಈ ವಸಂತಕಾಲದಲ್ಲಿ ನಾನು ಒಂದು ಯೋಜನೆಯನ್ನು ನೋಡಿದೆ, ಅದರಲ್ಲಿ ಹುಡುಗರು 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) ಹುಡುಕಾಟವನ್ನು ಪ್ರಾರಂಭಿಸಲು, ಅವನು 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) ಆದ್ದರಿಂದ ನಾವು "ಉನ್ನತ" ಅಧಿಕಾರವನ್ನು ಪಡೆದುಕೊಂಡಿದ್ದೇವೆ - ವರ್ಗ ಬಾಟ್. ಸಾಮಾನ್ಯವಾಗಿ, ಅವರು ಗೇಟ್ವೇಗಳ ನಡುವಿನ ಸಂಪರ್ಕದೊಂದಿಗೆ ವ್ಯವಹರಿಸುತ್ತಾರೆ (ರಷ್ಯನ್ ಭಾಷೆಯಲ್ಲಿ ಅದು ಎಷ್ಟು ತಮಾಷೆಯಾಗಿ ಕಾಣುತ್ತದೆ ಎಂಬುದನ್ನು ನಾನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲ) ಮತ್ತು ಮ್ಯಾಚ್ಮೇಕಿಂಗ್ನ ವ್ಯವಹಾರ ತರ್ಕ. ಬೋಟ್ ಈವೆಂಟ್ ಅನ್ನು ಕೇಳುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಾ ಬಳಕೆದಾರರಿಗೆ ಸಿದ್ಧತೆ ಪರಿಶೀಲನೆಯನ್ನು ಕಳುಹಿಸಲು ಡಿಸ್ಕಾರ್ಡ್‌ಗೇಟ್‌ವೇಗೆ ಆದೇಶಿಸುತ್ತದೆ.
8) ಯಾರಾದರೂ 3 ನಿಮಿಷಗಳಲ್ಲಿ ಆಟವನ್ನು ತಿರಸ್ಕರಿಸಿದರೆ ಅಥವಾ ಸ್ವೀಕರಿಸದಿದ್ದರೆ, ನಾವು ಅವರನ್ನು ಸರತಿ ಸಾಲಿನಲ್ಲಿ ಹಿಂತಿರುಗಿಸುವುದಿಲ್ಲ. ನಾವು ಎಲ್ಲರನ್ನು ಸರದಿಯಲ್ಲಿ ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ ಮತ್ತು ಮತ್ತೆ 10 ಜನರು ಬರುವವರೆಗೆ ಕಾಯುತ್ತೇವೆ. ಎಲ್ಲಾ ಆಟಗಾರರು ಆಟವನ್ನು ಒಪ್ಪಿಕೊಂಡರೆ, ಆಸಕ್ತಿದಾಯಕ ಭಾಗವು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.
ಮೀಸಲಾದ ಸರ್ವರ್ ಕಾನ್ಫಿಗರೇಶನ್
ನಮ್ಮ ಆಟಗಳನ್ನು ವಿಂಡೋಸ್ ಸರ್ವರ್ 2012 ನೊಂದಿಗೆ VDS ನಲ್ಲಿ ಹೋಸ್ಟ್ ಮಾಡಲಾಗಿದೆ. ಇದರಿಂದ ನಾವು ಹಲವಾರು ತೀರ್ಮಾನಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು:
- ಅದರ ಮೇಲೆ ಡಾಕರ್ ಇಲ್ಲ, ಅದು ನನ್ನ ಹೃದಯವನ್ನು ಹೊಡೆದಿದೆ
- ನಾವು ಬಾಡಿಗೆಯಲ್ಲಿ ಉಳಿಸುತ್ತೇವೆ
ಲಿನಕ್ಸ್‌ನಲ್ಲಿ VPS ನಿಂದ VDS ನಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಡೆಸುವುದು ಕಾರ್ಯವಾಗಿದೆ. ನಾನು ಫ್ಲಾಸ್ಕ್‌ನಲ್ಲಿ ಸರಳ ಸರ್ವರ್ ಅನ್ನು ಬರೆದಿದ್ದೇನೆ. ಹೌದು, ನಾನು ಪೈಥಾನ್ ಅನ್ನು ಇಷ್ಟಪಡುವುದಿಲ್ಲ, ಆದರೆ ನೀವು ಏನು ಮಾಡಬಹುದು? ಈ ಸರ್ವರ್ ಅನ್ನು ಅದರ ಮೇಲೆ ಬರೆಯಲು ಇದು ವೇಗವಾಗಿ ಮತ್ತು ಸುಲಭವಾಗಿದೆ.
ಇದು 3 ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ:
- ಕಾನ್ಫಿಗರೇಶನ್‌ನೊಂದಿಗೆ ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತಿದೆ - ನಕ್ಷೆಯನ್ನು ಆಯ್ಕೆಮಾಡುವುದು, ಆಟವನ್ನು ಪ್ರಾರಂಭಿಸಲು ಆಟಗಾರರ ಸಂಖ್ಯೆ ಮತ್ತು ಪ್ಲಗಿನ್‌ಗಳ ಸೆಟ್. ನಾನು ಈಗ ಪ್ಲಗ್‌ಇನ್‌ಗಳ ಬಗ್ಗೆ ಬರೆಯುವುದಿಲ್ಲ - ಅದು ಕಣ್ಣೀರು ಮತ್ತು ಹರಿದ ಕೂದಲಿನೊಂದಿಗೆ ರಾತ್ರಿಯಲ್ಲಿ ಲೀಟರ್‌ಗಟ್ಟಲೆ ಕಾಫಿಯೊಂದಿಗೆ ವಿಭಿನ್ನ ಕಥೆಯಾಗಿದೆ.
- ವಿಫಲವಾದ ಸಂಪರ್ಕಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಸರ್ವರ್ ಅನ್ನು ನಿಲ್ಲಿಸುವುದು/ಮರುಪ್ರಾರಂಭಿಸುವುದು, ಅದನ್ನು ನಾವು ಹಸ್ತಚಾಲಿತವಾಗಿ ಮಾತ್ರ ನಿರ್ವಹಿಸಬಹುದು.
ಇಲ್ಲಿ ಎಲ್ಲವೂ ಸರಳವಾಗಿದೆ, ಕೋಡ್ ಉದಾಹರಣೆಗಳು ಸಹ ಸೂಕ್ತವಲ್ಲ. 100 ಸಾಲಿನ ಸ್ಕ್ರಿಪ್ಟ್
ಹೀಗಾಗಿ 10 ಜನ ಸೇರಿ ಗೇಮ್ ಒಪ್ಪಿಕೊಂಡಾಗ ಸರ್ವರ್ ಲಾಂಚ್ ಆಗಿದ್ದು, ಎಲ್ಲರೂ ಆಟವಾಡಲು ಉತ್ಸುಕರಾಗಿ, ಗೇಮ್ ಗೆ ಸಂಪರ್ಕ ಕಲ್ಪಿಸುವ ಲಿಂಕ್ ಅನ್ನು ಖಾಸಗಿ ಸಂದೇಶಗಳಲ್ಲಿ ಕಳುಹಿಸಲಾಗಿದೆ.
ಲಿಂಕ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡುವ ಮೂಲಕ, ಆಟಗಾರನು ಆಟದ ಸರ್ವರ್‌ಗೆ ಸಂಪರ್ಕಿಸುತ್ತಾನೆ, ಮತ್ತು ಅದು ಇಲ್ಲಿದೆ. ~ 25 ನಿಮಿಷಗಳ ನಂತರ, ಆಟಗಾರರೊಂದಿಗೆ ವರ್ಚುವಲ್ "ರೂಮ್" ಅನ್ನು ತೆರವುಗೊಳಿಸಲಾಗಿದೆ.
ಲೇಖನದ ವಿಚಿತ್ರತೆಗಾಗಿ ನಾನು ಮುಂಚಿತವಾಗಿ ಕ್ಷಮೆಯಾಚಿಸುತ್ತೇನೆ, ನಾನು ಇಲ್ಲಿ ದೀರ್ಘಕಾಲ ಬರೆದಿಲ್ಲ, ಮತ್ತು ಪ್ರಮುಖ ವಿಭಾಗಗಳನ್ನು ಹೈಲೈಟ್ ಮಾಡಲು ತುಂಬಾ ಕೋಡ್ ಇದೆ. ನೂಡಲ್ಸ್, ಸಂಕ್ಷಿಪ್ತವಾಗಿ.
ನಾನು ವಿಷಯದ ಬಗ್ಗೆ ಆಸಕ್ತಿಯನ್ನು ನೋಡಿದರೆ, ಎರಡನೇ ಭಾಗವಿರುತ್ತದೆ - ಇದು srcds (ಮೂಲ ಮೀಸಲಾದ ಸರ್ವರ್) ಗಾಗಿ ಪ್ಲಗಿನ್‌ಗಳೊಂದಿಗೆ ನನ್ನ ಹಿಂಸೆಯನ್ನು ಹೊಂದಿರುತ್ತದೆ ಮತ್ತು ಬಹುಶಃ ರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಮತ್ತು ಮಿನಿ-ಡೋಟಾಬಫ್, ಆಟದ ಅಂಕಿಅಂಶಗಳೊಂದಿಗೆ ಸೈಟ್.
ಕೆಲವು ಲಿಂಕ್‌ಗಳು:
ಮೂಲ: www.habr.com