Continue script abstraction

ReallifeGamemode.Client/core/rage-mp/entities.ts

@@ -0,0 +1,116 @@
+import { IEntity, IPlayer, IPlayerPool, IVehicle, IVehiclePool, VehicleSeat, EntityType } from "../../game";
+import { parseJson } from "../../util";
+
+class RageEntity implements IEntity {
+    private entity: EntityMp;
+
+    get id(): number {
+        return this.entity.id;
+    }
+
+    constructor(entity: EntityMp) {
+        this.entity = entity;
+    }
+
+    get type(): EntityType {
+        switch (this.entity.type) {
+            case 'vehicle': return EntityType.Vehicle;
+            case 'player': return EntityType.Player;
+            default: return EntityType.Unknown;
+        }
+    }
+
+    getSharedData<T>(key: string): T {
+        var data = this.entity.getVariable(key);
+        if (typeof data !== 'undefined') {
+            return parseJson<T>(<string>data);
+        }
+
+        return null;
+    }
+}
+
+class RagePlayer extends RageEntity implements IPlayer {
+    private player: PlayerMp;
+
+    get name(): string {
+        return this.player.name;
+    }
+
+    get vehicle(): IVehicle {
+        var veh: VehicleMp = this.player.vehicle;
+        return veh ? new RageVehicle(veh) : null;
+    }
+
+    get inVehicle(): boolean {
+        return this.player.isInAnyVehicle(false);
+    }
+
+    constructor(player: PlayerMp) {
+        super(player);
+        this.player = player;
+    }
+}
+
+class RagePlayerPool implements IPlayerPool {
+    get local(): IPlayer {
+        return new RagePlayer(mp.players.local);
+    }
+
+    at(id: number): IPlayer {
+        return new RagePlayer(mp.players.atRemoteId(Number(id)));
+    }
+
+    forEach(fn: (entity: IPlayer) => void): void {
+        mp.players.forEach(e => {
+            fn(new RagePlayer(e));
+        });
+    }
+}
+
+class RageVehicle extends RageEntity implements IVehicle {
+    private vehicle: VehicleMp;
+
+    constructor(vehicle: VehicleMp) {
+        super(vehicle);
+        this.vehicle = vehicle;
+    }
+
+    isSeatFree(seat: VehicleSeat): boolean {
+        return this.vehicle.isSeatFree(<number>seat - 1);
+    }
+
+    setEngineStatus(status: boolean, instantly: boolean, otherwise: boolean) {
+        this.vehicle.setEngineOn(status, instantly, otherwise);
+    }
+
+    setUndriveable(status: boolean) {
+        this.vehicle.setUndriveable(status);
+    }
+
+    setDoorsLocked(state: boolean) {
+        this.vehicle.setDoorsLocked(state ? 2 : 1);
+    }
+}
+
+class RageVehiclePool implements IVehiclePool {
+    at(id: number): IVehicle {
+        return new RageVehicle(mp.vehicles.atRemoteId(Number(id)));
+    }
+
+    forEach(fn: (entity: IVehicle) => void): void {
+        mp.vehicles.forEach(e => {
+            fn(new RageVehicle(e));
+        })
+    }
+
+
+}
+
+export {
+    RageEntity,
+    RagePlayer,
+    RagePlayerPool,
+    RageVehicle,
+    RageVehiclePool,
+}

ReallifeGamemode.Client/core/rage-mp/events.ts

