@battle-racing/br-common-lib 1.0.0

package/src/types/kartTracking/index.ts

@@ -0,0 +1,2 @@
+export * from './CheckpointEvent';
+export * from './KartTracking';

package/src/types/powerUp/PowerUp.ts

@@ -0,0 +1,50 @@
+import type {
+  BallSensorDiskThrowerModuleCommands,
+  DiskSensorBallShooterModuleCommands,
+  FlagModuleCommands,
+  LeftStarBackLaserModuleCommands,
+  RGBModuleCommands,
+  RightStarFrontLaserModuleCommands,
+  SoundModuleCommands,
+  SpeedModuleCommands,
+  SteeringWheelModuleCommands,
+} from '../command';
+import type { Damage } from '../damage';
+import type { PowerUpName } from './PowerUpName';
+import type { PowerUpShield } from './PowerUpShield';
+
+export type PowerUpLevel = 1 | 2 | 3 | 4 | 5;
+
+/**
+ * The Power-up command exclude the ScreenModuleCommands because
+ * the system needs to know to know in which kind of game is the kart.
+ */
+export type PowerUpCommand =
+  | BallSensorDiskThrowerModuleCommands
+  | DiskSensorBallShooterModuleCommands
+  | FlagModuleCommands
+  | RGBModuleCommands
+  | SpeedModuleCommands
+  | LeftStarBackLaserModuleCommands
+  | RightStarFrontLaserModuleCommands
+  | SteeringWheelModuleCommands
+  | SoundModuleCommands;
+
+export interface PowerUp {
+  id: string;
+  name: PowerUpName;
+  imageName: string;
+  description: string;
+  level: PowerUpLevel;
+
+  /** Commands to be executed when the power-up is assigned */
+  assignationCommands: PowerUpCommand[];
+  /** Whenever the user activates the assigned power-up */
+  activationCommands: PowerUpCommand[];
+  shield?: PowerUpShield;
+  /**
+   * Represents damage that needs the backend to be propagated
+   * to other(s) kart(s)
+   */
+  networkDamage?: Damage;
+}

package/src/types/powerUp/PowerUpName.ts

@@ -0,0 +1,9 @@
+export type PowerUpName =
+  | 'Battle God'
+  | 'Battle Star'
+  | 'Battle Shot'
+  | 'Battle Nitro'
+  | 'Battle Pulse'
+  | 'Battle Trap'
+  | 'Battle Shield'
+  | 'Battle Turbo';

package/src/types/powerUp/PowerUpShield.ts

@@ -0,0 +1,6 @@
+export interface PowerUpShield {
+  /**
+   * Time of the event in seconds
+   */
+  duration: number;
+}

package/src/types/powerUp/PowerUpTarget.ts

@@ -0,0 +1,12 @@
+import type { ObjectValues } from '../utils';
+
+const POWER_UP_TARGET = {
+  /** Affect the owner of the power-up */
+  Self: 'Self',
+  /** Affect a single Kart */
+  Any: 'Any',
+  /** Affect all the other Karts in game (must communicate to the server) */
+  All: 'All',
+} as const;
+
+export type PowerUpTarget = ObjectValues<typeof POWER_UP_TARGET>;

package/src/types/powerUp/PowerUpType.ts

@@ -0,0 +1,9 @@
+import type { ObjectValues } from '../utils';
+
+const POWER_UP_TYPE = {
+  Damage: 'Damage',
+  Shield: 'Shield',
+  Speed: 'Speed',
+} as const;
+
+export type PowerUpType = ObjectValues<typeof POWER_UP_TYPE>;

package/src/types/powerUp/index.ts

@@ -0,0 +1,5 @@
+export * from './PowerUp';
+export * from './PowerUpName';
+export * from './PowerUpShield';
+export * from './PowerUpTarget';
+export * from './PowerUpType';

package/src/types/response/ErrorResponse.ts

@@ -0,0 +1,6 @@
+export interface ErrorResponse {
+  status: 'error';
+  code: number;
+  errorType: string;
+  message: string;
+}

package/src/types/response/Response.ts

