@battle-racing/br-common-lib 3.8.0 → 4.1.0

package/src/domains/hardware/lights/Lights.const.ts

@@ -0,0 +1,11 @@
+export const LIGHTS_EFFECT = {
+  SHOW_UV_COLOR: 'SHOW_UV_COLOR',
+  POWER_OFF: 'POWER_OFF',
+  // GAME EFFECTS
+  START_GAME: 'START_GAME',
+  GAME_OVER: 'GAME_OVER',
+  FINAL_LAP: 'FINAL_LAP',
+  YELLOW_FLAG: 'YELLOW_FLAG',
+  RED_FLAG: 'RED_FLAG',
+  PULSE: 'PULSE',
+} as const;

package/src/domains/hardware/lights/Lights.schema.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { LIGHTS_EFFECT } from './Lights.const';
+
+export const lightsEffectSchema = z.enum(LIGHTS_EFFECT);
+
+export const showLightsColorParamsSchema = z.object({
+  address: z.union([z.array(z.number()), z.literal('all')]),
+  timeDuration: z.number().min(1).max(25),
+  color: z.string(), // Hex RGB
+});
+
+export const showLightsEffectParamsSchema = z.object({
+  addresses: z.union([z.array(z.number()), z.literal('all')]),
+  effect: lightsEffectSchema,
+  timeDuration: z.number().min(1).max(25),
+});

package/src/domains/hardware/lights/Lights.types.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { lightsEffectSchema, showLightsColorParamsSchema, showLightsEffectParamsSchema } from './Lights.schema';
+
+export type LightsEffect = z.infer<typeof lightsEffectSchema>;
+export type ShowLightsColorParams = z.infer<typeof showLightsColorParamsSchema>;
+export type ShowLightsEffectParams = z.infer<typeof showLightsEffectParamsSchema>;

package/src/domains/hardware/lights/index.ts

@@ -0,0 +1,3 @@
+export * from './Lights.const';
+export * from './Lights.schema';
+export * from './Lights.types';

package/src/domains/hardware/rgb/RGB.const.ts

@@ -0,0 +1,8 @@
+export const RGB_STATUS = {
+  SHOWING_COLOR: 'Showing Color',
+  NOT_CONFIGURED: 'Not Configured',
+  CONFIGURING_RGB: 'Configuring RGB',
+  SHOWING_EFFECT: 'Showing Effect',
+  UNKNOWN: 'Unknown',
+  ERROR: 'Error',
+} as const;

package/src/domains/hardware/rgb/RGB.schema.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { colorNameSchema } from '../../color';
+import { kartEffectSchema } from '../../hardware/kart-effect';
+import { RGB_STATUS } from './RGB.const';
+
+export const rgbStatusSchema = z.enum(RGB_STATUS);
+
+export const rgbModuleStatusSchema = z.object({
+  rgbStatus: rgbStatusSchema,
+  kartColor: colorNameSchema,
+});
+
+export const rgbConfigurationOptionsSchema = z.object({
+  kartColor: colorNameSchema,
+  brightness: z.number().min(0).max(100),
+  effectTime: z.number().min(1).max(25),
+});
+
+export const rgbShowEffectOptionsSchema = z.object({
+  effect: kartEffectSchema,
+});

package/src/domains/hardware/rgb/RGB.types.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import {
+  rgbConfigurationOptionsSchema,
+  rgbModuleStatusSchema,
+  rgbShowEffectOptionsSchema,
+  rgbStatusSchema,
+} from './RGB.schema';
+
+export type RGBStatus = z.infer<typeof rgbStatusSchema>;
+export type RGBModuleStatus = z.infer<typeof rgbModuleStatusSchema>;
+export type RGBConfigurationOptions = z.infer<typeof rgbConfigurationOptionsSchema>;
+export type RGBShowEffectOptions = z.infer<typeof rgbShowEffectOptionsSchema>;

package/src/domains/hardware/rgb/index.ts

@@ -0,0 +1,3 @@
+export * from './RGB.const';
+export * from './RGB.schema';
+export * from './RGB.types';

package/src/domains/hardware/screen/Screen.const.ts