@@ -0,0 +1,97 @@
+import { IEvents, EventName, Key, IEntity, IVehicle, VehicleSeat } from "../../game";
+import game from "../../index";
+import { RageEntity, RageVehicle, RagePlayer } from "./entities";
+
+export default class RageEvents implements IEvents {
+    boundKeys: Key[] = [];
+
+    translateEventName(event: EventName): string {
+        switch (event) {
+            case EventName.PlayerCommand: return "playerCommand";
+            case EventName.Tick: return "render";
+            case EventName.EntityStreamIn: return "entityStreamIn";
+        }
+    }
+
+    add(event: EventName | string, callback: (...args: any[]) => void): void {
+        var eventName: string;
+
+        if (typeof (event) === 'string') {
+            eventName = event.toString();
+        } else {
+            eventName = game.events.translateEventName(event);
+        }
+
+        mp.events.add(eventName, callback);
+    }
+
+    addCef(event: string, callback: (args: any[]) => void): void {
+        mp.events.add('CEF:' + event, (cefArgs: string) => {
+            callback(JSON.parse(cefArgs));
+        });
+    }
+
+    callServer(event: string, args?: any[] | any): void {
+        if (args) {
+            if (typeof args === 'object') {
+                args.push(event);
+            } else {
+                args = [args, event];
+            }
+        } else {
+            args = [event];
+        }
+        mp.events.callRemote('CLIENT:Event', JSON.stringify(args));
+    }
+
+    bindKey(key: Key, hold: boolean, callback: Function) {
+        if (this.boundKeys.indexOf(key) === -1) {
+            mp.keys.bind(key, hold, callback);
+            this.boundKeys.push(key);
+        }
+    }
+
+    unbindKey(key: Key, hold: boolean, callback?: Function) {
+        var index: number = this.boundKeys.indexOf(key);
+        if (index !== -1) {
+            mp.keys.unbind(key, hold, callback);
+            this.boundKeys.splice(index, 1);
+        }
+    }
+
+
+    onEntityStreamIn(callback: (entity: IEntity) => void): void {
+        mp.events.add("entityStreamIn", (e: EntityMp) => {
+            var rE: RageEntity;
+            switch (e.type) {
+                case 'vehicle':
+                    rE = new RageVehicle(<VehicleMp>e);
+                    break;
+                case 'player':
+                    rE = new RagePlayer(<PlayerMp>e);
+                    break;
+            }
+
+            callback(rE);
+        })
+    }
+
+    onPlayerEnterVehicle(callback: (vehicle: IVehicle, seat: VehicleSeat) => void): void {
+        mp.events.add("playerEnterVehicle", (rV: VehicleMp, rS: number) => {
+            callback(new RageVehicle(rV), <VehicleSeat>(rS + 1));
+        });
+    }
+
+    onPlayerExitVehicle(callback: () => void): void {
+        mp.events.add("playerLeaveVehicle", (rV: VehicleMp) => {
+            callback();
+        });
+    }
+
+
+    onPlayerCommand(callback: (cmd: string) => void) {
+        mp.events.add("playerCommand", (cmd: string) => {
+            callback(cmd);
+        });
+    }
+}

ReallifeGamemode.Client/core/rage-mp/game.ts

@@ -0,0 +1,20 @@
+import { IGame, IUi, IEvents, IPlayerPool, IVehiclePool } from "../../game";
+import RageEvents from "./events";
+import RageUi from "./ui";
+import { RagePlayerPool, RageVehiclePool } from "./entities";
+
+export default class RageGame implements IGame {
+    players: IPlayerPool = new RagePlayerPool();
+    vehicles: IVehiclePool = new RageVehiclePool();
+
+    events: IEvents = new RageEvents;
+    ui: IUi = new RageUi;
+
+    wait(ms: number): void {
+        mp.game.wait(ms);
+    }
+
+    disableDefaultEngineBehaviour(): void {
+        mp.game.vehicle.defaultEngineBehaviour = false;
+    }
+}

ReallifeGamemode.Client/core/rage-mp/ui.ts

@@ -0,0 +1,73 @@
+import { IUi, IBrowser } from "../../game";
+import { Menu } from "../../libs/NativeUI/index";
+
+export default class RageUi implements IUi {
+    private _inMenu: boolean = false;
+    private _activeMenu: Menu = null;
+
+    inChat: boolean = false;
+
+    get activeMenu(): Menu {
+        return this._activeMenu;
+    }
+
+    set activeMenu(value: Menu) {
+        if (this.activeMenu && this.activeMenu.Visible) {
+            this.activeMenu.Close(true);
+        }
+
+        this._activeMenu = value;
+
+        if (this.activeMenu) {
+            this.activeMenu.Open();
+        }
+
+        this.inMenu = this.activeMenu != null;
+    }
+
+    get inMenu() {
+        return this._inMenu;
+    }
+
+    set inMenu(value: boolean) {
+        this._inMenu = value;
+        this.toggleChat(!value);
+    }
+
+    toggleChat(toggle: boolean) {
+        mp.gui.chat.show(toggle);
+    }
+
+    openBrower(path: string): IBrowser {
+        return new RageBrowser(path);
+    }
+
+    sendChatMessage(message: string) {
+        mp.gui.chat.push(message);
+    }
+
+    setCursor(freeze: boolean, show: boolean): void {
+        mp.gui.cursor.show(freeze, show);
+    }
+}
+
+export class RageBrowser implements IBrowser {
+    private rageBrowser: BrowserMp;
+
+    constructor(path: string) {
+        this.rageBrowser = mp.browsers.new(path);
+    }
+
+    close(): void {
+        if (this.rageBrowser) {
+            this.rageBrowser.destroy();
+            this.rageBrowser = null;
+        }
+    }
+
+    executeJs(script: string) {
+        if (this.rageBrowser) {
+            this.rageBrowser.execute(script);
+        }
+    }
+}