@@ -0,0 +1,4 @@
+import type { ErrorResponse } from './ErrorResponse';
+import type { SuccesResponse } from './SuccesResponse';
+
+export type Response<T> = SuccesResponse<T> | ErrorResponse;

package/src/types/response/SuccesResponse.ts

@@ -0,0 +1,5 @@
+export interface SuccesResponse<T> {
+  status: 'success';
+  code: 200;
+  data?: T;
+}

package/src/types/response/index.ts

@@ -0,0 +1,3 @@
+export type { ErrorResponse } from './ErrorResponse';
+export type { SuccesResponse } from './SuccesResponse';
+export type { Response } from './Response';

package/src/types/socket/SocketHardwareModulesEventsParams.ts

@@ -0,0 +1,106 @@
+import type {
+  ConfigDiskSensorBallShooterModuleOptions,
+  ConfigureBallSensorDiskThrowerModuleOptions,
+  FlagConfigurationOptions,
+  FlagShowMediaOptions,
+  PlaySoundOptions,
+  RGBConfigurationOptions,
+  RGBShowEffectOptions,
+  ScreenCountdownParams,
+  ScreenFinishViewInput,
+  ScreenUpdateGameViewInput,
+  SpeedChangeOptions,
+  SpeedConfiguration,
+  StarLaserConfigureModuleOptions,
+  StarLaserSendActionsOptions,
+} from '../hardware';
+
+export type SocketHardwareDataSubscriptionEventsParams = {
+  'hardware:data:subscribe': undefined;
+  'hardware:data:unsubscribe': undefined;
+};
+
+export type SocketHardwareBallSensorDiskThrowerModuleEventsParams = {
+  'hardware:ball-sensor-disk-thrower:activateSensor': undefined;
+  'hardware:ball-sensor-disk-thrower:deactivateSensor': undefined;
+  'hardware:ball-sensor-disk-thrower:configureModule': ConfigureBallSensorDiskThrowerModuleOptions;
+  'hardware:ball-sensor-disk-thrower:throwDisk': undefined;
+  'hardware:ball-sensor-disk-thrower:activateDiskThrower': undefined;
+  'hardware:ball-sensor-disk-thrower:deactivateDiskThrower': undefined;
+};
+
+export type SocketHardwareDiskSensorBallShooterModuleEventsParams = {
+  'hardware:disk-sensor-ball-shooter:configure': ConfigDiskSensorBallShooterModuleOptions;
+  'hardware:disk-sensor-ball-shooter:prepareShooter': undefined;
+  'hardware:disk-sensor-ball-shooter:shootBall': undefined;
+  'hardware:disk-sensor-ball-shooter:activateSensor': undefined;
+  'hardware:disk-sensor-ball-shooter:deactivateSensor': undefined;
+  'hardware:disk-sensor-ball-shooter:calibrateSensor': undefined;
+};
+
+export type SocketHardwareFlagModuleEventsParams = {
+  'hardware:flag:activate': undefined;
+  'hardware:flag:deactivate': undefined;
+  'hardware:flag:configure': FlagConfigurationOptions;
+  'hardware:flag:showMediaIndefinitely': FlagShowMediaOptions;
+  'hardware:flag:showMediaTemporarily': FlagShowMediaOptions;
+};
+
+export type SocketHardwareRGBModuleEventsParams = {
+  'hardware:rgb:configure': RGBConfigurationOptions;
+  'hardware:rgb:showEffect': RGBShowEffectOptions;
+};
+
+export type SocketHardwareSpeedModuleEventsParams = {
+  'hardware:speed:activate': undefined;
+  'hardware:speed:deactivate': undefined;
+  'hardware:speed:update': SpeedChangeOptions;
+  'hardware:speed:configure': SpeedConfiguration;
+};
+
+export type SocketHardwareLeftStarBackLaserModuleEventsParams = {
+  'hardware:left-star-back-laser:action': StarLaserSendActionsOptions;
+  'hardware:left-star-back-laser:configure': StarLaserConfigureModuleOptions;
+};
+
+export type SocketHardwareRightStarFrontLaserModuleEventsParams = {
+  'hardware:right-star-front-laser:action': StarLaserSendActionsOptions;
+  'hardware:right-star-front-laser:configure': StarLaserConfigureModuleOptions;
+};
+
+export type SocketHardwareScreenModuleEventsParams = {
+  'hardware:screen:showHomeView': undefined;
+  'hardware:screen:showCountdownView': ScreenCountdownParams;
+  'hardware:screen:updateGameView': ScreenUpdateGameViewInput;
+  'hardware:screen:showScreenVictoryView': ScreenFinishViewInput;
+  'hardware:screen:showScreenDefeatView': ScreenFinishViewInput;
+};
+
+export type SocketHardwareSteeringWheelModuleEventsParams = {
+  'hardware:steering-wheel:turnLedOn': undefined;
+  'hardware:steering-wheel:turnLedOff': undefined;
+};
+
+export type SocketHardwareSoundModuleEventsParams = {
+  'hardware:sound:play': PlaySoundOptions;
+};
+
+// UNIQUE FOR GAME TRACK RPI
+export type SocketHardwareEmergencyModuleEventsParams = {
+  'hardware:emergency:activate': undefined;
+  'hardware:emergency:deactivate': undefined;
+};
+
+// Just the union of all the events params
+export type SocketHardwareModulesEventsParams = SocketHardwareBallSensorDiskThrowerModuleEventsParams &
+  SocketHardwareDiskSensorBallShooterModuleEventsParams &
+  SocketHardwareFlagModuleEventsParams &
+  SocketHardwareRGBModuleEventsParams &
+  SocketHardwareSpeedModuleEventsParams &
+  SocketHardwareDataSubscriptionEventsParams &
+  SocketHardwareLeftStarBackLaserModuleEventsParams &
+  SocketHardwareRightStarFrontLaserModuleEventsParams &
+  SocketHardwareScreenModuleEventsParams &
+  SocketHardwareSteeringWheelModuleEventsParams &
+  SocketHardwareSoundModuleEventsParams &
+  SocketHardwareEmergencyModuleEventsParams;