@@ -0,0 +1,17 @@
+export const SCREEN_STATUS = {
+  ACTIVATED: 'Activated',
+  DEACTIVATED: 'Deactivated',
+  UNKNOWN: 'Unknown',
+  ERROR: 'Error',
+  DEBUG: 'Debug',
+} as const;
+
+export const SCREEN_VIEW = {
+  HOME: 'Home',
+  COUNTDOWN: 'Countdown',
+  RACE: 'Race',
+  GAME_SUMMARY: 'GameSummary',
+  INSTRUCTION_VIDEO: 'InstructionVideo',
+  BATTLE: 'Battle',
+  DEBUG: 'Debug',
+} as const;

package/src/domains/hardware/screen/Screen.schema.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+
+import { damageEffectNameSchema } from '../../damage';
+import { kartHardwareStateSchema } from '../../hardware';
+import { powerUpNameSchema } from '../../powerUp/PowerUpAttributes.schema';
+import { SCREEN_STATUS, SCREEN_VIEW } from './Screen.const';
+import { KART_FINAL_STATE } from '../../kart';
+
+export const screenStatusSchema = z.enum(SCREEN_STATUS);
+export const screenViewSchema = z.enum(SCREEN_VIEW);
+// KART_FINAL_STATE is { FINISHED: 'finished', ... } as const. z.nativeEnum works with it.
+export const kartFinalStateSchema = z.enum(KART_FINAL_STATE);
+
+export const screenModuleStatusSchema = z.object({
+  latestView: screenViewSchema,
+  screenStatus: screenStatusSchema,
+});
+
+export const screenCurrentTotalSchema = z.object({
+  current: z.number().nullable(),
+  total: z.number().nullable(),
+});
+
+export const screenGameTimeLeftSchema = z.object({
+  minutes: z.number().nullable().optional(),
+  seconds: z.number().nullable().optional(),
+});
+
+export const screenViewBaseConfigSchema = z.object({
+  position: screenCurrentTotalSchema.optional(),
+  coins: z.number().nullable().optional(),
+  gameTimeLeft: screenGameTimeLeftSchema.optional(),
+  powerUp: z
+    .union([powerUpNameSchema, z.literal('Clear PowerUp')])
+    .nullable()
+    .optional(),
+  powerUpAnimationTimeSeconds: z.number().nullable().optional(),
+  damageEffect: z
+    .union([damageEffectNameSchema, z.literal('Yellow Flag'), z.literal('Red Flag')])
+    .nullable()
+    .optional(),
+  damageAnimationTimeSeconds: z
+    .union([z.literal('Infinite'), z.number()])
+    .nullable()
+    .optional(),
+});
+
+export const screenRaceViewConfigSchema = screenViewBaseConfigSchema.extend({
+  laps: screenCurrentTotalSchema.optional(),
+});
+
+export const screenBattleViewConfigSchema = screenViewBaseConfigSchema.extend({
+  lives: screenCurrentTotalSchema.optional(),
+});
+
+export const countDownNextViewRaceSchema = z.object({
+  nextView: z.literal('Race'),
+  config: screenRaceViewConfigSchema,
+});
+export const countDownNextViewBattleSchema = z.object({
+  nextView: z.literal('Battle'),
+  config: screenBattleViewConfigSchema,
+});
+
+export const screenCountdownParamsSchema = z.union([countDownNextViewRaceSchema, countDownNextViewBattleSchema]);
+
+export const updateRaceViewInputSchema = z.object({ view: z.literal('Race'), config: screenRaceViewConfigSchema });
+export const updateBattleViewInputSchema = z.object({
+  view: z.literal('Battle'),
+  config: screenBattleViewConfigSchema,
+});
+
+export const screenUpdateGameViewInputSchema = z.union([updateRaceViewInputSchema, updateBattleViewInputSchema]);
+
+export const screenFinishViewInputSchema = z.object({
+  kartNumber: z.number().optional(),
+  kartPosition: screenCurrentTotalSchema,
+  coins: z.number(),
+  finalState: kartFinalStateSchema.optional(),
+});
+
+export const screenDebugViewInputSchema = kartHardwareStateSchema.extend({
+  kartNumber: z.number(),
+});
+
+export const screenHomeViewInputSchema = z.object({
+  kartNumber: z.number().nullable().optional(),
+});

