@open-core/framework 0.1.0-alpha.1 → 0.2.1-beta.1

package/dist/runtime/server/services/core/vehicle-modification.service.js

@@ -0,0 +1,330 @@
+'use strict'
+var __decorate =
+  (this && this.__decorate) ||
+  function (decorators, target, key, desc) {
+    var c = arguments.length,
+      r =
+        c < 3
+          ? target
+          : desc === null
+            ? (desc = Object.getOwnPropertyDescriptor(target, key))
+            : desc,
+      d
+    if (typeof Reflect === 'object' && typeof Reflect.decorate === 'function')
+      r = Reflect.decorate(decorators, target, key, desc)
+    else
+      for (var i = decorators.length - 1; i >= 0; i--)
+        if ((d = decorators[i]))
+          r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r
+    return c > 3 && r && Object.defineProperty(target, key, r), r
+  }
+var __metadata =
+  (this && this.__metadata) ||
+  ((k, v) => {
+    if (typeof Reflect === 'object' && typeof Reflect.metadata === 'function')
+      return Reflect.metadata(k, v)
+  })
+var __param =
+  (this && this.__param) ||
+  ((paramIndex, decorator) => (target, key) => {
+    decorator(target, key, paramIndex)
+  })
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.VehicleModificationService = void 0
+const tsyringe_1 = require('tsyringe')
+const vehicle_service_1 = require('./vehicle.service')
+const logger_1 = require('../../../../kernel/shared/logger')
+/**
+ * Service for handling vehicle modifications with validation.
+ *
+ * This service is separated from VehicleService to maintain single responsibility.
+ * All modifications are validated server-side before being applied.
+ *
+ * Security features:
+ * - Ownership validation
+ * - Proximity checks
+ * - Modification limits
+ * - Audit logging
+ */
+let VehicleModificationService = class VehicleModificationService {
+  constructor(vehicleService) {
+    this.vehicleService = vehicleService
+  }
+  /**
+   * Applies modifications to a vehicle with validation.
+   *
+   * @param options - Modification options
+   * @returns Success status
+   */
+  applyModifications(options) {
+    const { networkId, mods, requestedBy } = options
+    const vehicle = this.vehicleService.getByNetworkId(networkId)
+    if (!vehicle) {
+      logger_1.coreLogger.warn('Vehicle not found for modification', { networkId })
+      return false
+    }
+    if (!vehicle.exists) {
+      logger_1.coreLogger.warn('Vehicle no longer exists', { networkId })
+      return false
+    }
+    if (requestedBy !== undefined) {
+      if (!this.vehicleService.validateOwnership(networkId, requestedBy)) {
+        logger_1.coreLogger.warn('Unauthorized modification attempt', {
+          networkId,
+          requestedBy,
+          owner: vehicle.ownership.clientID,
+        })
+        return false
+      }
+      if (!this.vehicleService.validateProximity(networkId, requestedBy, 15.0)) {
+        logger_1.coreLogger.warn('Player too far from vehicle for modification', {
+          networkId,
+          requestedBy,
+        })
+        return false
+      }
+    }
+    const validatedMods = this.validateMods(mods)
+    vehicle.applyMods(validatedMods)
+    logger_1.coreLogger.debug('Vehicle modifications applied', {
+      networkId,
+      requestedBy,
+      mods: Object.keys(validatedMods),
+    })
+    emitNet('opencore:vehicle:modified', -1, {
+      networkId,
+      mods: validatedMods,
+    })
+    return true
+  }
+  /**
+   * Sets vehicle colors with validation.
+   *
+   * @param networkId - Network ID of the vehicle
+   * @param primaryColor - Primary color ID
+   * @param secondaryColor - Secondary color ID
+   * @param requestedBy - Client ID requesting the change
+   * @returns Success status
+   */
+  setColors(networkId, primaryColor, secondaryColor, requestedBy) {
+    return this.applyModifications({
+      networkId,
+      mods: { primaryColor, secondaryColor },
+      requestedBy,
+    })
+  }
+  /**
+   * Sets vehicle livery with validation.
+   *
+   * @param networkId - Network ID of the vehicle
+   * @param livery - Livery index
+   * @param requestedBy - Client ID requesting the change
+   * @returns Success status
+   */
+  setLivery(networkId, livery, requestedBy) {
+    return this.applyModifications({
+      networkId,
+      mods: { livery },
+      requestedBy,
+    })
+  }
+  /**
+   * Toggles vehicle turbo with validation.
+   *
+   * @param networkId - Network ID of the vehicle
+   * @param enabled - Whether turbo should be enabled
+   * @param requestedBy - Client ID requesting the change
+   * @returns Success status
+   */
+  setTurbo(networkId, enabled, requestedBy) {
+    return this.applyModifications({
+      networkId,
+      mods: { turbo: enabled },
+      requestedBy,
+    })
+  }
+  /**
+   * Sets vehicle window tint with validation.
+   *
+   * @param networkId - Network ID of the vehicle
+   * @param tint - Tint level (0-6)
+   * @param requestedBy - Client ID requesting the change
+   * @returns Success status
+   */
+  setWindowTint(networkId, tint, requestedBy) {
+    const validTint = Math.max(0, Math.min(6, tint))
+    return this.applyModifications({
+      networkId,
+      mods: { windowTint: validTint },
+      requestedBy,
+    })
+  }
+  /**
+   * Sets vehicle neon lights with validation.
+   *
+   * @param networkId - Network ID of the vehicle
+   * @param enabled - Array of [left, right, front, back] enabled states
+   * @param color - RGB color array
+   * @param requestedBy - Client ID requesting the change
+   * @returns Success status
+   */
+  setNeon(networkId, enabled, color, requestedBy) {
+    const mods = { neonEnabled: enabled }
+    if (color) {
+      mods.neonColor = color
+    }
+    return this.applyModifications({
+      networkId,
+      mods,
+      requestedBy,
+    })
+  }
+  /**
+   * Resets all modifications on a vehicle.
+   *
+   * @param networkId - Network ID of the vehicle
+   * @param requestedBy - Client ID requesting the reset
+   * @returns Success status
+   */
+  resetModifications(networkId, requestedBy) {
+    const vehicle = this.vehicleService.getByNetworkId(networkId)
+    if (!vehicle) return false
+    if (requestedBy !== undefined) {
+      if (!this.vehicleService.validateOwnership(networkId, requestedBy)) {
+        return false
+      }
+    }
+    const defaultMods = {
+      spoiler: -1,
+      frontBumper: -1,
+      rearBumper: -1,
+      sideSkirt: -1,
+      exhaust: -1,
+      frame: -1,
+      grille: -1,
+      hood: -1,
+      fender: -1,
+      rightFender: -1,
+      roof: -1,
+      engine: -1,
+      brakes: -1,
+      transmission: -1,
+      horns: -1,
+      suspension: -1,
+      armor: -1,
+      turbo: false,
+      xenon: false,
+      windowTint: 0,
+    }
+    vehicle.applyMods(defaultMods)
+    logger_1.coreLogger.info('Vehicle modifications reset', { networkId, requestedBy })
+    emitNet('opencore:vehicle:modified', -1, {
+      networkId,
+      mods: defaultMods,
+    })
+    return true
+  }
+  /**
+   * Gets the current modifications of a vehicle.
+   *
+   * @param networkId - Network ID of the vehicle
+   * @returns Vehicle mods or undefined
+   */
+  getModifications(networkId) {
+    const vehicle = this.vehicleService.getByNetworkId(networkId)
+    return vehicle === null || vehicle === void 0 ? void 0 : vehicle.mods
+  }
+  /**
+   * Validates modification values to prevent exploits.
+   *
+   * @param mods - Modifications to validate
+   * @returns Validated modifications
+   */
+  validateMods(mods) {
+    const validated = {}
+    const modSlots = [
+      'spoiler',
+      'frontBumper',
+      'rearBumper',
+      'sideSkirt',
+      'exhaust',
+      'frame',
+      'grille',
+      'hood',
+      'fender',
+      'rightFender',
+      'roof',
+      'engine',
+      'brakes',
+      'transmission',
+      'horns',
+      'suspension',
+      'armor',
+      'wheels',
+    ]
+    for (const slot of modSlots) {
+      if (mods[slot] !== undefined) {
+        const value = mods[slot]
+        validated[slot] = Math.max(-1, Math.min(50, value))
+      }
+    }
+    if (mods.turbo !== undefined) validated.turbo = Boolean(mods.turbo)
+    if (mods.xenon !== undefined) validated.xenon = Boolean(mods.xenon)
+    if (mods.wheelType !== undefined) {
+      validated.wheelType = Math.max(0, Math.min(12, mods.wheelType))
+    }
+    if (mods.windowTint !== undefined) {
+      validated.windowTint = Math.max(0, Math.min(6, mods.windowTint))
+    }
+    if (mods.livery !== undefined) {
+      validated.livery = Math.max(-1, Math.min(50, mods.livery))
+    }
+    if (mods.plateStyle !== undefined) {
+      validated.plateStyle = Math.max(0, Math.min(5, mods.plateStyle))
+    }
+    if (mods.primaryColor !== undefined) {
+      validated.primaryColor = Math.max(0, Math.min(160, mods.primaryColor))
+    }
+    if (mods.secondaryColor !== undefined) {
+      validated.secondaryColor = Math.max(0, Math.min(160, mods.secondaryColor))
+    }
+    if (mods.pearlescentColor !== undefined) {
+      validated.pearlescentColor = Math.max(0, Math.min(160, mods.pearlescentColor))
+    }
+    if (mods.wheelColor !== undefined) {
+      validated.wheelColor = Math.max(0, Math.min(160, mods.wheelColor))
+    }
+    if (mods.xenonColor !== undefined) {
+      validated.xenonColor = Math.max(0, Math.min(12, mods.xenonColor))
+    }
+    if (mods.neonEnabled !== undefined) {
+      validated.neonEnabled = mods.neonEnabled
+    }
+    if (mods.neonColor !== undefined) {
+      validated.neonColor = [
+        Math.max(0, Math.min(255, mods.neonColor[0])),
+        Math.max(0, Math.min(255, mods.neonColor[1])),
+        Math.max(0, Math.min(255, mods.neonColor[2])),
+      ]
+    }
+    if (mods.extras !== undefined) {
+      validated.extras = {}
+      for (const [key, value] of Object.entries(mods.extras)) {
+        const extraId = Number(key)
+        if (extraId >= 0 && extraId <= 20) {
+          validated.extras[extraId] = Boolean(value)
+        }
+      }
+    }
+    return validated
+  }
+}
+exports.VehicleModificationService = VehicleModificationService
+exports.VehicleModificationService = VehicleModificationService = __decorate(
+  [
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(vehicle_service_1.VehicleService)),
+    __metadata('design:paramtypes', [vehicle_service_1.VehicleService]),
+  ],
+  VehicleModificationService,
+)