package/src/types/socket/SocketHardwareOnDataEventsParams.ts

@@ -0,0 +1,27 @@
+import type {
+  BallSensorDiskThrowerModuleStatus,
+  DiskSensorBallShooterModuleStatus,
+  EmergencyModuleStatus,
+  FlagModuleStatus,
+  RGBModuleStatus,
+  SpeedModuleStatus,
+  StarLaserModuleStatus,
+  SteeringWheelModuleStatus,
+} from '../hardware';
+
+/** Data that are triggered from Hardware Modules of Kart */
+export type SocketHardwareOnDataEventsParams = {
+  'hardware:disk-sensor-ball-shooter:onModuleStatus': DiskSensorBallShooterModuleStatus;
+  'hardware:ball-sensor-disk-thrower:onModuleStatus': BallSensorDiskThrowerModuleStatus;
+  'hardware:rgb:onModuleStatus': RGBModuleStatus;
+  'hardware:flag:onModuleStatus': FlagModuleStatus;
+  'hardware:speed:onModuleStatus': SpeedModuleStatus;
+  'hardware:left-star-back-laser:onModuleStatus': StarLaserModuleStatus;
+  'hardware:right-star-front-laser:onModuleStatus': StarLaserModuleStatus;
+  'hardware:steering-wheel:onModuleStatus': SteeringWheelModuleStatus;
+};
+
+/** Data that are triggered from Hardware Modules of Game Track */
+export type SocketGameTrackHardwareOnDataEventsParams = {
+  'hardware:emergency:onModuleStatus': EmergencyModuleStatus;
+};

package/src/types/socket/SocketPowerUpEventsParams.ts

@@ -0,0 +1,13 @@
+import type { DamageEffectName } from '../damage';
+import type { PowerUp } from '../powerUp';
+
+export type SocketPowerUpEventsParams = {
+  /** Assign the Powerup, shouldOverride will force the assignation */
+  'powerUp:assign': { powerUpId: PowerUp['id']; shouldOverride?: boolean };
+  /** Affect the Kart by a Damage */
+  'powerUp:damage': { damageName: DamageEffectName };
+  /** Trigger the Powerup */
+  'powerUp:execute': { powerUpId?: PowerUp['id'] };
+  /** Sync PowerUps */
+  'powerUps:sync': { powerUps: PowerUp[] };
+};