package/src/domains/hardware/screen/Screen.types.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import {
+  countDownNextViewBattleSchema,
+  countDownNextViewRaceSchema,
+  screenBattleViewConfigSchema,
+  screenCountdownParamsSchema,
+  screenDebugViewInputSchema,
+  screenFinishViewInputSchema,
+  screenGameTimeLeftSchema,
+  screenHomeViewInputSchema,
+  screenModuleStatusSchema,
+  screenRaceViewConfigSchema,
+  screenStatusSchema,
+  screenUpdateGameViewInputSchema,
+  screenViewBaseConfigSchema,
+  screenViewSchema,
+  updateBattleViewInputSchema,
+  updateRaceViewInputSchema,
+} from './Screen.schema';
+
+export type ScreenStatus = z.infer<typeof screenStatusSchema>;
+export type ScreenView = z.infer<typeof screenViewSchema>;
+export type ScreenModuleStatus = z.infer<typeof screenModuleStatusSchema>;
+
+export type ScreenViewBaseConfig = z.infer<typeof screenViewBaseConfigSchema>;
+export type ScreenRaceViewConfig = z.infer<typeof screenRaceViewConfigSchema>;
+export type ScreenBattleViewConfig = z.infer<typeof screenBattleViewConfigSchema>;
+
+export type ScreenGameTimeLeft = z.infer<typeof screenGameTimeLeftSchema>;
+export type CountDownNextViewRace = z.infer<typeof countDownNextViewRaceSchema>;
+export type CountDownNextViewBattle = z.infer<typeof countDownNextViewBattleSchema>;
+export type ScreenCountdownParams = z.infer<typeof screenCountdownParamsSchema>;
+
+export type UpdateRaceViewInput = z.infer<typeof updateRaceViewInputSchema>;
+export type UpdateBattleViewInput = z.infer<typeof updateBattleViewInputSchema>;
+export type ScreenUpdateGameViewInput = z.infer<typeof screenUpdateGameViewInputSchema>;
+export type ScreenFinishViewInput = z.infer<typeof screenFinishViewInputSchema>;
+export type ScreenDebugViewInput = z.infer<typeof screenDebugViewInputSchema>;
+export type ScreenHomeViewInput = z.infer<typeof screenHomeViewInputSchema>;

package/src/domains/hardware/screen/index.ts

@@ -0,0 +1,3 @@
+export * from './Screen.const';
+export * from './Screen.schema';
+export * from './Screen.types';

package/src/domains/hardware/sound/Sound.const.ts

@@ -0,0 +1,3 @@
+export const PLAY_SOUND_DURATION = {
+  INFINITE: 'infinite',
+} as const;

package/src/domains/hardware/sound/Sound.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { soundNameSchema } from '../../sounds'; // Import from domains/sounds
+import { PLAY_SOUND_DURATION } from './Sound.const';
+
+export const playSoundOptionsSchema = z.object({
+  soundName: soundNameSchema,
+  durationMs: z.union([z.number(), z.literal(PLAY_SOUND_DURATION.INFINITE)]).optional(),
+});

package/src/domains/hardware/sound/Sound.types.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { playSoundOptionsSchema } from './Sound.schema';
+
+export type PlaySoundOptions = z.infer<typeof playSoundOptionsSchema>;

package/src/domains/hardware/sound/index.ts

@@ -0,0 +1,3 @@
+export * from './Sound.const';
+export * from './Sound.schema';
+export * from './Sound.types';

package/src/domains/hardware/speed/Speed.const.ts

@@ -0,0 +1,17 @@
+export const SPEED_STATUS = {
+  ACTIVATED: 'Activated',
+  DEACTIVATED: 'Deactivated',
+  UNKNOWN: 'Unknown',
+  ERROR: 'Error',
+  STANDBY: 'Standby',
+  CHANGING_SPEED: 'Changing Speed',
+  IN_EMERGENCY: 'In Emergency',
+} as const;
+
+export const SPEED_ACTION_COMMAND = {
+  ACTIVATE: 'Activate',
+  DEACTIVATE: 'Deactivate',
+  CHANGE_SPEED: 'ChangeSpeed',
+  CONFIGURE: 'Configure',
+  RESTART: 'Restart',
+} as const;

package/src/domains/hardware/speed/Speed.schema.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { SPEED_ACTION_COMMAND, SPEED_STATUS } from './Speed.const';
+
+export const speedStatusSchema = z.enum(SPEED_STATUS);
+
+export const speedModuleStatusSchema = z.object({
+  speedStatus: speedStatusSchema,
+  battery12V: z.number(),
+  currentSpeed: z.number(),
+  ADCVoltage: z.number(),
+  DACVoltage: z.number(),
+  currentDefaultSpeedConfig: z.number(),
+});
+
+export const speedActionCommandSchema = z.enum(SPEED_ACTION_COMMAND);
+
+export const speedChangeOptionsSchema = z.object({
+  speed: z.number().min(0).max(100),
+  forUnlimitedTime: z.boolean().optional(),
+});
+
+export const speedConfigurationSchema = z.object({
+  defaultSpeed: z.number().min(0).max(100),
+  timeDuration: z.number().min(1).max(25),
+});