package/dist/runtime/server/services/core/vehicle.service.d.ts

@@ -0,0 +1,128 @@
+import { Vehicle } from '../../entities/vehicle'
+import type {
+  VehicleCreateOptions,
+  VehicleSpawnResult,
+  SerializedVehicleData,
+} from '../../types/vehicle.types'
+import { PlayerDirectoryPort } from '../ports/player-directory.port'
+/**
+ * Server-side service for managing vehicle entities.
+ *
+ * This service is the central authority for all vehicle operations:
+ * - Creating vehicles server-side (prevents client-side spawning abuse)
+ * - Managing vehicle registry by Network ID
+ * - Validating permissions and positions
+ * - Synchronizing vehicle state across clients
+ *
+ * @remarks
+ * All vehicle creation MUST go through this service to ensure security.
+ * Uses CreateVehicleServerSetter for server-authoritative spawning.
+ */
+export declare class VehicleService {
+  private readonly playerDirectory
+  /**
+   * Internal registry of all managed vehicles indexed by Network ID
+   */
+  private vehiclesByNetworkId
+  constructor(playerDirectory: PlayerDirectoryPort)
+  /**
+   * Creates a new vehicle on the server.
+   *
+   * This method uses CreateVehicleServerSetter to spawn the vehicle server-side,
+   * preventing client-side spawning exploits.
+   *
+   * @param options - Vehicle creation options
+   * @returns Spawn result with network ID and handle
+   */
+  create(options: VehicleCreateOptions): Promise<VehicleSpawnResult>
+  /**
+   * Creates a vehicle for a specific player.
+   *
+   * @param clientID - Client ID of the requesting player
+   * @param options - Vehicle creation options
+   * @returns Spawn result
+   */
+  createForPlayer(clientID: number, options: VehicleCreateOptions): Promise<VehicleSpawnResult>
+  /**
+   * Retrieves a vehicle by its Network ID.
+   *
+   * @param networkId - Network ID of the vehicle
+   * @returns Vehicle entity or undefined
+   */
+  getByNetworkId(networkId: number): Vehicle | undefined
+  /**
+   * Retrieves a vehicle by its entity handle.
+   *
+   * @param handle - Entity handle
+   * @returns Vehicle entity or undefined
+   */
+  getByHandle(handle: number): Vehicle | undefined
+  /**
+   * Gets all vehicles owned by a specific player.
+   *
+   * @param clientID - Client ID of the owner
+   * @returns Array of vehicles
+   */
+  getPlayerVehicles(clientID: number): Vehicle[]
+  /**
+   * Gets all vehicles in a specific routing bucket.
+   *
+   * @param bucket - Routing bucket ID
+   * @returns Array of vehicles
+   */
+  getVehiclesInBucket(bucket: number): Vehicle[]
+  /**
+   * Gets all managed vehicles.
+   *
+   * @returns Array of all vehicles
+   */
+  getAll(): Vehicle[]
+  /**
+   * Deletes a vehicle from the server.
+   *
+   * @param networkId - Network ID of the vehicle to delete
+   * @param requestedBy - Optional client ID for permission validation
+   * @returns Success status
+   */
+  delete(networkId: number, requestedBy?: number): boolean
+  /**
+   * Deletes all vehicles owned by a player.
+   * Useful when a player disconnects.
+   *
+   * @param clientID - Client ID of the owner
+   */
+  deletePlayerVehicles(clientID: number): void
+  /**
+   * Validates if a player can perform an action on a vehicle.
+   *
+   * @param networkId - Network ID of the vehicle
+   * @param clientID - Client ID of the player
+   * @returns True if authorized
+   */
+  validateOwnership(networkId: number, clientID: number): boolean
+  /**
+   * Validates if a player is near a vehicle.
+   *
+   * @param networkId - Network ID of the vehicle
+   * @param clientID - Client ID of the player
+   * @param maxDistance - Maximum distance in units
+   * @returns True if within range
+   */
+  validateProximity(networkId: number, clientID: number, maxDistance?: number): boolean
+  /**
+   * Cleans up orphaned vehicles that no longer exist.
+   */
+  cleanup(): void
+  /**
+   * Gets the total count of managed vehicles.
+   *
+   * @returns Vehicle count
+   */
+  getCount(): number
+  /**
+   * Serializes all vehicles for data transfer.
+   *
+   * @returns Array of serialized vehicle data
+   */
+  serializeAll(): SerializedVehicleData[]
+}