package/src/types/socket/clientToServer/SocketGameTrackClientToServerEventsParams.ts

@@ -0,0 +1,7 @@
+export interface SocketGameTrackClientToServerEventsParams {
+  'game-track:init': { macAddress: string };
+  /** Emergency Button Pressed phisicaly */
+  'game-track:emergency:buttonPressed': { macAddress: string };
+  /** Emergency Button released phisicaly */
+  'game-track:emergency:buttonReleased': { macAddress: string };
+}

package/src/types/socket/clientToServer/SocketKartClientToServerEventsParams.ts

@@ -0,0 +1,11 @@
+import type { DamageEffectName } from '../../damage';
+import type { SocketInitRaspberryInput, SocketRegisterKartCheckpointInput } from '../inputs';
+
+export interface SocketKartClientToServerEventsParams {
+  'kart:init': SocketInitRaspberryInput;
+  'kart:checkpoint': SocketRegisterKartCheckpointInput;
+  /** Activate the damage of a powerUp  */
+  'kart:damage:sent': { macAddress: string; damageName: DamageEffectName };
+  /** The Kart received damage  */
+  'kart:damage:received': { macAddress: string; damageName: DamageEffectName };
+}

package/src/types/socket/clientToServer/SocketWebAppClientToServerEventsParams.ts

@@ -0,0 +1,11 @@
+import type { Game, GameType } from '../../game';
+
+export interface SocketWebAppClientToServerEventsParams {
+  'karts:authenticate': { authToken: string };
+  'karts:list': undefined;
+  'karts:tracking:subscribe': { kartGuid: string };
+  'karts:tracking:unsubscribe': { kartGuid: string };
+  'game-changed:subscribe': { gameId: Game['id']; gameType: GameType };
+  'game-changed:unsubscribe': { gameId: Game['id']; gameType: GameType };
+  'game-tracks:list': undefined;
+}

package/src/types/socket/clientToServer/index.ts

@@ -0,0 +1,3 @@
+export * from './SocketGameTrackClientToServerEventsParams';
+export * from './SocketKartClientToServerEventsParams';
+export * from './SocketWebAppClientToServerEventsParams';

package/src/types/socket/index.ts

@@ -0,0 +1,7 @@
+export * from './clientToServer';
+export * from './inputs';
+export * from './serverToClient';
+export * from './SocketHardwareModulesEventsParams';
+export * from './SocketHardwareOnDataEventsParams';
+export * from './SocketPowerUpEventsParams';
+export * from './utils';

package/src/types/socket/inputs/MacAddressGameTrackConnection.ts

@@ -0,0 +1,7 @@
+import type { GameTrack } from '../../gameTrack';
+
+export interface MacAddressGameTrackConnection {
+  macAddress: string;
+  gameTrack: GameTrack | null;
+  isConnected: boolean;
+}

package/src/types/socket/inputs/SocketInitRaspberryInput.ts

@@ -0,0 +1,3 @@
+export type SocketInitRaspberryInput = {
+  macAddress: string;
+};

package/src/types/socket/inputs/SocketRegisterKartCheckpointInput.ts

@@ -0,0 +1,12 @@
+import type { Checkpoint } from '../../checkpoint';
+
+export type SocketRegisterKartCheckpointInput = {
+  /** The macAddress is necessary to avoid extra process in the backend to find the macAddress */
+  macAddress: string;
+  checkpointAddress: Checkpoint['address'];
+  checkpointType: Checkpoint['type'];
+  /** Just Request the power-up when there is no a power-up already assigned */
+  shouldRequestPowerUp: boolean;
+  /** The real time when the event was generated on RPI */
+  originTimestampISO: string;
+};

package/src/types/socket/inputs/index.ts

@@ -0,0 +1,3 @@
+export * from './SocketInitRaspberryInput';
+export * from './MacAddressGameTrackConnection';
+export * from './SocketRegisterKartCheckpointInput';

package/src/types/socket/serverToClient/SocketGameTrackServerToClientEventParams.ts