package/src/domains/hardware/speed/Speed.types.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import {
+  speedActionCommandSchema,
+  speedChangeOptionsSchema,
+  speedConfigurationSchema,
+  speedModuleStatusSchema,
+  speedStatusSchema,
+} from './Speed.schema';
+
+export type SpeedStatus = z.infer<typeof speedStatusSchema>;
+export type SpeedModuleStatus = z.infer<typeof speedModuleStatusSchema>;
+export type SpeedActionCommand = z.infer<typeof speedActionCommandSchema>;
+export type SpeedChangeOptions = z.infer<typeof speedChangeOptionsSchema>;
+export type SpeedConfiguration = z.infer<typeof speedConfigurationSchema>;

package/src/domains/hardware/speed/index.ts

@@ -0,0 +1,3 @@
+export * from './Speed.const';
+export * from './Speed.schema';
+export * from './Speed.types';

package/src/domains/hardware/star-laser/StarLaser.const.ts

@@ -0,0 +1,16 @@
+export const STAR_LASER_COMMAND = {
+  ACTIVATE: 'Activate',
+  DEACTIVATE: 'Deactivate',
+  INIT_ATTACK: 'Init Attack',
+  CONFIGURE: 'Configure',
+  NONE: 'None',
+} as const;
+
+export const STAR_LASER_STATUS = {
+  STANDBY: 'Standby',
+  ACTIVATED: 'Activated',
+  DEACTIVATED: 'Deactivated',
+  ATTACKING: 'Attacking',
+  HIT: 'Hit',
+  UNKNOWN: 'Unknown',
+} as const;

package/src/domains/hardware/star-laser/StarLaser.schema.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { STAR_LASER_COMMAND, STAR_LASER_STATUS } from './StarLaser.const';
+
+export const starLaserCommandSchema = z.enum(STAR_LASER_COMMAND);
+
+export const starLaserStatusSchema = z.enum(STAR_LASER_STATUS);
+
+export const starLaserConfigureModuleOptionsSchema = z.object({
+  kartId: z.number(),
+  starAttackTime: z.number().min(1).max(25),
+  laserAttackTime: z.number().min(1).max(25),
+});
+
+export const starLaserSendActionsOptionsSchema = z.object({
+  starAction: starLaserCommandSchema.optional(),
+  laserAction: starLaserCommandSchema.optional(),
+});
+
+export const starLaserModuleStatusSchema = z.object({
+  starStatus: starLaserStatusSchema,
+  laserStatus: starLaserStatusSchema,
+  starHitByKartId: z.number().nullable(),
+  laserHitByKartId: z.number().nullable(),
+});

package/src/domains/hardware/star-laser/StarLaser.types.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import {
+  starLaserCommandSchema,
+  starLaserConfigureModuleOptionsSchema,
+  starLaserModuleStatusSchema,
+  starLaserSendActionsOptionsSchema,
+  starLaserStatusSchema,
+} from './StarLaser.schema';
+
+export type StarLaserCommand = z.infer<typeof starLaserCommandSchema>;
+export type StarLaserStatus = z.infer<typeof starLaserStatusSchema>;
+export type StarLaserConfigureModuleOptions = z.infer<typeof starLaserConfigureModuleOptionsSchema>;
+export type StarLaserSendActionsOptions = z.infer<typeof starLaserSendActionsOptionsSchema>;
+export type StarLaserModuleStatus = z.infer<typeof starLaserModuleStatusSchema>;

package/src/domains/hardware/star-laser/index.ts

@@ -0,0 +1,3 @@
+export * from './StarLaser.const';
+export * from './StarLaser.schema';
+export * from './StarLaser.types';

package/src/domains/hardware/steering-wheel/SteeringWheel.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+
+export const steeringWheelModuleStatusSchema = z.object({
+  isLeftButtonPressed: z.boolean(),
+  isRightButtonPressed: z.boolean(),
+});

package/src/domains/hardware/steering-wheel/SteeringWheel.types.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { steeringWheelModuleStatusSchema } from './SteeringWheel.schema';
+
+export type SteeringWheelModuleStatus = z.infer<typeof steeringWheelModuleStatusSchema>;

