105 lines
2.8 KiB
TypeScript
105 lines
2.8 KiB
TypeScript
import { Wrapper } from './wrapper'
|
|
import {
|
|
Environment,
|
|
Events,
|
|
type PlayerMp,
|
|
RPCEventType,
|
|
RPCState,
|
|
RpcWrapperConfig,
|
|
Utils,
|
|
} from './utils'
|
|
|
|
/**
|
|
* NOT INTENDED FOR OUT-OF-CONTEXT USE
|
|
*/
|
|
export class Server extends Wrapper {
|
|
constructor(
|
|
options: RpcWrapperConfig = {
|
|
forceBrowserDevMode: false,
|
|
},
|
|
) {
|
|
super(options)
|
|
|
|
if (!!options.forceBrowserDevMode) return
|
|
|
|
// specific event to save player in context as it is not available on server -> server calls
|
|
mp.events.add(
|
|
Events.SERVER_EVENT_LISTENER,
|
|
async (player: PlayerMp, dataRaw: string) => {
|
|
this.emit(player, dataRaw)
|
|
},
|
|
)
|
|
}
|
|
|
|
/**
|
|
* NOT INTENDED FOR OUT-OF-CONTEXT USE
|
|
*/
|
|
public _resolveEmitDestination(player: PlayerMp, dataRaw: string) {
|
|
let state = Utils.prepareExecution(dataRaw)
|
|
|
|
switch (state.calledTo) {
|
|
case Environment.SERVER:
|
|
this.emit(player, dataRaw)
|
|
break
|
|
|
|
default:
|
|
this.emitClient(player as PlayerMp, dataRaw)
|
|
break
|
|
}
|
|
}
|
|
|
|
private emitClient(player: PlayerMp, dataRaw: string) {
|
|
player.call(Events.LOCAL_EVENT_LISTENER, [dataRaw])
|
|
}
|
|
|
|
// called to server
|
|
private async emit(player: PlayerMp, dataRaw: string) {
|
|
let state = Utils.prepareExecution(dataRaw)
|
|
const responseEventName = Utils.generateResponseEventName(state.uuid)
|
|
|
|
// check availability
|
|
state = this.verifyEvent_(state)
|
|
if (state.knownError) {
|
|
this.triggerError_(state, state.knownError)
|
|
}
|
|
|
|
// execute + generate response
|
|
const response = await this.state_[state.eventName](
|
|
player,
|
|
...(Array.isArray(state.data) ? state.data : []),
|
|
)
|
|
const responseState: RPCState = {
|
|
uuid: Utils.generateUUID(),
|
|
eventName: state.eventName,
|
|
calledFrom: Environment.SERVER,
|
|
calledTo: state.calledFrom,
|
|
knownError: undefined,
|
|
data: response,
|
|
type: RPCEventType.RESPONSE,
|
|
}
|
|
|
|
// send response
|
|
switch (state.calledFrom) {
|
|
case Environment.SERVER:
|
|
try {
|
|
mp.events.call(
|
|
responseEventName,
|
|
Utils.prepareTransfer(responseState),
|
|
)
|
|
} catch (e) {
|
|
void e
|
|
}
|
|
break
|
|
default:
|
|
try {
|
|
player.call(responseEventName, [
|
|
Utils.prepareTransfer(responseState),
|
|
])
|
|
} catch (e) {
|
|
void e
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|