@@ -0,0 +1,14 @@
+import type { GameTrack } from '../../gameTrack';
+import type { Response } from '../../response';
+
+export interface SocketGameTrackEventsParams {
+  // Response from server (game-track:init)
+  'game-track:init:response': Response<GameTrack>;
+}
+
+export interface SocketGameTrackEventParams {
+  'game-track:emergency:activate': undefined;
+  'game-track:emergency:deactivate': undefined;
+}
+
+export type SocketGameTrackServerToClientEventsParams = SocketGameTrackEventsParams & SocketGameTrackEventParams;

package/src/types/socket/serverToClient/SocketKartServerToClientEventsParams.ts

@@ -0,0 +1,47 @@
+import type { Game, GameType } from '../../game';
+import type { GameTrack } from '../../gameTrack';
+import type { Kart } from '../../kart';
+import type { Response } from '../../response';
+import type { SocketPowerUpEventsParams } from '../SocketPowerUpEventsParams';
+
+interface BaseGameEventParams {
+  gameId: Game['id'];
+  gameType: GameType;
+}
+
+// Add the kart: prefix to the SocketPowerUpEventsParams
+export type SocketKartPowerUpEventsParams = {
+  [Key in keyof SocketPowerUpEventsParams as `kart:${Key}`]: SocketPowerUpEventsParams[Key];
+};
+
+export interface SocketKartEventsParams {
+  'kart:updated': { kart: Kart };
+  // Response from server
+  'kart:init:response': Response<Kart>;
+  /** Whenever the Game Track config changed */
+  'kart:gameTrack:updated': { gameTrack: GameTrack };
+  /** When the physical button of the game track is pressed */
+  'kart:gameTrack:emergency:started': undefined;
+  /** When the physical button of the game track is released */
+  'kart:gameTrack:emergency:stopped': undefined;
+}
+
+export interface SocketGameEventParams {
+  /** Kart is selected for a game */
+  'kart:game:selected': BaseGameEventParams;
+  /** Kart Is eliminated from a game (game is in progress) */
+  'kart:game:eliminated': BaseGameEventParams;
+  'kart:game:yellow-flag:started': BaseGameEventParams;
+  'kart:game:yellow-flag:stopped': BaseGameEventParams;
+  'kart:game:red-flag:started': BaseGameEventParams;
+  'kart:game:red-flag:stopped': BaseGameEventParams;
+
+  // Critical Game Events that require the whole game state to be sent
+  'kart:game:started': { game: Game };
+  'kart:game:finished': { game: Game; isWinner: boolean };
+  'kart:game:sync': { game: Game };
+}
+
+export type SocketKartServerToClientEventsParams = SocketKartEventsParams &
+  SocketGameEventParams &
+  SocketKartPowerUpEventsParams;

package/src/types/socket/serverToClient/SocketWebAppServerToClientEventsParams.ts

@@ -0,0 +1,23 @@
+import type { Game } from '../../game';
+import type { Kart } from '../../kart';
+import type { CheckpointEvent } from '../../kartTracking';
+import type { Response } from '../../response';
+import type { MacAddressGameTrackConnection } from '../inputs';
+import type { SocketHardwareOnDataEventsParams } from '../SocketHardwareOnDataEventsParams';
+
+export interface SocketWebAppServerToClientEventsParams {
+  'karts:authenticate:response': Response<void>;
+  'karts:list:response': Response<Kart[]>;
+  'karts:onKartsUpdated': Kart[];
+  'karts:onHardwareData': {
+    kartGuid: string;
+    socketEvent: keyof SocketHardwareOnDataEventsParams;
+    payload: SocketHardwareOnDataEventsParams[keyof SocketHardwareOnDataEventsParams];
+  };
+  'karts:tracking:checkpointEvent': {
+    checkpointEvent: CheckpointEvent;
+  };
+  'game:changed': { game: Game };
+  'gameTracks:onGameTrackUpdated': MacAddressGameTrackConnection[];
+  'gameTracks:list:response': Response<MacAddressGameTrackConnection[]>;
+}

package/src/types/socket/serverToClient/index.ts