package/src/domains/hardware/steering-wheel/index.ts

@@ -0,0 +1,2 @@
+export * from './SteeringWheel.schema';
+export * from './SteeringWheel.types';

package/src/domains/index.ts

@@ -0,0 +1,20 @@
+export * from './checkpoint';
+export * from './color';
+export * from './damage';
+export * from './command';
+export * from './flow';
+export * from './game';
+export * from './gameTrack';
+export * from './hardware';
+export * from './kart';
+export * from './kartTracking';
+export * from './powerUp';
+export * from './racingTeam';
+export * from './socket';
+export * from './ticketing';
+export * from './user';
+export * from './pagination';
+export * from './response';
+export * from './role';
+export * from './sounds';
+export * from './utils';

package/src/domains/kart/Kart.const.ts

@@ -0,0 +1,13 @@
+export const KART_STATUS = {
+  STAND_BY: 'standBy',
+  IN_GAME: 'in-game',
+  YELLOW_FLAG: 'yellow-flag',
+  EMERGENCY: 'emergency',
+  PITS: 'pits',
+  ELIMINATED: 'eliminated',
+} as const;
+
+export const KART_FINAL_STATE = {
+  VICTORY: 'Victory',
+  DEFEAT: 'Defeat',
+} as const;

package/src/domains/kart/Kart.schema.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { colorNameSchema } from '../color';
+import { damageEffectNameSchema } from '../damage';
+import { gameTypeSchema } from '../game';
+import { kartHardwareStateSchema } from '../hardware';
+import { powerUpNameSchema } from '../powerUp/PowerUpAttributes.schema';
+import { KART_STATUS } from './Kart.const';
+
+export const kartStatusSchema = z.enum(KART_STATUS);
+
+export const kartShieldSchema = z.object({
+  isActive: z.boolean(),
+  duration: z.number(),
+});
+
+export const kartGameSchema = z.object({
+  id: z.number(),
+  type: gameTypeSchema,
+});
+
+export const kartSchema = z.object({
+  guid: z.string(),
+  id: z.number(),
+  mac: z.string(),
+  hostname: z.string(),
+  isConnected: z.boolean(),
+  status: kartStatusSchema,
+  shield: kartShieldSchema,
+  gameTrackId: z.string(),
+  color: colorNameSchema,
+  number: z.number(),
+  currentGame: kartGameSchema.nullable().optional(),
+  description: z.string().nullable().optional(),
+  isSubscribedToHardwareStatus: z.boolean(),
+  hardwareState: kartHardwareStateSchema.nullable().optional(),
+  currentPowerUp: powerUpNameSchema.nullable().optional(),
+  currentDamage: damageEffectNameSchema.nullable().optional(),
+});

package/src/domains/kart/Kart.types.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { kartGameSchema, kartSchema, kartShieldSchema, kartStatusSchema } from './Kart.schema';
+
+export type KartStatus = z.infer<typeof kartStatusSchema>;
+export type KartShield = z.infer<typeof kartShieldSchema>;
+export type KartGame = z.infer<typeof kartGameSchema>;
+export type Kart = z.infer<typeof kartSchema>;

package/src/domains/kart/KartHardwareState.schema.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { checkpointTypeSchema } from '../checkpoint';
+import { flagStatusSchema, rgbStatusSchema, screenStatusSchema, speedStatusSchema } from '../hardware';
+
+export const kartHardwareStateSchema = z.object({
+  speed: z
+    .object({
+      status: speedStatusSchema,
+      current: z.number(),
+      configured: z.number(),
+    })
+    .nullable(),
+  rgb: rgbStatusSchema.nullable(),
+  flag: z
+    .object({
+      status: flagStatusSchema,
+      checkpointType: checkpointTypeSchema.nullable(),
+      checkpointAddress: z.number().nullable(),
+    })
+    .nullable(),
+  screen: screenStatusSchema.nullable(),
+  isConnectedToServer: z.boolean(),
+  isSteeringWheelPressed: z.boolean(),
+});

package/src/domains/kart/index.ts

@@ -0,0 +1,3 @@
+export * from './Kart.const';
+export * from './Kart.schema';
+export * from './Kart.types';

