LibAcc: 0.7232=81/112, ProjAcc: 1.0000=0/0, Missing: 265
Module: src/Utils
function 𝓟1{registerGracefulShutdown} (𝓟2{callback}): (𝓟3: [miss]𝓛[ty]10033{Void})
{
let 𝓟4{calledOnce}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
function 𝓟5{$Lambda35} (𝓟6{signal}): (𝓟7: [miss]𝓛[ty]10033{Void})
{
function 𝓟8{$Lambda36} (): (𝓟9: [OOV]any)
{
return 𝓟9 = 𝓟2{callback}(𝓟6{signal})
}
𝓛1{<UNKNOWN>}(𝓟6{signal},𝓟8{$Lambda36})
}
𝓛8757{Array}(𝓛8743{String},𝓛8743{String},𝓛8743{String}).forEach(𝓟5{$Lambda35})
}
function 𝓟10{CONSTRUCTOR} (): (𝓟[ty]18{Deferred})
{
const 𝓟[ty]18{Deferred};
const 𝓟[ty]18{Deferred};
function 𝓟14{$Lambda37} (𝓟15{resolve},𝓟16{reject}): (𝓟17: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]18{Deferred}.resolve ⟵ 𝓟15{resolve};
𝓟[ty]18{Deferred}.reject ⟵ 𝓟16{reject};
}
𝓟[ty]18{Deferred}.promise ⟵ 𝓛1062{Promise}.CONSTRUCTOR(𝓟14{$Lambda37});
}
class 𝓟[ty]18{Deferred}{
𝓟20{promise}: 𝓛[ty]8654{Promise};
𝓟21{reject}: 𝓛[ty]8696{Function};
𝓟22{resolve}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8696{Function});
function 𝓟23{then} (𝓟24{func}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8696{Function})): (𝓟25: [miss]𝓛[ty]8654{Promise})
{
return 𝓟25 = 𝓟[ty]18{Deferred}.promise.then(𝓟24{func})
}
function 𝓟26{catch} (𝓟27{func}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟28: [miss]𝓛[ty]8654{Promise})
{
return 𝓟28 = 𝓟[ty]18{Deferred}.promise.catch(𝓟27{func})
}
}
function 𝓟29{spliceOne} (𝓟30{arr}: 𝓛[ty]8670{Array},𝓟31{index}: 𝓛[ty]8655{Number}): (𝓟32: 𝓛[ty]8666{Boolean})
{
if (𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟31{index},𝓛12616{MinusToken}(𝓛8745{Number})),𝓛12596{GreaterThanEqualsToken}(𝓟31{index},𝓟30{arr}.length)))
{
return 𝓟32 = 𝓛8744{Boolean}
}
{
let 𝓟33{i}: [miss]𝓛[ty]8655{Number} = 𝓟31{index};
let 𝓟34{len}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓟30{arr}.length,𝓛8745{Number});
while (𝓛1{<UNKNOWN>}(𝓟33{i},𝓟34{len}))
{
{
𝓟30{arr}.access(𝓟33{i}) ⟵ 𝓟30{arr}.access(𝓛12641{PlusToken}(𝓟33{i},𝓛8745{Number}));
}
𝓛12556{POST_PlusPlusToken}(𝓟33{i})
}
}
𝓟30{arr}.length ⟵ 𝓟40{len};
return 𝓟32 = 𝓛8744{Boolean}
}
function 𝓟35{merge} (𝓟36{a}: [OOV]any,𝓟37{objs}: 𝓛[ty]8670{Array}): (𝓟38: [OOV]any)
{
{
let 𝓟39{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
let 𝓟40{len}: [miss]𝓛[ty]8655{Number} = 𝓟37{objs}.length;
while (𝓛1{<UNKNOWN>}(𝓟39{i},𝓟40{len}))
{
{
let 𝓟41{b} = 𝓟37{objs}.access(𝓟39{i});
{
let 𝓟42{key}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟41{b});
while (𝓛8744{Boolean})
{
if (𝓟41{b}.hasOwnProperty(𝓟42{key}))
{
𝓟36{a}.access(𝓟42{key}) ⟵ 𝓟41{b}.access(𝓟42{key});
}
}
}
}
𝓛12556{POST_PlusPlusToken}(𝓟39{i})
}
}
return 𝓟38 = 𝓟36{a}
}
function 𝓟43{logError} (𝓟44{err}: (𝓛[ty]10051{String} ≠ 𝓛[ty]10053{Error})): (𝓟45: 𝓛[ty]10033{Void})
{
if (𝓟44{err})
{
𝓛1{<UNKNOWN>}(𝓟44{err})
}
}
Module: src/index
type 𝓟[ty]46{Client} = any
type 𝓟[ty]47{EntityMap} = {access: (𝓛[ty]10051{String})->any}
function 𝓟48{generateId} (): (𝓟49: [OOV]any)
{
return 𝓟49 = 𝓛1{<UNKNOWN>}()
}
function 𝓟50{isValidId} (𝓟51{id}: [OOV]any): (𝓟52: [OOV]any)
{
return 𝓟52 = 𝓛1{<UNKNOWN>}(𝓟51{id})
}
Module: src/Room
function 𝓟53{CONSTRUCTOR} (): (𝓟[ty]57{Room})
{
const 𝓟[ty]57{Room};
const 𝓟[ty]57{Room};
𝓟[ty]57{Room}.autoDispose ⟵ 𝓛8744{Boolean};
𝓟[ty]57{Room}.clients ⟵ 𝓛8757{Array}();
𝓟[ty]57{Room}.clock ⟵ 𝓟757{Clock}.CONSTRUCTOR();
𝓟[ty]57{Room}.connectingClients ⟵ {};
𝓟[ty]57{Room}.maxClients ⟵ 𝓛8706{Infinity};
𝓟[ty]57{Room}.patchRate ⟵ 𝓛12573{SlashToken}(𝓛8745{Number},𝓛8745{Number});
𝓟[ty]57{Room}()
if (𝓛12595{GreaterThanToken}(𝓛10035{arguments}.length,𝓛8745{Number}))
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
}
𝓟[ty]57{Room}.setPatchRate(𝓟[ty]57{Room}.patchRate)
}
class 𝓟[ty]57{Room} extends 𝓛[ty]6152{EventEmitter}{
𝓟59{roomId}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10051{String});
𝓟60{state}: [OOV]any;
𝓟61{clients}: 𝓛[ty]8670{Array};
𝓟62{_previousStateEncoded}: [OOV]any;
𝓟63{connectingClients}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8642{Object});
𝓟64{_simulationInterval}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10129{Timer});
𝓟65{autoDispose}: 𝓛[ty]8666{Boolean};
𝓟66{patchRate}: 𝓛[ty]8655{Number};
𝓟67{_patchInterval}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10129{Timer});
𝓟68{clock}: [OOV]𝓛[ty]2{<UNKNOWN>};
𝓟69{timeline}: [OOV]𝓛[ty]2{<UNKNOWN>};
𝓟70{_previousState}: [OOV]any;
𝓟71{roomName}: 𝓛[ty]10051{String};
𝓟72{maxClients}: 𝓛[ty]8655{Number};
function 𝓟93{verifyClient} (𝓟94{client}: [OOV]𝓟[ty]46{Client},𝓟95{options}: [OOV]any): (𝓟96: [OOV]any)
{
return 𝓟96 = 𝓛1062{Promise}.resolve(𝓛8744{Boolean})
}
function 𝓟105{setPatchRate} (𝓟106{milliseconds}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟107: 𝓛[ty]10033{Void})
{
if (𝓟[ty]57{Room}._patchInterval)
{
𝓛12462{clearInterval}(𝓟[ty]57{Room}._patchInterval)
}
𝓟[ty]57{Room}._patchInterval ⟵ 𝓛12485{setInterval}(𝓟[ty]57{Room}.broadcastPatch.bind(𝓟[ty]57{Room}),𝓟106{milliseconds});
}
function 𝓟126{disconnect} (): (𝓟127: 𝓛[ty]8654{Promise})
{
let 𝓟128{promises}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}();
let 𝓟129{i}: [miss]𝓛[ty]8655{Number} = 𝓟[ty]57{Room}.clients.length;
while (𝓛12614{POST_MinusMinusToken}(𝓟129{i}))
{
𝓟128{promises}.push(𝓟[ty]57{Room}._onLeave(𝓟[ty]57{Room}.clients.access(𝓟129{i})))
}
return 𝓟127 = 𝓛1062{Promise}.all(𝓟128{promises})
}
function 𝓟149{_dispose} (): (𝓟150: (𝓛[ty]10051{String} ≠ 𝓛[ty]8654{Promise}))
{
let 𝓟151{userReturnData};
if (𝓟[ty]57{Room}.onDispose)
{
𝓟151{userReturnData} ⟵ 𝓟[ty]57{Room}.onDispose();
}
if (𝓟[ty]57{Room}._patchInterval)
{
𝓛12462{clearInterval}(𝓟[ty]57{Room}._patchInterval)
}
if (𝓟[ty]57{Room}._simulationInterval)
{
𝓛12462{clearInterval}(𝓟[ty]57{Room}._simulationInterval)
}
𝓟[ty]57{Room}.clock.clear()
𝓟[ty]57{Room}.clock.stop()
return 𝓟150 = 𝓛12546{BarBarToken}(𝓟151{userReturnData},𝓛1062{Promise}.resolve())
}
function 𝓟108{useTimeline} (𝓟109{maxSnapshots}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟110: 𝓛[ty]10033{Void})
{
𝓟[ty]57{Room}.timeline ⟵ 𝓟758{createTimeline}(𝓟109{maxSnapshots});
}
function 𝓟111{setState} (𝓟112{newState}): (𝓟113: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]57{Room}.clock.start()
𝓟[ty]57{Room}._previousState ⟵ 𝓟112{newState};
𝓟[ty]57{Room}._previousStateEncoded ⟵ 𝓛1{<UNKNOWN>}(𝓟[ty]57{Room}._previousState);
𝓟[ty]57{Room}.state ⟵ 𝓟112{newState};
if (𝓟[ty]57{Room}.timeline)
{
𝓟[ty]57{Room}.timeline.takeSnapshot(𝓟[ty]57{Room}.state)
}
}
function 𝓟73{onInit} (𝓟74{options}: [OOV]any): (𝓟75: 𝓛[ty]10033{Void})
{
}
function 𝓟130{sendState} (𝓟131{client}: [OOV]𝓟[ty]46{Client}): (𝓟132: 𝓛[ty]10033{Void})
{
𝓟225{send}(𝓟131{client},𝓛8757{Array}(𝓟221{Protocol}.ROOM_STATE,𝓟[ty]57{Room}.roomId,𝓟[ty]57{Room}._previousStateEncoded,𝓟[ty]57{Room}.clock.currentTime,𝓟[ty]57{Room}.clock.elapsedTime))
}
function 𝓟84{onLeave} (𝓟85{client}: [OOV]𝓟[ty]46{Client}): (𝓟86: [OOV]any)
{
}
function 𝓟142{_onLeave} (𝓟143{client}: [OOV]𝓟[ty]46{Client},𝓟144{isDisconnect}: 𝓛[ty]8666{Boolean}): (𝓟145: [OOV]any)
{
let 𝓟146{userReturnData};
if (𝓛12592{AmpersandAmpersandToken}(𝓟29{spliceOne}(𝓟[ty]57{Room}.clients,𝓟[ty]57{Room}.clients.indexOf(𝓟143{client})),𝓟[ty]57{Room}.onLeave))
{
𝓟146{userReturnData} ⟵ 𝓟[ty]57{Room}.onLeave(𝓟143{client});
}
𝓟[ty]57{Room}.emit(𝓛8743{String},𝓟143{client},𝓟144{isDisconnect})
if (𝓛12569{ExclamationToken}(𝓟144{isDisconnect}))
{
𝓟225{send}(𝓟143{client},𝓛8757{Array}(𝓟221{Protocol}.LEAVE_ROOM,𝓟[ty]57{Room}.roomId))
}
if (𝓟[ty]57{Room}.autoDispose)
{
𝓟[ty]57{Room}._disposeIfEmpty()
}
return 𝓟145 = 𝓛12546{BarBarToken}(𝓟146{userReturnData},𝓛1062{Promise}.resolve())
}
function 𝓟114{lock} (): (𝓟115: 𝓛[ty]10033{Void})
{
𝓟[ty]57{Room}.emit(𝓛8743{String})
}
function 𝓟97{maxClientsReached} (): (𝓟98)
{
return 𝓟98 = 𝓛12596{GreaterThanEqualsToken}(𝓛12641{PlusToken}(𝓟[ty]57{Room}.clients.length,𝓛8741{Object}.keys(𝓟[ty]57{Room}.connectingClients).length),𝓟[ty]57{Room}.maxClients)
}
function 𝓟116{unlock} (): (𝓟117: 𝓛[ty]10033{Void})
{
𝓟[ty]57{Room}.emit(𝓛8743{String})
}
function 𝓟122{broadcast} (𝓟123{data}: [OOV]any): (𝓟124: 𝓛[ty]8666{Boolean})
{
if (𝓛12569{ExclamationToken}(𝓟123{data}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟123{data},𝓛10100{Buffer})))
{
𝓟123{data} ⟵ 𝓛1{<UNKNOWN>}(𝓛8757{Array}(𝓟221{Protocol}.ROOM_DATA,𝓟[ty]57{Room}.roomId,𝓟123{data}));
}
let 𝓟125{numClients}: [miss]𝓛[ty]8655{Number} = 𝓟[ty]57{Room}.clients.length;
while (𝓛12614{POST_MinusMinusToken}(𝓟125{numClients}))
{
𝓟[ty]57{Room}.clients.access(𝓟125{numClients}).send(𝓟123{data},{binary: 𝓛8744{Boolean}},𝓟43{logError}.bind(𝓟[ty]57{Room}))
}
return 𝓟124 = 𝓛8744{Boolean}
}
function 𝓟99{setSimulationInterval} (𝓟100{callback}: 𝓛[ty]8696{Function},𝓟101{delay}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟102: 𝓛[ty]10033{Void})
{
if (𝓟[ty]57{Room}._simulationInterval)
{
𝓛12462{clearInterval}(𝓟[ty]57{Room}._simulationInterval)
}
function 𝓟103{$Lambda26} (): (𝓟104: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]57{Room}.clock.tick()
𝓟100{callback}()
}
𝓟[ty]57{Room}._simulationInterval ⟵ 𝓛12485{setInterval}(𝓟103{$Lambda26},𝓟101{delay});
}
function 𝓟138{_onJoin} (𝓟139{client}: [OOV]𝓟[ty]46{Client},𝓟140{options}: [OOV]any): (𝓟141: 𝓛[ty]10033{Void})
{
𝓟[ty]57{Room}.clients.push(𝓟139{client})
𝓟225{send}(𝓟139{client},𝓛8757{Array}(𝓟221{Protocol}.JOIN_ROOM,𝓟139{client}.sessionId))
if (𝓟[ty]57{Room}.state)
{
𝓟[ty]57{Room}.sendState(𝓟139{client})
}
if (𝓟[ty]57{Room}.onJoin)
{
𝓟[ty]57{Room}.onJoin(𝓟139{client},𝓟140{options})
}
}
function 𝓟87{onDispose} (): (𝓟88: [OOV]any)
{
}
function 𝓟89{requestJoin} (𝓟90{options}: [OOV]any,𝓟91{isNew}: 𝓛[ty]8666{Boolean}): (𝓟92: [OOV]any)
{
return 𝓟92 = 𝓛8745{Number}
}
function 𝓟133{broadcastPatch} (): (𝓟134: 𝓛[ty]8666{Boolean})
{
if (𝓛12569{ExclamationToken}(𝓟[ty]57{Room}._previousState))
{
𝓟218{debugPatch}(𝓛8743{String})
return 𝓟134 = 𝓛8744{Boolean}
}
let 𝓟135{currentState}: [OOV]any = 𝓟[ty]57{Room}.state;
let 𝓟136{currentStateEncoded} = 𝓛1{<UNKNOWN>}(𝓟135{currentState});
if (𝓟136{currentStateEncoded}.equals(𝓟[ty]57{Room}._previousStateEncoded))
{
return 𝓟134 = 𝓛8744{Boolean}
}
let 𝓟137{patches} = 𝓛1{<UNKNOWN>}(𝓟[ty]57{Room}._previousStateEncoded,𝓟136{currentStateEncoded});
if (𝓟[ty]57{Room}.timeline)
{
𝓟[ty]57{Room}.timeline.takeSnapshot(𝓟[ty]57{Room}.state,𝓟[ty]57{Room}.clock.elapsedTime)
}
if (𝓟218{debugPatch}.enabled)
{
𝓟218{debugPatch}(𝓛8743{String},𝓟[ty]57{Room}.roomName,𝓟[ty]57{Room}.roomId,𝓟137{patches}.length)
}
if (𝓟219{debugPatchData}.enabled)
{
𝓟219{debugPatchData}(𝓛1{<UNKNOWN>}(𝓟[ty]57{Room}._previousState,𝓟135{currentState}))
}
𝓟[ty]57{Room}._previousState ⟵ 𝓟135{currentState};
𝓟[ty]57{Room}._previousStateEncoded ⟵ 𝓟136{currentStateEncoded};
return 𝓟134 = 𝓟[ty]57{Room}.broadcast(𝓛1{<UNKNOWN>}(𝓛8757{Array}(𝓟221{Protocol}.ROOM_STATE_PATCH,𝓟[ty]57{Room}.roomId,𝓟137{patches})))
}
function 𝓟76{onMessage} (𝓟77{client}: [OOV]𝓟[ty]46{Client},𝓟78{data}: [OOV]any): (𝓟79: 𝓛[ty]10033{Void})
{
}
function 𝓟147{_disposeIfEmpty} (): (𝓟148: [miss]𝓛[ty]10033{Void})
{
if (𝓛12599{EqualsEqualsToken}(𝓟[ty]57{Room}.clients.length,𝓛8745{Number}))
{
𝓟[ty]57{Room}._dispose()
𝓟[ty]57{Room}.emit(𝓛8743{String})
}
}
function 𝓟80{onJoin} (𝓟81{client}: [OOV]𝓟[ty]46{Client},𝓟82{options}: [OOV]any): (𝓟83: [OOV]any)
{
}
function 𝓟118{send} (𝓟119{client}: [OOV]𝓟[ty]46{Client},𝓟120{data}: [OOV]any): (𝓟121: 𝓛[ty]10033{Void})
{
𝓟225{send}(𝓟119{client},𝓛8757{Array}(𝓟221{Protocol}.ROOM_DATA,𝓟[ty]57{Room}.roomId,𝓟120{data}))
}
}
Module: src/cluster/Worker
function 𝓟152{setUserId} (𝓟153{client}: [OOV]𝓟[ty]46{Client}): (𝓟154: [miss]𝓛[ty]10033{Void})
{
let 𝓟155{url} = 𝓟153{client}.upgradeReq as any.url;
𝓟153{client}.id ⟵ 𝓛12546{BarBarToken}(𝓛1{<UNKNOWN>}.access(𝓛8743{String}),𝓟48{generateId}());
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}.access(𝓛8743{String})))
{
𝓟225{send}(𝓟153{client},𝓛8757{Array}(𝓟221{Protocol}.USER_ID,𝓟153{client}.id))
}
}
function 𝓟156{handleUpgrade} (𝓟157{server}: (𝓛[ty]10045{Buffer} ≠ 𝓛[ty]8985{Server}),𝓟158{socket}: [OOV]𝓛[ty]6501{Socket},𝓟159{message}: [OOV]any): (𝓟160: [miss]𝓛[ty]10033{Void})
{
let 𝓟161{code} = 𝓟159{message}.access(𝓛8745{Number});
let 𝓟162{upgradeReq}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟159{message}.access(𝓛8745{Number});
let 𝓟163{head}: [OOV]any = 𝓟159{message}.access(𝓛8745{Number});
let 𝓟164{url}: [OOV]any = 𝓛12643{undefined}(𝓟159{message}.access(𝓛8745{Number}),𝓛8744{Boolean});
𝓟162{upgradeReq} as any.url ⟵ 𝓟164{url};
𝓟162{upgradeReq} as any.roomId ⟵ 𝓛1{<UNKNOWN>}.substr(𝓛8745{Number});
𝓟162{upgradeReq}.connection ⟵ 𝓟158{socket};
𝓟157{server}.emit(𝓛8743{String},𝓟162{upgradeReq},𝓟158{socket},𝓟163{head})
𝓟158{socket}.resume()
}
function 𝓟165{setupWorker} (𝓟166{server}: [OOV]𝓛[ty]6820{Server},𝓟167{matchMaker}: [OOV]𝓟[ty]316{MatchMaker}): (𝓟168: [OOV]any)
{
let 𝓟169{wss} = 𝓟214{WebSocketServer} as any.CONSTRUCTOR({server: 𝓟166{server}});
function 𝓟170{$Lambda64} (𝓟171{client}: [OOV]𝓟[ty]46{Client},𝓟172{req}: (𝓛[ty]8635{Date} ≠ 𝓛[ty]9098{IncomingMessage})): (𝓟173: [miss]𝓛[ty]10033{Void})
{
if (𝓟172{req})
{
𝓟171{client}.upgradeReq ⟵ 𝓟172{req};
}
𝓟152{setUserId}(𝓟171{client})
let 𝓟174{roomId} = 𝓟171{client}.upgradeReq as any.roomId;
𝓟167{matchMaker}.bindClient(𝓟171{client},𝓟174{roomId})
}
𝓟169{wss}.on(𝓛8743{String},𝓟170{$Lambda64})
function 𝓟175{$Lambda65} (𝓟176{message},𝓟177{socket}): (𝓟178: [miss]𝓛[ty]10033{Void})
{
let 𝓟179{roomNameOrId} = 𝓟176{message}.access(𝓛8745{Number});
let 𝓟180{joinOptions} = 𝓟176{message}.access(𝓛8745{Number});
let 𝓟181{allowCreateRoom}: [miss]𝓛[ty]8666{Boolean} = 𝓛12559{EqualsEqualsEqualsToken}(𝓟176{message}.access(𝓛8745{Number}),𝓟221{Protocol}.CREATE_ROOM);
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟176{message}.access(𝓛8745{Number}),𝓟221{Protocol}.PASS_HTTP_SOCKET))
{
𝓟166{server}.emit(𝓛8743{String},𝓟177{socket})
let 𝓟182{request}: [OOV]any = 𝓛12643{undefined} as any.ClientRequest.CONSTRUCTOR({port: 𝓟166{server}.address().port});
𝓟182{request}.headers ⟵ 𝓟176{message}.access(𝓛8745{Number}).headers;
𝓟182{request}.method ⟵ 𝓟176{message}.access(𝓛8745{Number}).method;
𝓟182{request}.url ⟵ 𝓟176{message}.access(𝓛8745{Number}).url;
𝓟182{request}.connection ⟵ 𝓟177{socket};
𝓟182{request}._readableState ⟵ 𝓟177{socket}._readableState;
function 𝓟183{$Lambda66} (): (𝓟184: [miss]𝓛[ty]10033{Void})
{
}
𝓟182{request}._flush ⟵ 𝓟183{$Lambda66};
function 𝓟185{$Lambda67} (): (𝓟186: [miss]𝓛[ty]10033{Void})
{
}
𝓟182{request}._dump ⟵ 𝓟185{$Lambda67};
𝓟177{socket}.parser.onIncoming(𝓟182{request})
𝓟177{socket}.resume()
𝓟182{request}.emit(𝓛8743{String},𝓟176{message}.access(𝓛8745{Number}).body)
𝓟182{request}.emit(𝓛8743{String})
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟176{message}.access(𝓛8745{Number}),𝓟221{Protocol}.PASS_WEBSOCKET))
{
𝓟156{handleUpgrade}(𝓟166{server} as 𝓛[ty]8985{Server},𝓟177{socket},𝓟176{message})
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟176{message}.access(𝓛8745{Number}),𝓟221{Protocol}.REQUEST_JOIN_ROOM))
{
let 𝓟187{roomNameOrId} = 𝓟176{message}.access(𝓛8745{Number});
let 𝓟188{clientOptions} = 𝓟176{message}.access(𝓛8745{Number});
let 𝓟189{room};
let 𝓟190{roomId};
let 𝓟191{score}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
if (𝓟50{isValidId}(𝓟187{roomNameOrId}))
{
𝓟189{room} ⟵ 𝓟167{matchMaker}.joinById(𝓟187{roomNameOrId},𝓟188{clientOptions});
}
else
{
let 𝓟192{result}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟167{matchMaker}.getAvailableRoomByScore(𝓟187{roomNameOrId},𝓟188{clientOptions});
𝓟189{room} ⟵ 𝓟192{result}.room;
𝓟191{score} ⟵ 𝓟192{result}.score;
}
𝓟190{roomId} ⟵ 𝓛12592{AmpersandAmpersandToken}(𝓟189{room},𝓟189{room}.roomId);
function 𝓟193{$Lambda68} (𝓟194{matchMakingPid}): (𝓟195: [miss]𝓛[ty]10033{Void})
{
𝓟217{debugMatchMaking}(𝓛8743{String},𝓛1{<UNKNOWN>},𝓟190{roomId},𝓟191{score})
𝓛1{<UNKNOWN>}(𝓛8757{Array}(𝓟194{matchMakingPid},𝓟180{joinOptions}.clientId,𝓛1{<UNKNOWN>},𝓟190{roomId},𝓟191{score}))
}
𝓟204{getMatchMakingProcess}(𝓟193{$Lambda68})
}
else
{
if (𝓛12546{BarBarToken}(𝓟181{allowCreateRoom},𝓛12559{EqualsEqualsEqualsToken}(𝓟176{message}.access(𝓛8745{Number}),𝓟221{Protocol}.JOIN_ROOM)))
{
function 𝓟196{$Lambda69} (𝓟197{err}: 𝓛[ty]10051{String},𝓟198{room}: [OOV]𝓟[ty]57{Room}): (𝓟199: [miss]𝓛[ty]10033{Void})
{
let 𝓟200{joinRoomResponse}: [miss]𝓛[ty]8670{Array} = (𝓟197{err} ? 𝓛8757{Array}(𝓟221{Protocol}.JOIN_ERROR,𝓟179{roomNameOrId},𝓟197{err}) : 𝓛8757{Array}(𝓟221{Protocol}.JOIN_ROOM,𝓟198{room}.roomId,𝓟180{joinOptions}.requestId);
function 𝓟201{$Lambda70} (𝓟202{matchMakingPid}): (𝓟203: [miss]𝓛[ty]10033{Void})
{
𝓛1{<UNKNOWN>}(𝓛8757{Array}(𝓟202{matchMakingPid},𝓟180{joinOptions}.clientId,𝓟200{joinRoomResponse}))
}
𝓟204{getMatchMakingProcess}(𝓟201{$Lambda70})
}
𝓟167{matchMaker}.onJoinRoomRequest(𝓟179{roomNameOrId},𝓟180{joinOptions},𝓟181{allowCreateRoom},𝓟196{$Lambda69})
}
}
}
}
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟175{$Lambda65})
return 𝓟168 = 𝓟166{server}
}
function 𝓟204{getMatchMakingProcess} (𝓟205{callback}: 𝓛[ty]8696{Function}): (𝓟206: [miss]𝓛[ty]10033{Void})
{
function 𝓟207{$Lambda71} (𝓟208{err},𝓟209{matchMakingPid}): (𝓟210: [miss]𝓛[ty]10033{Void})
{
𝓟205{callback}(𝓟209{matchMakingPid})
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟207{$Lambda71})
}
Module: src/ws/index
type 𝓟[ty]211{IServerOptions} = any
type 𝓟[ty]212{WebSocketServer} = any
let 𝓟213{dep};
𝓟213{dep} ⟵ 𝓛10097{require}(𝓛8743{String});
const 𝓟214{WebSocketServer}: [OOV]𝓟[ty]212{WebSocketServer} = 𝓟213{dep}.Server;
const 𝓟215{defaultVar} = 𝓟213{dep} as any;
Module: src/Debug
const 𝓟216{debugCluster} = 𝓛12643{undefined}(𝓛8743{String});
const 𝓟217{debugMatchMaking} = 𝓛12643{undefined}(𝓛8743{String});
const 𝓟218{debugPatch} = 𝓛12643{undefined}(𝓛8743{String});
const 𝓟219{debugPatchData} = 𝓛12643{undefined}(𝓛8743{String});
Module: src/Protocol
type 𝓛[ty]8655{Number} = 𝓛[ty]8655{Number}
const 𝓟221{Protocol} = {PASS_WEBSOCKET: 𝓛8745{Number},BAD_REQUEST: 𝓛8745{Number},USER_ID: 𝓛8745{Number},CREATE_ROOM: 𝓛8745{Number},PASS_HTTP_SOCKET: 𝓛8745{Number},JOIN_ROOM: 𝓛8745{Number},ROOM_DATA: 𝓛8745{Number},REQUEST_JOIN_ROOM: 𝓛8745{Number},JOIN_ERROR: 𝓛8745{Number},ROOM_STATE_PATCH: 𝓛8745{Number},ROOM_STATE: 𝓛8745{Number},LEAVE_ROOM: 𝓛8745{Number}};
function 𝓟222{decode} (𝓟223{message}: [OOV]any): (𝓟224: [OOV]any)
{
{
𝓟223{message} ⟵ 𝓛1{<UNKNOWN>}(𝓛10100{Buffer}.from(𝓟223{message}));
}
return 𝓟224 = 𝓟223{message}
}
function 𝓟225{send} (𝓟226{client}: [OOV]𝓟[ty]46{Client},𝓟227{message}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟228: [miss]𝓛[ty]10033{Void})
{
𝓟226{client}.send(𝓛1{<UNKNOWN>}(𝓟227{message}),{binary: 𝓛8744{Boolean}})
}
Module: usage/ClusteredServer
const 𝓟229{PORT}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
let 𝓟230{gameServer}: [OOV]𝓟[ty]641{ClusterServer} = 𝓟591{CONSTRUCTOR}();
if (𝓛2126{isMaster})
{
𝓟230{gameServer}.listen(𝓟229{PORT})
𝓟230{gameServer}.fork()
function 𝓟231{$Lambda40} (): (𝓟232: [miss]𝓛[ty]8654{Promise})
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
function 𝓟233{$Lambda41} (𝓟234{resolve},𝓟235{reject}): (𝓟236: [miss]𝓛[ty]10033{Void})
{
function 𝓟237{$Lambda42} (): (𝓟238: [miss]𝓛[ty]10033{Void})
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓟234{resolve}()
}
𝓛12490{setTimeout}(𝓟237{$Lambda42},𝓛8745{Number})
}
return 𝓟232 = 𝓛1062{Promise}.CONSTRUCTOR(𝓟233{$Lambda41})
}
𝓟230{gameServer}.onShutdown(𝓟231{$Lambda40})
}
else
{
const 𝓟239{app} = 𝓛1{<UNKNOWN>}();
𝓟239{app}.use(𝓛1{<UNKNOWN>}())
function 𝓟240{$Lambda43} (): (𝓟241: [miss]𝓛[ty]10033{Void})
{
return 𝓟241 = 𝓛1{<UNKNOWN>}(𝓛8743{String})
}
𝓟239{app}.on(𝓛8743{String},𝓟240{$Lambda43})
function 𝓟242{$Lambda44} (𝓟243{req},𝓟244{res}): (𝓟245: [miss]𝓛[ty]10033{Void})
{
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓛1{<UNKNOWN>})
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓟244{res}.send(𝓛8743{String})
}
𝓟239{app}.get(𝓛8743{String},𝓟242{$Lambda44})
function 𝓟246{$Lambda45} (𝓟247{req},𝓟248{res}): (𝓟249: [miss]𝓛[ty]10033{Void})
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓟248{res}.json(𝓟247{req}.body)
}
𝓟239{app}.post(𝓛8743{String},𝓟246{$Lambda45})
function 𝓟250{$Lambda46} (𝓟251{room}): (𝓟252: [miss]𝓛[ty]10033{Void})
{
return 𝓟252 = 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟251{room}.roomId)
}
function 𝓟253{$Lambda47} (𝓟254{room},𝓟255{client}): (𝓟256: [miss]𝓛[ty]10033{Void})
{
return 𝓟256 = 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟255{client}.id,𝓛8743{String},𝓟254{room}.roomId)
}
function 𝓟257{$Lambda48} (𝓟258{room},𝓟259{client}): (𝓟260: [miss]𝓛[ty]10033{Void})
{
return 𝓟260 = 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟259{client}.id,𝓛8743{String},𝓟258{room}.roomId)
}
function 𝓟261{$Lambda49} (𝓟262{room}): (𝓟263: [miss]𝓛[ty]10033{Void})
{
return 𝓟263 = 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟262{room}.roomId)
}
𝓟230{gameServer}.register(𝓛8743{String},𝓛12643{undefined}).on(𝓛8743{String},𝓟250{$Lambda46}).on(𝓛8743{String},𝓟253{$Lambda47}).on(𝓛8743{String},𝓟257{$Lambda48}).on(𝓛8743{String},𝓟261{$Lambda49})
function 𝓟264{$Lambda50} (): (𝓟265: [miss]𝓛[ty]8654{Promise})
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
function 𝓟266{$Lambda51} (𝓟267{resolve},𝓟268{reject}): (𝓟269: [miss]𝓛[ty]10033{Void})
{
function 𝓟270{$Lambda52} (): (𝓟271: [miss]𝓛[ty]10033{Void})
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓟267{resolve}()
}
𝓛12490{setTimeout}(𝓟270{$Lambda52},𝓛8745{Number})
}
return 𝓟265 = 𝓛1062{Promise}.CONSTRUCTOR(𝓟266{$Lambda51})
}
𝓟230{gameServer}.onShutdown(𝓟264{$Lambda50})
𝓟230{gameServer}.attach({server: 𝓟239{app}})
}
𝓛1{<UNKNOWN>}(𝓛12607{$Template}(𝓟229{PORT}))
Module: usage/ChatRoom
function 𝓟272{CONSTRUCTOR} (): (𝓟[ty]276{ChatRoom})
{
const 𝓟[ty]276{ChatRoom};
const 𝓟[ty]276{ChatRoom};
}
class 𝓟[ty]276{ChatRoom} extends 𝓟[ty]57{Room}{
function 𝓟278{onInit} (𝓟279{options}): (𝓟280: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]276{ChatRoom}.setState({messages: 𝓛8757{Array}()})
}
function 𝓟285{onLeave} (𝓟286{client}): (𝓟287: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]276{ChatRoom}.state.messages.push(𝓛12607{$Template}(𝓟286{client}.id))
}
function 𝓟292{onDispose} (): (𝓟293: [miss]𝓛[ty]8654{Promise})
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
function 𝓟294{$Lambda38} (𝓟295{resolve},𝓟296{reject}): (𝓟297: [miss]𝓛[ty]10033{Void})
{
function 𝓟298{$Lambda39} (): (𝓟299: [miss]𝓛[ty]10033{Void})
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓟296{reject}()
}
𝓛12490{setTimeout}(𝓟298{$Lambda39},𝓛8745{Number})
}
return 𝓟293 = 𝓛1062{Promise}.CONSTRUCTOR(𝓟294{$Lambda38})
}
function 𝓟288{onMessage} (𝓟289{client},𝓟290{data}): (𝓟291: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]276{ChatRoom}.state.messages.push(𝓟290{data}.message)
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟290{data}.message,𝓛8743{String}))
{
𝓟[ty]276{ChatRoom}.disconnect()
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟289{client}.id,𝓟290{data})
}
function 𝓟281{onJoin} (𝓟282{client},𝓟283{options}): (𝓟284: [miss]𝓛[ty]10033{Void})
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟282{client}.id)
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟282{client}.sessionId)
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟283{options})
𝓟[ty]276{ChatRoom}.state.messages.push(𝓛12607{$Template}(𝓟282{client}.id))
}
}
Module: src/MatchMaker
type 𝓟[ty]300{RoomWithScore} = {room: 𝓟[ty]57{Room}, score: 𝓛[ty]8655{Number}}
type 𝓟[ty]301{ClientOptions} = any
function 𝓟302{CONSTRUCTOR} (𝓟303{klass}: [OOV]any,𝓟304{options}: [OOV]any): (𝓟[ty]308{RegisteredHandler})
{
const 𝓟[ty]308{RegisteredHandler};
const 𝓟[ty]308{RegisteredHandler};
𝓟[ty]308{RegisteredHandler}()
𝓟[ty]308{RegisteredHandler}.klass ⟵ 𝓟303{klass};
𝓟[ty]308{RegisteredHandler}.options ⟵ 𝓟304{options};
}
class 𝓟[ty]308{RegisteredHandler} extends 𝓛[ty]2{<UNKNOWN>}{
𝓟310{klass}: [OOV]any;
𝓟311{options}: [OOV]any;
}
function 𝓟312{CONSTRUCTOR} (): (𝓟[ty]316{MatchMaker})
{
const 𝓟[ty]316{MatchMaker};
const 𝓟[ty]316{MatchMaker};
𝓟[ty]316{MatchMaker}.roomsById ⟵ {};
𝓟[ty]316{MatchMaker}.sessions ⟵ {};
𝓟[ty]316{MatchMaker}.handlers ⟵ {};
𝓟[ty]316{MatchMaker}.availableRooms ⟵ {};
𝓟[ty]316{MatchMaker}.isGracefullyShuttingDown ⟵ 𝓛8744{Boolean};
}
class 𝓟[ty]316{MatchMaker}{
𝓟318{sessions}: 𝓛[ty]8642{Object};
𝓟319{isGracefullyShuttingDown}: 𝓛[ty]8666{Boolean};
𝓟320{handlers}: 𝓛[ty]8642{Object};
𝓟321{availableRooms}: 𝓛[ty]8642{Object};
𝓟322{roomsById}: 𝓛[ty]8642{Object};
function 𝓟343{execute} (𝓟344{client}: [OOV]𝓟[ty]46{Client},𝓟345{message}: [OOV]any): (𝓟346: [miss]𝓛[ty]10033{Void})
{
if (𝓛12599{EqualsEqualsToken}(𝓟345{message}.access(𝓛8745{Number}),𝓟221{Protocol}.JOIN_ROOM))
{
function 𝓟347{$Lambda20} (𝓟348{err}: 𝓛[ty]10051{String},𝓟349{room}: [OOV]𝓟[ty]57{Room}): (𝓟350: [miss]𝓛[ty]10033{Void})
{
if (𝓟348{err})
{
let 𝓟351{roomId} = (𝓟349{room} ? 𝓟349{room}.roomId : 𝓟345{message}.access(𝓛8745{Number});
𝓟225{send}(𝓟344{client},𝓛8757{Array}(𝓟221{Protocol}.JOIN_ERROR,𝓟351{roomId},𝓟348{err}))
}
}
𝓟[ty]316{MatchMaker}.onJoinRoomRequest(𝓟345{message}.access(𝓛8745{Number}),𝓟345{message}.access(𝓛8745{Number}),𝓛8744{Boolean},𝓟347{$Lambda20})
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓟345{message}.access(𝓛8745{Number}),𝓟221{Protocol}.ROOM_DATA))
{
let 𝓟352{room}: [OOV]𝓟[ty]57{Room} = 𝓟[ty]316{MatchMaker}.getRoomById(𝓟345{message}.access(𝓛8745{Number}));
if (𝓟352{room})
{
𝓟352{room}.onMessage(𝓟344{client},𝓟345{message}.access(𝓛8745{Number}))
}
}
else
{
𝓟[ty]316{MatchMaker}.sessions.access(𝓟344{client}.sessionId).onMessage(𝓟344{client},𝓟345{message})
}
}
}
function 𝓟444{clearRoomReferences} (𝓟445{roomName}: 𝓛[ty]10051{String},𝓟446{room}: [OOV]𝓟[ty]57{Room}): (𝓟447: 𝓛[ty]8666{Boolean})
{
let 𝓟448{hasDisposed}: 𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
if (𝓟[ty]316{MatchMaker}.hasAvailableRoom(𝓟445{roomName}))
{
let 𝓟449{roomIndex}: [miss]𝓛[ty]8655{Number} = 𝓟[ty]316{MatchMaker}.availableRooms.access(𝓟445{roomName}).indexOf(𝓟446{room});
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟449{roomIndex},𝓛12616{MinusToken}(𝓛8745{Number})))
{
𝓛1{<UNKNOWN>}(𝓛1{<UNKNOWN>}.toString())
𝓟448{hasDisposed} ⟵ 𝓛8744{Boolean};
}
𝓟29{spliceOne}(𝓟[ty]316{MatchMaker}.availableRooms.access(𝓟445{roomName}),𝓟449{roomIndex})
}
if (𝓛12569{ExclamationToken}(𝓟[ty]316{MatchMaker}.hasAvailableRoom(𝓟445{roomName})))
{
𝓛1{<UNKNOWN>}(𝓟446{room}.roomName,𝓛1{<UNKNOWN>})
}
return 𝓟447 = 𝓟448{hasDisposed}
}
function 𝓟398{hasHandler} (𝓟399{name}: 𝓛[ty]10051{String}): (𝓟400: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟400 = 𝓛12612{ExclamationEqualsEqualsToken}(𝓟[ty]316{MatchMaker}.handlers.access(𝓟399{name}),𝓛12643{undefined})
}
function 𝓟382{onLeave} (𝓟383{client}: [OOV]𝓟[ty]46{Client},𝓟384{roomId}: 𝓛[ty]10051{String}): (𝓟385: [miss]𝓛[ty]10033{Void})
{
let 𝓟386{room} = 𝓟[ty]316{MatchMaker}.roomsById.access(𝓟384{roomId});
if (𝓛12569{ExclamationToken}(𝓟386{room}))
{
}
𝓟386{room} as any._onLeave(𝓟383{client},𝓛8744{Boolean})
𝓟[ty]316{MatchMaker}.handlers.access(𝓟386{room}.roomName).emit(𝓛8743{String},𝓟386{room},𝓟383{client})
}
function 𝓟440{createRoomReferences} (𝓟441{roomName}: 𝓛[ty]10051{String},𝓟442{room}: [OOV]𝓟[ty]57{Room}): (𝓟443: 𝓛[ty]8666{Boolean})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]316{MatchMaker}.availableRooms.access(𝓟441{roomName}).indexOf(𝓟442{room}),𝓛12616{MinusToken}(𝓛8745{Number})))
{
𝓟[ty]316{MatchMaker}.availableRooms.access(𝓟441{roomName}).push(𝓟442{room})
𝓛1{<UNKNOWN>}(𝓟442{room}.roomName,𝓛1{<UNKNOWN>})
𝓛1{<UNKNOWN>}(𝓛1{<UNKNOWN>}.toString())
return 𝓟443 = 𝓛8744{Boolean}
}
}
function 𝓟422{create} (𝓟423{roomName}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]10051{String}),𝓟424{clientOptions}: [OOV]𝓟[ty]301{ClientOptions}): (𝓟425: [OOV]𝓟[ty]57{Room})
{
let 𝓟426{room} = 𝓛12643{undefined};
let 𝓟427{registeredHandler}: [OOV]𝓟[ty]308{RegisteredHandler} = 𝓟[ty]316{MatchMaker}.handlers.access(𝓟423{roomName});
𝓟426{room} ⟵ 𝓟427{registeredHandler}.klass.CONSTRUCTOR();
𝓟426{room}.roomId ⟵ 𝓟48{generateId}();
𝓟426{room}.roomName ⟵ 𝓟423{roomName};
if (𝓟426{room}.onInit)
{
𝓟426{room}.onInit(𝓟35{merge}({},𝓟424{clientOptions},𝓟427{registeredHandler}.options))
}
𝓛1{<UNKNOWN>}(𝓟426{room}.roomId,𝓛1{<UNKNOWN>})
if (𝓟426{room}.requestJoin(𝓟424{clientOptions},𝓛8744{Boolean}))
{
𝓟217{debugMatchMaking}(𝓛8743{String},𝓟423{roomName},𝓛1{<UNKNOWN>})
𝓟426{room}.on(𝓛8743{String},𝓟[ty]316{MatchMaker}.lockRoom.bind(𝓟[ty]316{MatchMaker},𝓟423{roomName},𝓟426{room}))
𝓟426{room}.on(𝓛8743{String},𝓟[ty]316{MatchMaker}.unlockRoom.bind(𝓟[ty]316{MatchMaker},𝓟423{roomName},𝓟426{room}))
𝓟426{room}.once(𝓛8743{String},𝓟[ty]316{MatchMaker}.disposeRoom.bind(𝓟[ty]316{MatchMaker},𝓟423{roomName},𝓟426{room}))
𝓟[ty]316{MatchMaker}.roomsById.access(𝓟426{room}.roomId) ⟵ 𝓟426{room};
𝓟[ty]316{MatchMaker}.createRoomReferences(𝓟423{roomName},𝓟426{room})
𝓟427{registeredHandler}.emit(𝓛8743{String},𝓟426{room})
}
else
{
𝓟426{room}._dispose()
𝓟426{room} ⟵ 𝓛12643{undefined};
}
return 𝓟425 = 𝓟426{room}
}
function 𝓟353{onJoinRoomRequest} (𝓟354{roomToJoin}: 𝓛[ty]10051{String},𝓟355{clientOptions}: [OOV]𝓟[ty]301{ClientOptions},𝓟356{allowCreateRoom}: 𝓛[ty]8666{Boolean},𝓟357{callback}: 𝓛[ty]8696{Function}): (𝓟358: 𝓛[ty]10033{Void})
{
let 𝓟359{room}: [OOV]𝓟[ty]57{Room};
let 𝓟360{err}: 𝓛[ty]10051{String};
𝓟355{clientOptions}.sessionId ⟵ 𝓟48{generateId}();
if (𝓟[ty]316{MatchMaker}.hasHandler(𝓟354{roomToJoin}))
{
𝓟359{room} ⟵ 𝓛12546{BarBarToken}(𝓟[ty]316{MatchMaker}.getAvailableRoomByScore(𝓟354{roomToJoin},𝓟355{clientOptions}).room,𝓛12592{AmpersandAmpersandToken}(𝓟356{allowCreateRoom},𝓟[ty]316{MatchMaker}.create(𝓟354{roomToJoin},𝓟355{clientOptions})));
}
else
{
if (𝓟50{isValidId}(𝓟354{roomToJoin}))
{
𝓟359{room} ⟵ 𝓟[ty]316{MatchMaker}.joinById(𝓟354{roomToJoin},𝓟355{clientOptions});
}
}
if (𝓟359{room})
{
𝓟359{room}.connectingClients.access(𝓟355{clientOptions}.clientId) ⟵ 𝓟355{clientOptions};
}
else
{
𝓟360{err} ⟵ 𝓛8743{String};
}
𝓟357{callback}(𝓟360{err},𝓟359{room})
}
function 𝓟428{lockRoom} (𝓟429{roomName}: 𝓛[ty]10051{String},𝓟430{room}: [OOV]𝓟[ty]57{Room}): (𝓟431: 𝓛[ty]10033{Void})
{
if (𝓟[ty]316{MatchMaker}.clearRoomReferences(𝓟429{roomName},𝓟430{room}))
{
𝓟[ty]316{MatchMaker}.handlers.access(𝓟430{room}.roomName).emit(𝓛8743{String},𝓟430{room})
}
}
function 𝓟392{registerHandler} (𝓟393{name}: 𝓛[ty]10051{String},𝓟394{klass}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟395{options}: [OOV]any): (𝓟396: [OOV]𝓟[ty]308{RegisteredHandler})
{
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟393{name})
let 𝓟397{registeredHandler}: [OOV]𝓟[ty]308{RegisteredHandler} = 𝓟302{CONSTRUCTOR}(𝓟394{klass},𝓟395{options});
𝓟[ty]316{MatchMaker}.handlers.access(𝓟393{name}) ⟵ 𝓟397{registeredHandler};
𝓟[ty]316{MatchMaker}.availableRooms.access(𝓟393{name}) ⟵ 𝓛8757{Array}();
return 𝓟396 = 𝓟397{registeredHandler}
}
function 𝓟401{hasAvailableRoom} (𝓟402{roomName}: 𝓛[ty]10051{String}): (𝓟403: 𝓛[ty]8666{Boolean})
{
return 𝓟403 = 𝓛12592{AmpersandAmpersandToken}(𝓟[ty]316{MatchMaker}.availableRooms.access(𝓟402{roomName}),𝓛12595{GreaterThanToken}(𝓟[ty]316{MatchMaker}.availableRooms.access(𝓟402{roomName}).length,𝓛8745{Number}))
}
function 𝓟436{disposeRoom} (𝓟437{roomName}: 𝓛[ty]10051{String},𝓟438{room}: [OOV]𝓟[ty]57{Room}): (𝓟439: 𝓛[ty]10033{Void})
{
𝓟217{debugMatchMaking}(𝓛8743{String},𝓟437{roomName},𝓛1{<UNKNOWN>})
𝓟[ty]316{MatchMaker}.handlers.access(𝓟437{roomName}).emit(𝓛8743{String},𝓟438{room})
𝓛12622{$Delete}(𝓟[ty]316{MatchMaker}.roomsById.access(𝓟438{room}.roomId))
𝓛1{<UNKNOWN>}(𝓟438{room}.roomId)
𝓟[ty]316{MatchMaker}.clearRoomReferences(𝓟437{roomName},𝓟438{room})
}
function 𝓟387{onClientLeaveRoom} (𝓟388{room}: [OOV]𝓟[ty]57{Room},𝓟389{client}: [OOV]𝓟[ty]46{Client},𝓟390{isDisconnect}: 𝓛[ty]8666{Boolean}): (𝓟391: 𝓛[ty]8666{Boolean})
{
if (𝓟390{isDisconnect})
{
return 𝓟391 = 𝓛8744{Boolean}
}
𝓛12622{$Delete}(𝓟[ty]316{MatchMaker}.sessions.access(𝓟389{client}.sessionId))
}
function 𝓟450{gracefullyShutdown} (): (𝓟451: [miss]𝓛[ty]8654{Promise})
{
if (𝓟[ty]316{MatchMaker}.isGracefullyShuttingDown)
{
return 𝓟451 = 𝓛1062{Promise}.reject(𝓛8744{Boolean})
}
𝓟[ty]316{MatchMaker}.isGracefullyShuttingDown ⟵ 𝓛8744{Boolean};
let 𝓟452{promises}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}();
{
let 𝓟453{roomId}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟[ty]316{MatchMaker}.roomsById);
while (𝓛8744{Boolean})
{
let 𝓟454{room}: [OOV]𝓟[ty]57{Room} = 𝓟[ty]316{MatchMaker}.roomsById.access(𝓟453{roomId});
𝓟454{room}.autoDispose ⟵ 𝓛8744{Boolean};
𝓟452{promises}.push(𝓟454{room}.disconnect())
𝓟452{promises}.push(𝓟454{room} as any._dispose())
𝓟454{room}.emit(𝓛8743{String})
}
}
return 𝓟451 = 𝓛1062{Promise}.all(𝓟452{promises})
}
function 𝓟432{unlockRoom} (𝓟433{roomName}: 𝓛[ty]10051{String},𝓟434{room}: [OOV]𝓟[ty]57{Room}): (𝓟435: [miss]𝓛[ty]10033{Void})
{
if (𝓟[ty]316{MatchMaker}.createRoomReferences(𝓟433{roomName},𝓟434{room}))
{
𝓟[ty]316{MatchMaker}.handlers.access(𝓟434{room}.roomName).emit(𝓛8743{String},𝓟434{room})
}
}
function 𝓟323{bindClient} (𝓟324{client}: [OOV]𝓟[ty]46{Client},𝓟325{roomId}: 𝓛[ty]10051{String}): (𝓟326: [miss]𝓛[ty]8654{Promise})
{
let 𝓟327{roomPromise}: [miss]𝓛[ty]8654{Promise} = 𝓟[ty]316{MatchMaker}.onJoin(𝓟325{roomId},𝓟324{client});
function 𝓟328{$Lambda15} (𝓟329{_}): (𝓟330: [miss]𝓛[ty]10033{Void})
{
return 𝓟330 = 𝓟[ty]316{MatchMaker}.onLeave(𝓟324{client},𝓟325{roomId})
}
𝓟324{client}.on(𝓛8743{String},𝓟328{$Lambda15})
function 𝓟331{$Lambda16} (𝓟332{e}): (𝓟333: [miss]𝓛[ty]10033{Void})
{
}
𝓟324{client}.on(𝓛8743{String},𝓟331{$Lambda16})
function 𝓟334{$Lambda17} (𝓟335{room}): (𝓟336: [miss]𝓛[ty]10033{Void})
{
function 𝓟337{$Lambda18} (𝓟338{message}): (𝓟339: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟338{message},𝓟222{decode}(𝓟338{message}))))
{
}
𝓟[ty]316{MatchMaker}.execute(𝓟324{client},𝓟338{message})
}
𝓟324{client}.on(𝓛8743{String},𝓟337{$Lambda18})
}
function 𝓟340{$Lambda19} (𝓟341{err}): (𝓟342: [miss]𝓛[ty]10033{Void})
{
𝓟225{send}(𝓟324{client},𝓛8757{Array}(𝓟221{Protocol}.JOIN_ERROR,𝓟325{roomId},𝓟341{err}))
𝓟324{client}.removeAllListeners()
}
𝓟327{roomPromise}.then(𝓟334{$Lambda17}).catch(𝓟340{$Lambda19})
return 𝓟326 = 𝓟327{roomPromise}
}
function 𝓟412{getAvailableRoomByScore} (𝓟413{roomName}: 𝓛[ty]10051{String},𝓟414{clientOptions}: [OOV]𝓟[ty]301{ClientOptions}): (𝓟415: [OOV]𝓟[ty]300{RoomWithScore})
{
let 𝓟416{room}: [OOV]𝓟[ty]57{Room};
let 𝓟417{bestScore}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
if (𝓟[ty]316{MatchMaker}.hasAvailableRoom(𝓟413{roomName}))
{
function 𝓟418{$Lambda25} (𝓟419{availableRoom}): (𝓟420: [miss]𝓛[ty]10033{Void})
{
if (𝓟419{availableRoom}.maxClientsReached)
{
}
let 𝓟421{score}: [miss]𝓛[ty]8655{Number} = 𝓟419{availableRoom}.requestJoin(𝓟414{clientOptions},𝓛8744{Boolean}) as 𝓛[ty]8655{Number};
if (𝓛12595{GreaterThanToken}(𝓟421{score},𝓟417{bestScore}))
{
𝓟417{bestScore} ⟵ 𝓟421{score};
𝓟416{room} ⟵ 𝓟419{availableRoom};
}
}
𝓟[ty]316{MatchMaker}.availableRooms.access(𝓟413{roomName}).forEach(𝓟418{$Lambda25})
}
return 𝓟415 = {room: 𝓟416{room},score: 𝓟417{bestScore}}
}
function 𝓟407{joinById} (𝓟408{roomId}: 𝓛[ty]10051{String},𝓟409{clientOptions}: [OOV]𝓟[ty]301{ClientOptions}): (𝓟410: [OOV]𝓟[ty]57{Room})
{
let 𝓟411{room} = 𝓟[ty]316{MatchMaker}.roomsById.access(𝓟408{roomId});
if (𝓛12569{ExclamationToken}(𝓟411{room}))
{
𝓛1{<UNKNOWN>}(𝓛12607{$Template}(𝓟408{roomId}))
}
else
{
if (𝓟411{room}.maxClientsReached)
{
𝓛1{<UNKNOWN>}(𝓛12607{$Template}(𝓟408{roomId}))
𝓟411{room} ⟵ 𝓛12643{undefined};
}
else
{
if (𝓛12569{ExclamationToken}(𝓟411{room}.requestJoin(𝓟409{clientOptions},𝓛8744{Boolean})))
{
𝓛1{<UNKNOWN>}(𝓛12607{$Template}(𝓟411{room}.roomName,𝓛8756{JSON}.stringify(𝓟409{clientOptions})))
𝓟411{room} ⟵ 𝓛12643{undefined};
}
}
}
return 𝓟410 = 𝓟411{room}
}
function 𝓟404{getRoomById} (𝓟405{roomId}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟406: [OOV]𝓟[ty]57{Room})
{
return 𝓟406 = 𝓟[ty]316{MatchMaker}.roomsById.access(𝓟405{roomId})
}
function 𝓟361{onJoin} (𝓟362{roomId}: 𝓛[ty]10051{String},𝓟363{client}: [OOV]𝓟[ty]46{Client}): (𝓟364: 𝓛[ty]8654{Promise})
{
const 𝓟365{room} = 𝓟[ty]316{MatchMaker}.roomsById.access(𝓟362{roomId});
const 𝓟366{clientOptions} = 𝓛12592{AmpersandAmpersandToken}(𝓟365{room},𝓟365{room}.connectingClients.access(𝓟363{client}.id));
function 𝓟367{$Lambda21} (𝓟368{resolve},𝓟369{reject}): (𝓟370: [miss]𝓛[ty]10033{Void})
{
if (𝓛12592{AmpersandAmpersandToken}(𝓟365{room},𝓟366{clientOptions}))
{
𝓟363{client}.sessionId ⟵ 𝓟366{clientOptions}.sessionId;
𝓛12622{$Delete}(𝓟366{clientOptions}.sessionId)
𝓛12622{$Delete}(𝓟366{clientOptions}.clientId)
let 𝓟371{isVerified} = 𝓟365{room}.verifyClient(𝓟363{client},𝓟366{clientOptions});
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟371{isVerified},𝓛1062{Promise})))
{
𝓟371{isVerified} ⟵ (𝓟371{isVerified} ? 𝓛1062{Promise}.resolve() : 𝓛1062{Promise}.reject(𝓛12643{undefined});
}
function 𝓟372{$Lambda22} (𝓟373{err}: 𝓛[ty]10051{String}): (𝓟374: [miss]𝓛[ty]10033{Void})
{
𝓟373{err} ⟵ 𝓛12546{BarBarToken}(𝓟373{err},𝓛8743{String});
𝓟217{debugMatchMaking}(𝓛12607{$Template}(𝓟373{err}),𝓟362{roomId},𝓟366{clientOptions})
𝓟365{room}._disposeIfEmpty()
𝓟369{reject}(𝓟373{err})
}
const 𝓟375{onVerifyFailure}: [miss]𝓛[ty]8696{Function} = 𝓟372{$Lambda22};
function 𝓟376{$Lambda23} (𝓟377{result}): (𝓟378: [miss]𝓛[ty]10033{Void})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟377{result},𝓛8744{Boolean}))
{
return 𝓟378 = 𝓟375{onVerifyFailure}()
}
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟363{client}.readyState,𝓟215{defaultVar}.OPEN))
{
return 𝓟378 = 𝓟369{reject}(𝓛8743{String})
}
𝓟365{room} as any._onJoin(𝓟363{client},𝓟366{clientOptions})
𝓟365{room}.once(𝓛8743{String},𝓟[ty]316{MatchMaker}.onClientLeaveRoom.bind(𝓟[ty]316{MatchMaker},𝓟365{room}))
𝓟[ty]316{MatchMaker}.sessions.access(𝓟363{client}.sessionId) ⟵ 𝓟365{room};
𝓟[ty]316{MatchMaker}.handlers.access(𝓟365{room}.roomName).emit(𝓛8743{String},𝓟365{room},𝓟363{client})
𝓟368{resolve}(𝓟365{room})
}
function 𝓟379{$Lambda24} (): (𝓟380: [miss]𝓛[ty]10033{Void})
{
𝓛12622{$Delete}(𝓟365{room}.connectingClients.access(𝓟363{client}.id))
}
𝓟371{isVerified}.then(𝓟376{$Lambda23}).catch(𝓟375{onVerifyFailure}).then(𝓟379{$Lambda24})
}
else
{
let 𝓟381{err}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
𝓟217{debugMatchMaking}(𝓛12607{$Template}(𝓟381{err}),𝓟362{roomId},𝓟366{clientOptions})
𝓟369{reject}(𝓟381{err})
}
}
return 𝓟364 = 𝓛1062{Promise}.CONSTRUCTOR(𝓟367{$Lambda21})
}
}
Module: src/cluster/Master
const 𝓟455{seed}: [miss]𝓛[ty]8655{Number} = 𝓛12618{BarToken}(𝓛12548{AsteriskToken}(𝓛8746{Math}.random(),𝓛8745{Number}),𝓛8745{Number});
const 𝓟456{workers}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
let 𝓟457{workersShutDown}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
const 𝓟458{onWorkersShutdown}: [OOV]𝓟[ty]18{Deferred} = 𝓟10{CONSTRUCTOR}();
function 𝓟459{getNextWorkerForSocket} (𝓟460{socket}: [OOV]𝓛[ty]6501{Socket}): (𝓟461: [OOV]any)
{
let 𝓟462{hash}: [miss]𝓛[ty]8655{Number} = 𝓟486{getHash}(𝓛1{<UNKNOWN>}(𝓛12546{BarBarToken}(𝓟460{socket}.remoteAddress,𝓛8743{String})));
return 𝓟461 = 𝓟456{workers}.access(𝓛12611{PercentToken}(𝓟462{hash},𝓟456{workers}.length))
}
function 𝓟463{spawnWorkers} (𝓟464{numWorkers}: 𝓛[ty]8655{Number}): (𝓟465: 𝓛[ty]8670{Array})
{
let 𝓟466{workers}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
{
let 𝓟467{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
let 𝓟468{len}: [miss]𝓛[ty]8655{Number} = 𝓟464{numWorkers};
while (𝓛1{<UNKNOWN>}(𝓟467{i},𝓟468{len}))
{
{
𝓟466{workers}.push(𝓟472{spawnWorker}())
}
𝓛12556{POST_PlusPlusToken}(𝓟467{i})
}
}
return 𝓟465 = 𝓟466{workers}
}
function 𝓟469{spawnMatchMaking} (): (𝓟470: [OOV]any)
{
let 𝓟471{worker} = 𝓛8531{fork}(𝓛12641{PlusToken}(𝓛10058{__dirname},𝓛8743{String}),𝓛8757{Array}(),{silent: 𝓛8744{Boolean}});
𝓟479{enableProcessCommunication}(𝓟471{worker})
𝓛1{<UNKNOWN>}(𝓟471{worker})
return 𝓟470 = 𝓟471{worker}
}
function 𝓟472{spawnWorker} (): (𝓟473: [OOV]any)
{
let 𝓟474{worker} = 𝓛2123{fork}();
𝓟216{debugCluster}(𝓛12607{$Template}(𝓟474{worker}.process.pid))
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}.access(𝓛8743{String})))
{
𝓛1{<UNKNOWN>}.access(𝓛8743{String}) ⟵ 𝓛8757{Array}();
}
𝓛1{<UNKNOWN>}.access(𝓛8743{String}).push(𝓟474{worker}.process.pid)
𝓟456{workers}.push(𝓟474{worker})
𝓟479{enableProcessCommunication}(𝓟474{worker})
function 𝓟475{$Lambda62} (𝓟476{code},𝓟477{signal}): (𝓟478: [miss]𝓛[ty]10033{Void})
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓟477{signal},𝓛8743{String}),𝓛12612{ExclamationEqualsEqualsToken}(𝓟477{signal},𝓛8743{String})),𝓛12612{ExclamationEqualsEqualsToken}(𝓟477{signal},𝓛8743{String})))
{
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓛1{<UNKNOWN>},𝓛8743{String})
𝓟29{spliceOne}(𝓛1{<UNKNOWN>}.access(𝓛8743{String}),𝓛1{<UNKNOWN>}.access(𝓛8743{String}).indexOf(𝓛1{<UNKNOWN>}))
𝓟29{spliceOne}(𝓟456{workers},𝓟456{workers}.indexOf(𝓟474{worker}))
𝓟472{spawnWorker}()
}
else
{
𝓛12556{POST_PlusPlusToken}(𝓟457{workersShutDown})
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟457{workersShutDown},𝓟456{workers}.length))
{
𝓟458{onWorkersShutdown}.resolve()
}
}
}
𝓟474{worker}.on(𝓛8743{String},𝓟475{$Lambda62})
return 𝓟473 = 𝓟474{worker}
}
function 𝓟479{enableProcessCommunication} (𝓟480{worker}: [OOV]any): (𝓟481: [miss]𝓛[ty]10033{Void})
{
function 𝓟482{$Lambda63} (𝓟483{message}): (𝓟484: [miss]𝓛[ty]10033{Void})
{
let 𝓟485{workerProcess} = 𝓛12592{AmpersandAmpersandToken}(𝓛8757{Array}.isArray(𝓟483{message}),𝓛1{<UNKNOWN>}(𝓟483{message}.shift()));
if (𝓟485{workerProcess})
{
𝓟485{workerProcess}.send(𝓟483{message})
}
}
𝓟480{worker}.on(𝓛8743{String},𝓟482{$Lambda63})
}
function 𝓟486{getHash} (𝓟487{ip}: (𝓛[ty]10051{String} ≠ 𝓛[ty]10045{Buffer})): (𝓟488: [miss]𝓛[ty]8655{Number})
{
let 𝓟489{hash}: [miss]𝓛[ty]8655{Number} = 𝓟455{seed};
{
let 𝓟490{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟490{i},𝓛1{<UNKNOWN>}))
{
{
let 𝓟491{num} = 𝓛1{<UNKNOWN>}(𝓟490{i});
𝓛12564{FirstCompoundAssignment}(𝓟489{hash},𝓟491{num})
𝓛12562{PercentEqualsToken}(𝓟489{hash},𝓛8745{Number})
𝓛12564{FirstCompoundAssignment}(𝓟489{hash},𝓛12560{LessThanLessThanToken}(𝓟489{hash},𝓛8745{Number}))
𝓛12562{PercentEqualsToken}(𝓟489{hash},𝓛8745{Number})
𝓛1{<UNKNOWN>}(𝓟489{hash},𝓛12626{GreaterThanGreaterThanToken}(𝓟489{hash},𝓛8745{Number}))
}
𝓛12556{POST_PlusPlusToken}(𝓟490{i})
}
}
𝓛12564{FirstCompoundAssignment}(𝓟489{hash},𝓛12560{LessThanLessThanToken}(𝓟489{hash},𝓛8745{Number}))
𝓛12562{PercentEqualsToken}(𝓟489{hash},𝓛8745{Number})
𝓛1{<UNKNOWN>}(𝓟489{hash},𝓛12626{GreaterThanGreaterThanToken}(𝓟489{hash},𝓛8745{Number}))
𝓛12564{FirstCompoundAssignment}(𝓟489{hash},𝓛12560{LessThanLessThanToken}(𝓟489{hash},𝓛8745{Number}))
𝓛12562{PercentEqualsToken}(𝓟489{hash},𝓛8745{Number})
return 𝓟488 = 𝓛12598{GreaterThanGreaterThanGreaterThanToken}(𝓟489{hash},𝓛8745{Number})
}
Module: usage/Server
const 𝓟492{port}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
const 𝓟493{endpoint}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
const 𝓟494{app} = 𝓛12643{undefined}();
𝓟494{app}.use(𝓛1{<UNKNOWN>}())
const 𝓟495{server} = 𝓛9138{createServer}(𝓟494{app});
const 𝓟496{gameServer}: [OOV]𝓟[ty]554{Server} = 𝓟528{CONSTRUCTOR}({server: 𝓟495{server}});
function 𝓟497{$Lambda53} (𝓟498{room}): (𝓟499: [miss]𝓛[ty]10033{Void})
{
return 𝓟499 = 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟498{room}.roomId)
}
function 𝓟500{$Lambda54} (𝓟501{room},𝓟502{client}): (𝓟503: [miss]𝓛[ty]10033{Void})
{
return 𝓟503 = 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟502{client}.id,𝓛8743{String},𝓟501{room}.roomId)
}
function 𝓟504{$Lambda55} (𝓟505{room},𝓟506{client}): (𝓟507: [miss]𝓛[ty]10033{Void})
{
return 𝓟507 = 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟506{client}.id,𝓛8743{String},𝓟505{room}.roomId)
}
function 𝓟508{$Lambda56} (𝓟509{room}): (𝓟510: [miss]𝓛[ty]10033{Void})
{
return 𝓟510 = 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟509{room}.roomId)
}
𝓟496{gameServer}.register(𝓛8743{String},𝓛12643{undefined}).on(𝓛8743{String},𝓟497{$Lambda53}).on(𝓛8743{String},𝓟500{$Lambda54}).on(𝓛8743{String},𝓟504{$Lambda55}).on(𝓛8743{String},𝓟508{$Lambda56})
𝓟494{app}.use(𝓛30113{static}(𝓛10058{__dirname}))
function 𝓟511{$Lambda57} (𝓟512{req},𝓟513{res}): (𝓟514: [miss]𝓛[ty]10033{Void})
{
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓛1{<UNKNOWN>})
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓟513{res}.send(𝓛8743{String})
}
𝓟494{app}.get(𝓛8743{String},𝓟511{$Lambda57})
function 𝓟515{$Lambda58} (𝓟516{req},𝓟517{res}): (𝓟518: [miss]𝓛[ty]10033{Void})
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓟517{res}.json(𝓟516{req}.body)
}
𝓟494{app}.post(𝓛8743{String},𝓟515{$Lambda58})
function 𝓟519{$Lambda59} (): (𝓟520: [miss]𝓛[ty]8654{Promise})
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
function 𝓟521{$Lambda60} (𝓟522{resolve},𝓟523{reject}): (𝓟524: [miss]𝓛[ty]10033{Void})
{
function 𝓟525{$Lambda61} (): (𝓟526: [miss]𝓛[ty]10033{Void})
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
𝓟522{resolve}()
}
𝓛12490{setTimeout}(𝓟525{$Lambda61},𝓛8745{Number})
}
return 𝓟520 = 𝓛1062{Promise}.CONSTRUCTOR(𝓟521{$Lambda60})
}
𝓟496{gameServer}.onShutdown(𝓟519{$Lambda59})
𝓟496{gameServer}.listen(𝓟492{port})
𝓛1{<UNKNOWN>}(𝓛12607{$Template}(𝓟493{endpoint},𝓟492{port}))
Module: src/Server
type 𝓟[ty]527{ServerOptions} = any
function 𝓟528{CONSTRUCTOR} (𝓟529{options}: [OOV]𝓟[ty]527{ServerOptions}): (𝓟[ty]554{Server})
{
const 𝓟[ty]554{Server};
const 𝓟[ty]554{Server};
function 𝓟533{$Lambda27} (): (𝓟534: [miss]𝓛[ty]8654{Promise})
{
return 𝓟534 = 𝓛1062{Promise}.resolve()
}
function 𝓟535{$Lambda32} (𝓟536{client}: [OOV]𝓟[ty]46{Client},𝓟537{req}: (𝓛[ty]8635{Date} ≠ 𝓛[ty]9098{IncomingMessage})): (𝓟538: [miss]𝓛[ty]10033{Void})
{
if (𝓟537{req})
{
𝓟536{client}.upgradeReq ⟵ 𝓟537{req};
}
let 𝓟539{url} = 𝓛12643{undefined}(𝓟536{client}.upgradeReq as any.url,𝓛8744{Boolean});
𝓟536{client}.upgradeReq.url ⟵ 𝓟539{url};
𝓟536{client}.upgradeReq as any.roomId ⟵ 𝓛1{<UNKNOWN>}.substr(𝓛8745{Number});
𝓟152{setUserId}(𝓟536{client})
let 𝓟540{roomId} = 𝓟536{client}.upgradeReq as any.roomId;
if (𝓟540{roomId})
{
𝓟[ty]554{Server}.matchMaker.bindClient(𝓟536{client},𝓟540{roomId})
}
else
{
𝓟536{client}.on(𝓛8743{String},𝓟[ty]554{Server}.onMessageMatchMaking.bind(𝓟[ty]554{Server},𝓟536{client}))
function 𝓟541{$Lambda33} (𝓟542{e}): (𝓟543: [miss]𝓛[ty]10033{Void})
{
}
𝓟536{client}.on(𝓛8743{String},𝓟541{$Lambda33})
}
}
𝓟[ty]554{Server}._onShutdown ⟵ 𝓟533{$Lambda27};
𝓟[ty]554{Server}.matchMaker ⟵ 𝓟312{CONSTRUCTOR}();
𝓟[ty]554{Server}.onConnection ⟵ 𝓟535{$Lambda32};
function 𝓟544{$Lambda28} (𝓟545{signal}): (𝓟546: [miss]𝓛[ty]10033{Void})
{
function 𝓟547{$Lambda29} (): (𝓟548: [OOV]any)
{
return 𝓟548 = 𝓟[ty]554{Server}._onShutdown()
}
function 𝓟549{$Lambda30} (𝓟550{err}): (𝓟551: [miss]𝓛[ty]10033{Void})
{
return 𝓟551 = 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟550{err})
}
function 𝓟552{$Lambda31} (): (𝓟553: [OOV]any)
{
return 𝓟553 = 𝓛1{<UNKNOWN>}()
}
𝓟[ty]554{Server}.matchMaker.gracefullyShutdown().then(𝓟547{$Lambda29}).catch(𝓟549{$Lambda30}).then(𝓟552{$Lambda31})
}
𝓟1{registerGracefulShutdown}(𝓟544{$Lambda28})
if (𝓟529{options}.server)
{
𝓟[ty]554{Server}.attach({server: 𝓟529{options}.server as 𝓛[ty]8985{Server}})
}
}
class 𝓟[ty]554{Server}{
𝓟556{server}: [OOV]𝓟[ty]212{WebSocketServer};
𝓟557{httpServer}: [OOV]any;
𝓟558{onConnection}: [miss]𝓛[ty]8696{Function};
𝓟559{matchMaker}: [OOV]𝓟[ty]316{MatchMaker};
𝓟560{_onShutdown}: 𝓛[ty]8696{Function};
function 𝓟570{register} (𝓟571{name}: 𝓛[ty]10051{String},𝓟572{handler}: 𝓛[ty]8696{Function},𝓟573{options}: [OOV]any): (𝓟574: [OOV]𝓟[ty]308{RegisteredHandler})
{
return 𝓟574 = 𝓟[ty]554{Server}.matchMaker.registerHandler(𝓟571{name},𝓟572{handler},𝓟573{options})
}
function 𝓟561{attach} (𝓟562{options}: [OOV]𝓟[ty]527{ServerOptions}): (𝓟563: [miss]𝓛[ty]10033{Void})
{
if (𝓛12546{BarBarToken}(𝓟562{options}.server,𝓟562{options}.port))
{
𝓟[ty]554{Server}.server ⟵ 𝓟214{WebSocketServer} as any.CONSTRUCTOR(𝓟562{options});
𝓟[ty]554{Server}.httpServer ⟵ 𝓟562{options}.server;
}
else
{
𝓟[ty]554{Server}.server ⟵ 𝓟562{options}.ws;
}
𝓟[ty]554{Server}.server.on(𝓛8743{String},𝓟[ty]554{Server}.onConnection)
}
function 𝓟564{listen} (𝓟565{port}: 𝓛[ty]8655{Number},𝓟566{hostname}: 𝓛[ty]10051{String},𝓟567{backlog}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟568{listeningListener}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function})): (𝓟569: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]554{Server}.httpServer.listen(𝓟565{port},𝓟566{hostname},𝓟567{backlog},𝓟568{listeningListener})
}
function 𝓟578{onMessageMatchMaking} (𝓟579{client}: [OOV]𝓟[ty]46{Client},𝓟580{message}): (𝓟581: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟580{message},𝓟222{decode}(𝓟580{message}))))
{
}
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟580{message}.access(𝓛8745{Number}),𝓟221{Protocol}.JOIN_ROOM))
{
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟580{message})
}
let 𝓟582{roomName} = 𝓟580{message}.access(𝓛8745{Number});
let 𝓟583{joinOptions} = 𝓟580{message}.access(𝓛8745{Number});
𝓟583{joinOptions}.clientId ⟵ 𝓟579{client}.id;
if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟[ty]554{Server}.matchMaker.hasHandler(𝓟582{roomName})),𝓛12569{ExclamationToken}(𝓟50{isValidId}(𝓟582{roomName}))))
{
𝓟225{send}(𝓟579{client},𝓛8757{Array}(𝓟221{Protocol}.JOIN_ERROR,𝓟582{roomName},𝓛12607{$Template}(𝓟582{roomName})))
}
else
{
function 𝓟584{$Lambda34} (𝓟585{err}: 𝓛[ty]10051{String},𝓟586{room}: [OOV]𝓟[ty]57{Room}): (𝓟587: [miss]𝓛[ty]10033{Void})
{
let 𝓟588{joinRoomResponse}: [miss]𝓛[ty]8670{Array} = (𝓟585{err} ? 𝓛8757{Array}(𝓟221{Protocol}.JOIN_ERROR,𝓟582{roomName},𝓟585{err}) : 𝓛8757{Array}(𝓟221{Protocol}.JOIN_ROOM,𝓟586{room}.roomId,𝓟583{joinOptions}.requestId);
𝓟225{send}(𝓟579{client},𝓟588{joinRoomResponse})
}
𝓟[ty]554{Server}.matchMaker.onJoinRoomRequest(𝓟582{roomName},𝓟583{joinOptions},𝓛8744{Boolean},𝓟584{$Lambda34})
}
}
function 𝓟575{onShutdown} (𝓟576{callback}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8696{Function})): (𝓟577: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]554{Server}._onShutdown ⟵ 𝓟576{callback};
}
}
Module: src/ClusterServer
type 𝓟[ty]589{ClusterOptions} = {server: 𝓛[ty]8985{Server}}
let 𝓟590{cache} = 𝓛1{<UNKNOWN>};
function 𝓟591{CONSTRUCTOR} (𝓟592{options}: [OOV]𝓟[ty]589{ClusterOptions}): (𝓟[ty]641{ClusterServer})
{
const 𝓟[ty]641{ClusterServer};
const 𝓟[ty]641{ClusterServer};
function 𝓟596{$Lambda0} (): (𝓟597: [miss]𝓛[ty]8654{Promise})
{
return 𝓟597 = 𝓛1062{Promise}.resolve()
}
𝓟[ty]641{ClusterServer}._onShutdown ⟵ 𝓟596{$Lambda0};
if (𝓛2126{isMaster})
{
𝓟216{debugCluster}(𝓛12607{$Template}(𝓛1{<UNKNOWN>}))
𝓟[ty]641{ClusterServer}.matchMakingWorker ⟵ 𝓟469{spawnMatchMaking}();
𝓟590{cache}.access(𝓛8743{String}) ⟵ 𝓟[ty]641{ClusterServer}.matchMakingWorker.pid;
𝓟216{debugCluster}(𝓛12607{$Template}(𝓟[ty]641{ClusterServer}.matchMakingWorker.pid))
function 𝓟598{$Lambda1} (𝓟599{signal}): (𝓟600: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]641{ClusterServer}.server.removeAllListeners()
𝓟[ty]641{ClusterServer}.matchMakingWorker.removeAllListeners()
𝓟[ty]641{ClusterServer}.matchMakingWorker.kill(𝓟599{signal})
function 𝓟601{$Lambda2} (): (𝓟602: [OOV]any)
{
return 𝓟602 = 𝓟[ty]641{ClusterServer}._onShutdown()
}
function 𝓟603{$Lambda3} (𝓟604{e}): (𝓟605: [miss]𝓛[ty]10033{Void})
{
return 𝓟605 = 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟604{e})
}
function 𝓟606{$Lambda4} (): (𝓟607: [OOV]any)
{
return 𝓟607 = 𝓛1{<UNKNOWN>}()
}
𝓟458{onWorkersShutdown}.then(𝓟601{$Lambda2}).catch(𝓟603{$Lambda3}).then(𝓟606{$Lambda4})
}
𝓟1{registerGracefulShutdown}(𝓟598{$Lambda1})
𝓟[ty]641{ClusterServer}.server ⟵ 𝓛12546{BarBarToken}(𝓟592{options}.server,𝓛9138{createServer}());
function 𝓟608{$Lambda5} (𝓟609{socket}): (𝓟610: [miss]𝓛[ty]10033{Void})
{
𝓟609{socket}.pause()
}
𝓟[ty]641{ClusterServer}.server.on(𝓛8743{String},𝓟608{$Lambda5})
function 𝓟611{$Lambda6} (𝓟612{request},𝓟613{response}): (𝓟614: [miss]𝓛[ty]10033{Void})
{
let 𝓟615{socket} = 𝓟612{request}.connection;
let 𝓟616{worker} = 𝓟459{getNextWorkerForSocket}(𝓟615{socket});
let 𝓟617{bodyChunks}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}();
function 𝓟618{$Lambda7} (𝓟619{chunk}): (𝓟620: [miss]𝓛[ty]10033{Void})
{
𝓟617{bodyChunks}.push(𝓟619{chunk})
}
function 𝓟621{$Lambda8} (): (𝓟622: [miss]𝓛[ty]10033{Void})
{
let 𝓟623{body} = 𝓛10100{Buffer}.concat(𝓟617{bodyChunks}).toString();
𝓟612{request}.headers.access(𝓛8743{String}) ⟵ 𝓟623{body}.length;
𝓟616{worker}.send(𝓛8757{Array}(𝓟221{Protocol}.PASS_HTTP_SOCKET,{url: 𝓟612{request}.url,headers: 𝓟612{request}.headers,body: 𝓟623{body},method: 𝓟612{request}.method}),𝓟615{socket})
}
𝓟612{request}.on(𝓛8743{String},𝓟618{$Lambda7}).on(𝓛8743{String},𝓟621{$Lambda8})
}
𝓟[ty]641{ClusterServer}.server.on(𝓛8743{String},𝓟611{$Lambda6})
function 𝓟624{$Lambda9} (𝓟625{request},𝓟626{socket},𝓟627{head}): (𝓟628: [miss]𝓛[ty]10033{Void})
{
let 𝓟629{worker} = 𝓟[ty]641{ClusterServer}.matchMakingWorker;
let 𝓟630{roomId} = 𝓛12643{undefined}(𝓟625{request}.url).pathname.substr(𝓛8745{Number});
if (𝓟590{cache}.access(𝓟630{roomId}))
{
𝓟629{worker} ⟵ 𝓛1{<UNKNOWN>}(𝓟590{cache}.access(𝓟630{roomId}));
}
𝓟629{worker}.send(𝓛8757{Array}(𝓟221{Protocol}.PASS_WEBSOCKET,{headers: 𝓟625{request}.headers,method: 𝓟625{request}.method},𝓟627{head},𝓟625{request}.url),𝓟626{socket})
}
𝓟[ty]641{ClusterServer}.server.on(𝓛8743{String},𝓟624{$Lambda9})
}
if (𝓛2127{isWorker})
{
𝓟[ty]641{ClusterServer}.matchMaker ⟵ 𝓟312{CONSTRUCTOR}();
function 𝓟631{$Lambda10} (𝓟632{signal}): (𝓟633: [miss]𝓛[ty]10033{Void})
{
function 𝓟634{$Lambda11} (): (𝓟635: [OOV]any)
{
return 𝓟635 = 𝓟[ty]641{ClusterServer}._onShutdown()
}
function 𝓟636{$Lambda12} (𝓟637{err}): (𝓟638: [miss]𝓛[ty]10033{Void})
{
return 𝓟638 = 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟637{err})
}
function 𝓟639{$Lambda13} (): (𝓟640: [OOV]any)
{
return 𝓟640 = 𝓛1{<UNKNOWN>}(𝓛1{<UNKNOWN>},𝓟632{signal})
}
𝓟[ty]641{ClusterServer}.matchMaker.gracefullyShutdown().then(𝓟634{$Lambda11}).catch(𝓟636{$Lambda12}).then(𝓟639{$Lambda13})
}
𝓟1{registerGracefulShutdown}(𝓟631{$Lambda10})
}
}
class 𝓟[ty]641{ClusterServer}{
𝓟643{server}: [OOV]any;
𝓟644{matchMakingWorker}: (𝓛[ty]8635{Date} ≠ 𝓛[ty]8318{ChildProcess});
𝓟645{matchMaker}: [OOV]𝓟[ty]316{MatchMaker};
𝓟646{_onShutdown}: 𝓛[ty]8696{Function};
function 𝓟656{register} (𝓟657{name}: 𝓛[ty]10051{String},𝓟658{handler}: 𝓛[ty]8696{Function},𝓟659{options}: [OOV]any): (𝓟660: [OOV]𝓟[ty]308{RegisteredHandler})
{
if (𝓛12569{ExclamationToken}(𝓛2127{isWorker}))
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
}
return 𝓟660 = 𝓟[ty]641{ClusterServer}.matchMaker.registerHandler(𝓟657{name},𝓟658{handler},𝓟659{options})
}
function 𝓟647{fork} (𝓟648{numWorkers}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟649: [miss]𝓛[ty]8670{Array})
{
return 𝓟649 = 𝓟463{spawnWorkers}(𝓟648{numWorkers})
}
function 𝓟661{attach} (𝓟662{options}: (𝓛[ty]8614{Readonly} ≠ 𝓛[ty]8642{Object})): (𝓟663: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓛2127{isWorker}))
{
𝓛1{<UNKNOWN>}(𝓛8743{String})
}
if (𝓟662{options}.server)
{
let 𝓟664{server} = 𝓟662{options}.server.listen(𝓛8745{Number},𝓛8743{String});
function 𝓟665{$Lambda14} (): (𝓟666: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]641{ClusterServer}.server ⟵ 𝓟165{setupWorker}(𝓟664{server},𝓟[ty]641{ClusterServer}.matchMaker);
}
𝓟664{server}.on(𝓛8743{String},𝓟665{$Lambda14})
}
}
function 𝓟650{listen} (𝓟651{port}: 𝓛[ty]8655{Number},𝓟652{hostname}: 𝓛[ty]10051{String},𝓟653{backlog}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟654{listeningListener}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function})): (𝓟655: [miss]𝓛[ty]10033{Void})
{
if (𝓛2126{isMaster})
{
𝓟[ty]641{ClusterServer}.server.listen(𝓟651{port},𝓟652{hostname},𝓟653{backlog},𝓟654{listeningListener})
}
}
function 𝓟667{onShutdown} (𝓟668{callback}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8696{Function})): (𝓟669: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]641{ClusterServer}._onShutdown ⟵ 𝓟668{callback};
}
}
Module: src/matchmaking/Process
const 𝓟670{server} = 𝓛9138{createServer}();
𝓟670{server}.listen(𝓛8745{Number},𝓛8743{String})
function 𝓟671{$Lambda72} (𝓟672{info},𝓟673{done}): (𝓟674: [miss]𝓛[ty]10033{Void})
{
𝓟673{done}(𝓛8744{Boolean})
}
let 𝓟675{wss} = 𝓛21502{CONSTRUCTOR}({server: 𝓟670{server},verifyClient: 𝓟671{$Lambda72}});
𝓟675{wss}.on(𝓛8743{String},𝓟682{onConnect})
let 𝓟676{callbacks}: 𝓛[ty]8642{Object} = {};
function 𝓟677{$Lambda73} (𝓟678{message},𝓟679{socket}): (𝓟680: [miss]𝓛[ty]10033{Void})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟678{message}.access(𝓛8745{Number}),𝓟221{Protocol}.PASS_WEBSOCKET))
{
𝓟156{handleUpgrade}(𝓟670{server},𝓟679{socket},𝓟678{message})
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛8757{Array}.isArray(𝓟678{message}),𝓟676{callbacks}.access(𝓟678{message}.access(𝓛8745{Number}))))
{
let 𝓟681{callback}: [miss]𝓛[ty]8696{Function} = 𝓟676{callbacks}.access(𝓟678{message}.shift());
𝓟681{callback}(𝓛12587{$Spread}(𝓟678{message}))
}
}
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟677{$Lambda73})
function 𝓟682{onConnect} (𝓟683{client}: [OOV]𝓟[ty]46{Client},𝓟684{req}: (𝓛[ty]8635{Date} ≠ 𝓛[ty]9098{IncomingMessage})): (𝓟685: [miss]𝓛[ty]10033{Void})
{
if (𝓟684{req})
{
𝓟683{client}.upgradeReq ⟵ 𝓟684{req};
}
function 𝓟686{$Lambda74} (𝓟687{e}): (𝓟688: [miss]𝓛[ty]10033{Void})
{
}
𝓟683{client}.on(𝓛8743{String},𝓟686{$Lambda74})
𝓟152{setUserId}(𝓟683{client})
function 𝓟689{$Lambda75} (𝓟690{message}): (𝓟691: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟690{message},𝓟222{decode}(𝓟690{message}))))
{
}
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟690{message}.access(𝓛8745{Number}),𝓟221{Protocol}.JOIN_ROOM))
{
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟690{message})
}
let 𝓟692{roomName} = 𝓟690{message}.access(𝓛8745{Number});
let 𝓟693{joinOptions} = 𝓟690{message}.access(𝓛8745{Number});
𝓟693{joinOptions}.clientId ⟵ 𝓟683{client}.id;
if (𝓟50{isValidId}(𝓟692{roomName}))
{
function 𝓟694{$Lambda76} (𝓟695{err},𝓟696{workerId}): (𝓟697: [miss]𝓛[ty]10033{Void})
{
return 𝓟697 = 𝓟706{broadcastJoinRoomRequest}(𝓛8757{Array}(𝓟696{workerId}),𝓟683{client},𝓟692{roomName},𝓟693{joinOptions})
}
𝓛1{<UNKNOWN>}(𝓟692{roomName},𝓟694{$Lambda76})
}
else
{
function 𝓟698{$Lambda77} (𝓟699{err},𝓟700{isHandlerAvailable}): (𝓟701: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓟700{isHandlerAvailable}))
{
𝓟225{send}(𝓟683{client},𝓛8757{Array}(𝓟221{Protocol}.JOIN_ERROR,𝓟692{roomName},𝓛12607{$Template}(𝓟692{roomName})))
}
function 𝓟702{$Lambda78} (𝓟703{err},𝓟704{availableWorkerIds}): (𝓟705: [miss]𝓛[ty]10033{Void})
{
if (𝓛12595{GreaterThanToken}(𝓟704{availableWorkerIds}.length,𝓛8745{Number}))
{
𝓟706{broadcastJoinRoomRequest}(𝓟704{availableWorkerIds},𝓟683{client},𝓟692{roomName},𝓟693{joinOptions})
}
else
{
𝓟737{requestCreateRoom}(𝓟683{client},𝓟692{roomName},𝓟693{joinOptions})
}
}
𝓛1{<UNKNOWN>}(𝓟692{roomName},𝓟702{$Lambda78})
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟692{roomName},𝓟698{$Lambda77})
}
}
𝓟683{client}.on(𝓛8743{String},𝓟689{$Lambda75})
}
function 𝓟706{broadcastJoinRoomRequest} (𝓟707{availableWorkerIds}: 𝓛[ty]8670{Array},𝓟708{client}: [OOV]𝓟[ty]46{Client},𝓟709{roomName}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]10051{String}),𝓟710{joinOptions}: [OOV]any): (𝓟711: [miss]𝓛[ty]10033{Void})
{
let 𝓟712{responsesReceived}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}();
function 𝓟713{$Lambda79} (𝓟714{workerId},𝓟715{roomId},𝓟716{score}): (𝓟717: [miss]𝓛[ty]10033{Void})
{
𝓟712{responsesReceived}.push({roomId: 𝓟715{roomId},score: 𝓟716{score},workerId: 𝓟714{workerId}})
𝓟217{debugMatchMaking}(𝓛8743{String},𝓟712{responsesReceived}.length,𝓟707{availableWorkerIds}.length)
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟712{responsesReceived}.length,𝓟707{availableWorkerIds}.length))
{
function 𝓟718{$Lambda80} (𝓟719{a},𝓟720{b}): (𝓟721: [miss]𝓛[ty]8655{Number})
{
return 𝓟721 = 𝓛12616{MinusToken}(𝓟720{b}.score,𝓟719{a}.score)
}
𝓟712{responsesReceived}.sort(𝓟718{$Lambda80})
let 𝓟722{workerId} = 𝓟712{responsesReceived}.access(𝓛8745{Number}).workerId;
let 𝓟723{roomId} = 𝓟712{responsesReceived}.access(𝓛8745{Number}).roomId;
let 𝓟724{score} = 𝓟712{responsesReceived}.access(𝓛8745{Number}).score;
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟724{score},𝓛8745{Number}))
{
𝓟217{debugMatchMaking}(𝓛8743{String},𝓟724{score},𝓟710{joinOptions})
𝓟737{requestCreateRoom}(𝓟708{client},𝓟709{roomName},𝓟710{joinOptions})
}
else
{
𝓟217{debugMatchMaking}(𝓛8743{String},𝓟724{score},𝓟710{joinOptions})
𝓟728{joinRoomRequest}(𝓟722{workerId},𝓟708{client},𝓟723{roomId},𝓟710{joinOptions})
}
}
}
𝓟676{callbacks}.access(𝓟708{client}.id) ⟵ 𝓟713{$Lambda79};
function 𝓟725{$Lambda81} (𝓟726{availableWorkerId}): (𝓟727: [miss]𝓛[ty]10033{Void})
{
𝓛1{<UNKNOWN>}(𝓛8757{Array}(𝓟726{availableWorkerId},𝓟221{Protocol}.REQUEST_JOIN_ROOM,𝓟709{roomName},𝓟710{joinOptions}))
}
𝓟707{availableWorkerIds}.forEach(𝓟725{$Lambda81})
}
function 𝓟728{joinRoomRequest} (𝓟729{workerId},𝓟730{client},𝓟731{roomName},𝓟732{joinOptions}): (𝓟733: [miss]𝓛[ty]10033{Void})
{
function 𝓟734{$Lambda82} (𝓟735{data}): (𝓟736: [miss]𝓛[ty]10033{Void})
{
return 𝓟736 = 𝓟225{send}(𝓟730{client},𝓟735{data})
}
𝓟676{callbacks}.access(𝓟730{client}.id) ⟵ 𝓟734{$Lambda82};
𝓛1{<UNKNOWN>}(𝓛8757{Array}(𝓟729{workerId},𝓟221{Protocol}.JOIN_ROOM,𝓟731{roomName},𝓟732{joinOptions}))
}
function 𝓟737{requestCreateRoom} (𝓟738{client},𝓟739{roomName},𝓟740{joinOptions}): (𝓟741: [miss]𝓛[ty]10033{Void})
{
function 𝓟742{$Lambda83} (𝓟743{data}): (𝓟744: [miss]𝓛[ty]10033{Void})
{
return 𝓟744 = 𝓟225{send}(𝓟738{client},𝓟743{data})
}
𝓟676{callbacks}.access(𝓟738{client}.id) ⟵ 𝓟742{$Lambda83};
function 𝓟745{$Lambda84} (𝓟746{err},𝓟747{workerIds}): (𝓟748: [miss]𝓛[ty]10033{Void})
{
function 𝓟749{$Lambda85} (𝓟750{err},𝓟751{spawnedRoomCounts}): (𝓟752: [miss]𝓛[ty]10033{Void})
{
function 𝓟753{$Lambda86} (𝓟754{count}): (𝓟755: [OOV]any)
{
return 𝓟755 = 𝓟754{count}
}
𝓟751{spawnedRoomCounts} ⟵ 𝓟751{spawnedRoomCounts}.filter(𝓟753{$Lambda86});
let 𝓟756{selectedWorkerId} = (𝓛12595{GreaterThanToken}(𝓟751{spawnedRoomCounts}.length,𝓛8745{Number}) ? 𝓟747{workerIds}.access(𝓟751{spawnedRoomCounts}.indexOf(𝓛8746{Math}.min(𝓛12587{$Spread}(𝓟751{spawnedRoomCounts})))) : 𝓟747{workerIds}.access(𝓛8745{Number});
𝓟217{debugMatchMaking}(𝓛8743{String})
𝓛1{<UNKNOWN>}(𝓛8757{Array}(𝓟756{selectedWorkerId},𝓟221{Protocol}.CREATE_ROOM,𝓟739{roomName},𝓟740{joinOptions}))
}
𝓛1{<UNKNOWN>}(𝓟747{workerIds},𝓟749{$Lambda85})
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓛8745{Number},𝓛12616{MinusToken}(𝓛8745{Number}),𝓟745{$Lambda84})
}