@@ -0,0 +1,3 @@
+export * from './SocketGameTrackServerToClientEventParams';
+export * from './SocketKartServerToClientEventsParams';
+export * from './SocketWebAppServerToClientEventsParams';

package/src/types/socket/utils/SocketParamsToEvents.ts

@@ -0,0 +1,16 @@
+/** Map the Events Params Types to Event to be used on Socket.io  */
+export type EmptyEventParams = () => void;
+export type EventParams<EventParams> = (payload: EventParams) => void;
+//With Extra
+export type EmptyEventParamsWithExtra<Extra> = (params: Extra) => void;
+export type EventParamsWithExtra<EventParams, Extra> = (params: Extra & { payload: EventParams }) => void;
+
+export type SocketParamsToEvents<Event, Extra = undefined> = {
+  [EventKey in keyof Event]: Event[EventKey] extends undefined
+    ? Extra extends undefined
+      ? EmptyEventParams
+      : EmptyEventParamsWithExtra<Extra>
+    : Extra extends undefined
+      ? EventParams<Event[EventKey]>
+      : EventParamsWithExtra<Event[EventKey], Extra>;
+};

package/src/types/socket/utils/index.ts

@@ -0,0 +1 @@
+export * from './SocketParamsToEvents';

package/src/types/sounds/SoundName.ts

@@ -0,0 +1,24 @@
+export type SoundName =
+  | 'battle_god_activation.mp3'
+  | 'battle_laser_activation.mp3'
+  | 'battle_laser_damage.mp3'
+  | 'battle_pulse_activation.mp3'
+  | 'battle_pulse_damage.mp3'
+  | 'battle_shield_activation.mp3'
+  | 'battle_shot_activation.mp3'
+  | 'battle_shot_damage.mp3'
+  | 'battle_star_damage.mp3'
+  | 'battle_trap_activation.mp3'
+  | 'battle_trap_damage.mp3'
+  | 'battle_turbo_activation.mp3'
+  | 'countdown_3_2_1.mp3'
+  | 'emergency_alert.mp3'
+  | 'engine_start.mp3'
+  | 'final_lap_mario_kart.mp3'
+  | 'kart_skiding.mp3'
+  | 'pick_coin_x2.mp3'
+  | 'power_up_selection.mp3'
+  | 'sad_trumpet_loser.mp3'
+  | 'system_started.mp3'
+  | 'warning_alert_this_is_not_a_test.mp3'
+  | 'winner_laugh.mp3';

package/src/types/sounds/index.ts

@@ -0,0 +1 @@
+export * from './SoundName';

package/src/types/user/User.ts

@@ -0,0 +1,8 @@
+import type { UserOrigin } from './UserOrigin';
+
+export interface User {
+  id: string;
+  username: string;
+  name: string;
+  origin: UserOrigin;
+}

package/src/types/user/UserOrigin.ts

@@ -0,0 +1 @@
+export type UserOrigin = 'webapp' | 'hardware';

package/src/types/user/index.ts

@@ -0,0 +1,2 @@
+export * from './User';
+export * from './UserOrigin';

package/src/types/utils/ArithmeticString.ts

@@ -0,0 +1,17 @@
+export type ArithmeticOperator = '+' | '-' | '*' | '/';
+
+/**
+ * The Value is determined by an arithmetic operator followed by a number.
+ */
+export type SimpleArithmeticString = `${ArithmeticOperator}${number}`;
+
+export type KartContextVariable = '$kart.configuredSpeed';
+
+export type ContextVariable = KartContextVariable;
+
+export type ContextArithmeticString =
+  // Example: $kart.configuredSpeed + 1
+  `${ContextVariable} ${ArithmeticOperator} ${number}`;
+
+// Unión de todos los posibles formatos de expresión
+export type ArithmeticExpression = number | SimpleArithmeticString | ContextArithmeticString;

package/src/types/utils/ObjectValues.ts

@@ -0,0 +1,2 @@
+// Create a type from the object values
+export type ObjectValues<T> = T[keyof T];

package/src/types/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './ObjectValues';
+export * from './ArithmeticString';

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist",
+    "declaration": true,
+    "moduleResolution": "node",
+    "target": "es2020",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}