package/src/domains/kartTracking/KartTracking.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { checkpointSchema } from '../checkpoint';
+
+export const checkpointEventSchema = checkpointSchema.extend({
+  index: z.number(),
+  timestampISO: z.object({
+    origin: z.string(),
+    server: z.string(),
+  }),
+});
+
+export const kartTrackingSchema = z.object({
+  macAddress: z.string(),
+  checkpointsEvents: z.array(checkpointEventSchema).optional(),
+});

package/src/domains/kartTracking/KartTracking.types.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { checkpointEventSchema, kartTrackingSchema } from './KartTracking.schema';
+
+export type CheckpointEvent = z.infer<typeof checkpointEventSchema>;
+export type KartTracking = z.infer<typeof kartTrackingSchema>;

package/src/domains/kartTracking/index.ts

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

package/src/domains/pagination/Pagination.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export const paginationMetadataSchema = z.object({
+  nextCursor: z.string().optional(),
+  hasMore: z.boolean().optional(),
+  limit: z.number(),
+});
+
+export const paginatedResponseSchema = <T extends z.ZodTypeAny>(itemSchema: T) => {
+  return z.object({
+    data: z.array(itemSchema),
+    meta: paginationMetadataSchema,
+  });
+};

package/src/domains/pagination/Pagination.types.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { paginationMetadataSchema } from './Pagination.schema';
+
+export type Pagination = z.infer<typeof paginationMetadataSchema>;

package/src/domains/pagination/index.ts

@@ -0,0 +1,2 @@
+export * from './Pagination.schema';
+export * from './Pagination.types';

package/src/domains/powerUp/PowerUp.const.ts

@@ -0,0 +1,23 @@
+export const POWER_UP_NAME = {
+  BATTLE_GOD: 'Battle God',
+  BATTLE_STAR: 'Battle Star',
+  BATTLE_SHOT: 'Battle Shot',
+  BATTLE_NITRO: 'Battle Nitro',
+  BATTLE_PULSE: 'Battle Pulse',
+  BATTLE_TRAP: 'Battle Trap',
+  BATTLE_SHIELD: 'Battle Shield',
+  BATTLE_TURBO: 'Battle Turbo',
+  BATTLE_BLUE_SHOT: 'Battle Blue Shot',
+} as const;
+
+export const POWER_UP_TYPE = {
+  Damage: 'Damage',
+  Shield: 'Shield',
+  Speed: 'Speed',
+} as const;
+
+export const POWER_UP_TARGET = {
+  Self: 'Self',
+  Any: 'Any',
+  All: 'All',
+} as const;

package/src/domains/powerUp/PowerUp.schema.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { allCommandsConfigSchema } from '../command';
+import { damageEffectNameSchema, damageTargetSchema } from '../damage';
+import { powerUpNameSchema, powerUpTargetSchema } from './PowerUpAttributes.schema';
+
+export const powerUpCommandSchema = allCommandsConfigSchema;
+
+export const powerUpShieldSchema = z.object({
+  duration: z.number(),
+});
+
+export const powerUpLevelSchema = z.union([z.literal(1), z.literal(2), z.literal(3), z.literal(4), z.literal(5)]);
+
+export const powerUpSchema = z.object({
+  id: z.string(),
+  name: powerUpNameSchema,
+  imageName: z.string(),
+  description: z.string(),
+  level: powerUpLevelSchema,
+  assignationCommands: z.array(powerUpCommandSchema),
+  activationCommands: z.array(powerUpCommandSchema),
+  shield: powerUpShieldSchema.optional(),
+  networkDamage: z
+    .object({
+      name: damageEffectNameSchema,
+      target: damageTargetSchema,
+    })
+    .optional(),
+});

package/src/domains/powerUp/PowerUp.types.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { powerUpCommandSchema, powerUpLevelSchema, powerUpSchema, powerUpShieldSchema } from './PowerUp.schema';
+import { powerUpNameSchema, powerUpTargetSchema, powerUpTypeSchema } from './PowerUpAttributes.schema';
+
+export type PowerUpName = z.infer<typeof powerUpNameSchema>;
+export type PowerUpType = z.infer<typeof powerUpTypeSchema>;
+export type PowerUpTarget = z.infer<typeof powerUpTargetSchema>;
+export type PowerUpShield = z.infer<typeof powerUpShieldSchema>;
+export type PowerUp = z.infer<typeof powerUpSchema>;
+export type PowerUpLevel = z.infer<typeof powerUpLevelSchema>;
+
+export type PowerUpCommand = z.infer<typeof powerUpCommandSchema>;