blacktrigram 0.7.2

package/lib/types/PhysicsTypes.d.ts

@@ -0,0 +1,327 @@
+/**
+ * Physics-based type definitions for Black Trigram (흑괘)
+ *
+ * This module defines physics-first types where all positions, distances,
+ * and measurements are in **meters** or **centimeters**, never pixels.
+ * Pixel conversions happen ONLY at render time.
+ *
+ * @module types/PhysicsTypes
+ * @category Type Definitions
+ * @korean 물리타입
+ */
+import * as THREE from "three";
+import type { Position3D } from "./physics";
+/**
+ * Arena bounds with both pixel dimensions (for rendering) and
+ * world dimensions (for physics calculations).
+ *
+ * This allows proper conversion between screen space (pixels) and
+ * physics space (meters) without fixed constants.
+ *
+ * **Korean**: 경기장 경계 (Arena Bounds)
+ *
+ * @public
+ * @category Physics Types
+ */
+export interface PhysicsArenaBounds {
+    /** X coordinate of arena top-left corner (pixels, for rendering) */
+    readonly x: number;
+    /** Y coordinate of arena top-left corner (pixels, for rendering) */
+    readonly y: number;
+    /** Arena width in pixels (for rendering) */
+    readonly width: number;
+    /** Arena height in pixels (for rendering) */
+    readonly height: number;
+    /** Arena scale factor (1.0 = desktop, <1.0 = mobile, for 3D scene scaling) */
+    readonly scale: number;
+    /**
+     * Physical arena width in meters.
+     *
+     * This is the actual size of the combat arena in the game world.
+     * Combined with width (pixels), this gives pixels-per-meter ratio:
+     * `pixelsPerMeter = width / worldWidthMeters`
+     *
+     * Example: Desktop 960px / 10m = 96 px/m, Mobile 300px / 6m = 50 px/m
+     */
+    readonly worldWidthMeters: number;
+    /**
+     * Physical arena depth in meters.
+     *
+     * Typically same as worldWidthMeters for square arenas.
+     * For rectangular arenas, may differ.
+     *
+     * Example: 10m × 10m square arena
+     */
+    readonly worldDepthMeters: number;
+}
+/**
+ * Default arena bounds used across visual effect components.
+ *
+ * Represents a standard 10m × 7.5m arena at desktop resolution (1200×800px).
+ * Components should use this as their default to ensure consistency.
+ *
+ * **Korean**: 기본경기장경계 (Default Arena Bounds)
+ *
+ * @public
+ * @category Physics Types
+ */
+export declare const DEFAULT_PHYSICS_ARENA_BOUNDS: PhysicsArenaBounds;
+/**
+ * Calculate pixels-per-meter ratio from arena bounds.
+ *
+ * This is the fundamental conversion factor between screen space (pixels)
+ * and physics space (meters). It varies by device resolution and arena size.
+ *
+ * **Korean**: 픽셀당미터비율 (Pixels Per Meter Ratio)
+ *
+ * @param bounds - Arena bounds with pixel and meter dimensions
+ * @returns Conversion ratio (pixels per meter)
+ * @throws Error if worldWidthMeters is not positive
+ *
+ * @example
+ * ```typescript
+ * // Desktop: 960px arena, 10m world
+ * const desktopPxPerM = getPixelsPerMeter({ width: 960, worldWidthMeters: 10, ... });
+ * // Result: 96 px/m
+ *
+ * // Mobile: 300px arena, 6m world
+ * const mobilePxPerM = getPixelsPerMeter({ width: 300, worldWidthMeters: 6, ... });
+ * // Result: 50 px/m
+ * ```
+ *
+ * @public
+ * @category Physics Types
+ */
+export declare function getPixelsPerMeter(bounds: PhysicsArenaBounds): number;
+/**
+ * Convert physics position (meters) to screen position (pixels).
+ *
+ * **IMPORTANT**: This function only handles scaling conversion between
+ * meters and pixels. It does NOT account for arena position offsets
+ * (bounds.x and bounds.y). Callers must add these offsets separately
+ * when rendering to screen.
+ *
+ * Example:
+ * ```typescript
+ * const pixelPos = metersToPixels(physicsPos, bounds);
+ * const screenX = bounds.x + pixelPos.x;  // Add arena offset
+ * const screenY = bounds.y + pixelPos.y;  // Add arena offset
+ * ```
+ *
+ * This conversion should ONLY be used at render time.
+ * Internal game logic should always work in meters.
+ *
+ * **Korean**: 미터를픽셀로 (Meters To Pixels)
+ *
+ * @param positionMeters - Position in meters
+ * @param bounds - Arena bounds for conversion
+ * @returns Position in pixels RELATIVE to arena origin (add bounds.x/y for screen position)
+ * @throws Error if position is invalid
+ *
+ * @public
+ * @category Physics Types
+ */
+export declare function metersToPixels(positionMeters: Position3D | THREE.Vector3, bounds: PhysicsArenaBounds): {
+    x: number;
+    y: number;
+};
+/**
+ * Convert screen position (pixels) to physics position (meters).
+ *
+ * **IMPORTANT**: This function only handles scaling conversion between
+ * pixels and meters. If you're converting from screen coordinates, you
+ * must first subtract arena position offsets (bounds.x and bounds.y).
+ *
+ * Example:
+ * ```typescript
+ * const arenaRelativeX = screenX - bounds.x;  // Remove arena offset
+ * const arenaRelativeY = screenY - bounds.y;  // Remove arena offset
+ * const physicsPos = pixelsToMeters({ x: arenaRelativeX, y: arenaRelativeY }, bounds);
+ * ```
+ *
+ * Use this when converting user input or initial positions.
+ * After conversion, work entirely in meters.
+ *
+ * **Korean**: 픽셀을미터로 (Pixels To Meters)
+ *
+ * @param pixelPosition - Position in pixels RELATIVE to arena origin (subtract bounds.x/y first)
+ * @param bounds - Arena bounds for conversion
+ * @returns Position in meters
+ * @throws Error if pixel coordinates are not finite numbers
+ *
+ * @public
+ * @category Physics Types
+ */
+export declare function pixelsToMeters(pixelPosition: {
+    x: number;
+    y: number;
+}, bounds: PhysicsArenaBounds): Position3D;
+/**
+ * Calculate distance between two positions in meters.
+ *
+ * This is the correct way to calculate distance - always in meters,
+ * never in pixels.
+ *
+ * **Korean**: 거리계산 (Distance Calculation)
+ *
+ * @param pos1 - First position in meters
+ * @param pos2 - Second position in meters
+ * @returns Distance in meters
+ * @throws Error if either position is invalid
+ *
+ * @public
+ * @category Physics Types
+ */
+export declare function calculateDistanceMeters(pos1: Position3D | THREE.Vector3, pos2: Position3D | THREE.Vector3): number;
+/**
+ * Movement-specific arena bounds in world coordinates (meters).
+ *
+ * Defines the playable area boundaries for player/AI movement.
+ * All arenas are centered at origin (0, 0) and extend symmetrically.
+ *
+ * **Korean**: 이동 경기장 경계 (Movement Arena Bounds)
+ *
+ * @remarks
+ * This is distinct from `ArenaBounds` interfaces in layout/test code
+ * which include pixel-based screen coordinates. MovementArenaBounds
+ * only contains world-space meter coordinates for physics calculations.
+ *
+ * @public
+ * @category Physics Types
+ */
+export interface MovementArenaBounds {
+    /** Minimum X position in meters (left edge) */
+    readonly minX: number;
+    /** Maximum X position in meters (right edge) */
+    readonly maxX: number;
+    /** Minimum Z position in meters (back edge) */
+    readonly minZ: number;
+    /** Maximum Z position in meters (front edge) */
+    readonly maxZ: number;
+    /** Arena center X in meters (typically 0) */
+    readonly centerX: number;
+    /** Arena center Z in meters (typically 0) */
+    readonly centerZ: number;
+    /** Arena width in meters */
+    readonly widthMeters: number;
+    /** Arena depth in meters */
+    readonly depthMeters: number;
+}
+/**
+ * Calculate arena bounds from arena configuration.
+ *
+ * Creates bounds with a margin to account for character radius,
+ * preventing characters from walking through edges.
+ *
+ * **Korean**: 경기장 경계 계산 (Calculate Arena Bounds)
+ *
+ * @param bounds - Arena configuration with meter dimensions (can be partial with just worldWidthMeters/worldDepthMeters)
+ * @param margin - Character radius/margin in meters (default: 0.3m - half character width)
+ * @returns Arena bounds for physics calculations
+ * @throws Error if dimensions are invalid (non-positive or non-finite) or margin is invalid
+ *
+ * @example
+ * ```typescript
+ * const config = { worldWidthMeters: 10, worldDepthMeters: 7.5 };
+ * const arenaBounds = calculateArenaBounds(config, 0.3);
+ * // Result: { minX: -4.7, maxX: 4.7, minZ: -3.45, maxZ: 3.45, ... }
+ * ```
+ *
+ * @public
+ * @category Physics Types
+ */
+export declare function calculateArenaBounds(bounds: Pick<PhysicsArenaBounds, 'worldWidthMeters' | 'worldDepthMeters'>, margin?: number): MovementArenaBounds;
+/**
+ * Clamp a 3D position to stay within arena boundaries.
+ *
+ * Only clamps X and Z axes (horizontal plane). Y axis (height) is unchanged.
+ * Arena is centered at origin with bounds extending ±width/2 and ±depth/2.
+ *
+ * **Korean**: 위치를 경기장 경계로 제한 (Clamp Position To Bounds)
+ *
+ * @param position - 3D position in meters (THREE.Vector3 or Position3D)
+ * @param bounds - Arena bounds with min/max values
+ * @returns Clamped position as new THREE.Vector3
+ *
+ * @example
+ * ```typescript
+ * const position = new THREE.Vector3(6, 0, 4); // Outside bounds
+ * const bounds = calculateArenaBounds(config);
+ * const clamped = clampPositionToBounds(position, bounds);
+ * // Result: Vector3(4.7, 0, 3.45) - clamped to edges
+ * ```
+ *
+ * @public
+ * @category Physics Types
+ */
+export declare function clampPositionToBounds(position: THREE.Vector3 | Position3D, bounds: MovementArenaBounds): THREE.Vector3;
+/**
+ * Check if a position is within arena boundaries.
+ *
+ * Only checks X and Z axes (horizontal plane). Y axis (height) is ignored.
+ *
+ * For 2D positions, accepts `{ x, y }` where `y` maps to world Z (depth),
+ * consistent with `clampToArenaBounds` and other 2D arena position APIs.
+ *
+ * **Korean**: 경기장 경계 내 위치 확인 (Check Position In Bounds)
+ *
+ * @param position - Position to check (2D {x,y} where y=depth, or 3D Vector3/Position3D)
+ * @param bounds - Arena bounds
+ * @returns True if position is within bounds
+ *
+ * @example
+ * ```typescript
+ * // 2D position (y maps to Z/depth)
+ * const position = { x: 5, y: 2 };
+ * const bounds = calculateArenaBounds(config);
+ * const inBounds = isPositionInBounds(position, bounds);
+ *
+ * // 3D position (uses z directly)
+ * const position3D = new THREE.Vector3(5, 1.8, 2);
+ * const inBounds3D = isPositionInBounds(position3D, bounds);
+ * ```
+ *
+ * @public
+ * @category Physics Types
+ */
+export declare function isPositionInBounds(position: {
+    x: number;
+    y: number;
+} | THREE.Vector3 | Position3D, bounds: MovementArenaBounds): boolean;
+/**
+ * Clamp a 2D position to stay within arena boundaries in meters.
+ *
+ * This function works in a projected 2D arena space where:
+ * - `position.x` corresponds to world **X** (horizontal)
+ * - `position.y` corresponds to world **Z** (depth)
+ *
+ * Arena coordinates are centered at origin (0, 0) and extend from
+ * -worldWidthMeters/2 to +worldWidthMeters/2 in X (position.x),
+ * -worldDepthMeters/2 to +worldDepthMeters/2 in Z/depth (position.y).
+ *
+ * This is used for physics calculations like knockback to ensure
+ * players stay within the playable area.
+ *
+ * @param position - 2D projected position in meters (X, depth-as-Y), which may exceed arena bounds
+ * @param bounds - Arena bounds with meter dimensions
+ * @returns Position clamped to arena boundaries in the same 2D projection
+ *
+ * @example
+ * ```typescript
+ * const bounds = { worldWidthMeters: 10, worldDepthMeters: 7.5, ... };
+ * const position = { x: 6, y: 4 }; // Outside arena in X/Z-projected space
+ * const clamped = clampToArenaBounds(position, bounds);
+ * // Result: { x: 5, y: 3.75 } - clamped to boundaries
+ * ```
+ *
+ * @public
+ * @category Physics Types
+ */
+export declare function clampToArenaBounds(position: {
+    x: number;
+    y: number;
+}, bounds: PhysicsArenaBounds): {
+    x: number;
+    y: number;
+};
+//# sourceMappingURL=PhysicsTypes.d.ts.map

package/lib/types/PhysicsTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsTypes.d.ts","sourceRoot":"","sources":["../../src/types/PhysicsTypes.ts"],"names":[],"mappings":"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"}

package/lib/types/PhysicsTypes.js

@@ -0,0 +1,105 @@
+import "three";
+//#region src/types/PhysicsTypes.ts
+/**
+* Default arena bounds used across visual effect components.
+* 
+* Represents a standard 10m × 7.5m arena at desktop resolution (1200×800px).
+* Components should use this as their default to ensure consistency.
+* 
+* **Korean**: 기본경기장경계 (Default Arena Bounds)
+* 
+* @public
+* @category Physics Types
+*/
+var DEFAULT_PHYSICS_ARENA_BOUNDS = {
+	x: 0,
+	y: 0,
+	width: 1200,
+	height: 800,
+	scale: 1,
+	worldWidthMeters: 10,
+	worldDepthMeters: 7.5
+};
+/**
+* Calculate arena bounds from arena configuration.
+* 
+* Creates bounds with a margin to account for character radius,
+* preventing characters from walking through edges.
+* 
+* **Korean**: 경기장 경계 계산 (Calculate Arena Bounds)
+* 
+* @param bounds - Arena configuration with meter dimensions (can be partial with just worldWidthMeters/worldDepthMeters)
+* @param margin - Character radius/margin in meters (default: 0.3m - half character width)
+* @returns Arena bounds for physics calculations
+* @throws Error if dimensions are invalid (non-positive or non-finite) or margin is invalid
+* 
+* @example
+* ```typescript
+* const config = { worldWidthMeters: 10, worldDepthMeters: 7.5 };
+* const arenaBounds = calculateArenaBounds(config, 0.3);
+* // Result: { minX: -4.7, maxX: 4.7, minZ: -3.45, maxZ: 3.45, ... }
+* ```
+* 
+* @public
+* @category Physics Types
+*/
+function calculateArenaBounds(bounds, margin = .3) {
+	if (!Number.isFinite(bounds.worldWidthMeters) || bounds.worldWidthMeters <= 0) throw new Error(`worldWidthMeters must be a positive finite number, got: ${bounds.worldWidthMeters}`);
+	if (!Number.isFinite(bounds.worldDepthMeters) || bounds.worldDepthMeters <= 0) throw new Error(`worldDepthMeters must be a positive finite number, got: ${bounds.worldDepthMeters}`);
+	if (!Number.isFinite(margin) || margin < 0) throw new Error(`margin must be a non-negative finite number, got: ${margin}`);
+	const halfWidth = bounds.worldWidthMeters / 2;
+	const halfDepth = bounds.worldDepthMeters / 2;
+	if (margin >= halfWidth) throw new Error(`margin (${margin}m) must be less than half the arena width (${halfWidth}m)`);
+	if (margin >= halfDepth) throw new Error(`margin (${margin}m) must be less than half the arena depth (${halfDepth}m)`);
+	return {
+		minX: -halfWidth + margin,
+		maxX: halfWidth - margin,
+		minZ: -halfDepth + margin,
+		maxZ: halfDepth - margin,
+		centerX: 0,
+		centerZ: 0,
+		widthMeters: bounds.worldWidthMeters,
+		depthMeters: bounds.worldDepthMeters
+	};
+}
+/**
+* Clamp a 2D position to stay within arena boundaries in meters.
+* 
+* This function works in a projected 2D arena space where:
+* - `position.x` corresponds to world **X** (horizontal)
+* - `position.y` corresponds to world **Z** (depth)
+* 
+* Arena coordinates are centered at origin (0, 0) and extend from
+* -worldWidthMeters/2 to +worldWidthMeters/2 in X (position.x),
+* -worldDepthMeters/2 to +worldDepthMeters/2 in Z/depth (position.y).
+* 
+* This is used for physics calculations like knockback to ensure
+* players stay within the playable area.
+* 
+* @param position - 2D projected position in meters (X, depth-as-Y), which may exceed arena bounds
+* @param bounds - Arena bounds with meter dimensions
+* @returns Position clamped to arena boundaries in the same 2D projection
+* 
+* @example
+* ```typescript
+* const bounds = { worldWidthMeters: 10, worldDepthMeters: 7.5, ... };
+* const position = { x: 6, y: 4 }; // Outside arena in X/Z-projected space
+* const clamped = clampToArenaBounds(position, bounds);
+* // Result: { x: 5, y: 3.75 } - clamped to boundaries
+* ```
+* 
+* @public
+* @category Physics Types
+*/
+function clampToArenaBounds(position, bounds) {
+	const halfWidth = bounds.worldWidthMeters / 2;
+	const halfDepth = bounds.worldDepthMeters / 2;
+	return {
+		x: Math.max(-halfWidth, Math.min(halfWidth, position.x)),
+		y: Math.max(-halfDepth, Math.min(halfDepth, position.y))
+	};
+}
+//#endregion
+export { DEFAULT_PHYSICS_ARENA_BOUNDS, calculateArenaBounds, clampToArenaBounds };
+
+//# sourceMappingURL=PhysicsTypes.js.map

package/lib/types/PhysicsTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsTypes.js","names":[],"sources":["../../src/types/PhysicsTypes.ts"],"sourcesContent":["/**\n * Physics-based type definitions for Black Trigram (흑괘)\n * \n * This module defines physics-first types where all positions, distances,\n * and measurements are in **meters** or **centimeters**, never pixels.\n * Pixel conversions happen ONLY at render time.\n * \n * @module types/PhysicsTypes\n * @category Type Definitions\n * @korean 물리타입\n */\n\nimport * as THREE from \"three\";\nimport type { Position3D } from \"./physics\";\n\n/**\n * Arena bounds with both pixel dimensions (for rendering) and \n * world dimensions (for physics calculations).\n * \n * This allows proper conversion between screen space (pixels) and\n * physics space (meters) without fixed constants.\n * \n * **Korean**: 경기장 경계 (Arena Bounds)\n * \n * @public\n * @category Physics Types\n */\nexport interface PhysicsArenaBounds {\n  /** X coordinate of arena top-left corner (pixels, for rendering) */\n  readonly x: number;\n  /** Y coordinate of arena top-left corner (pixels, for rendering) */\n  readonly y: number;\n  /** Arena width in pixels (for rendering) */\n  readonly width: number;\n  /** Arena height in pixels (for rendering) */\n  readonly height: number;\n  /** Arena scale factor (1.0 = desktop, <1.0 = mobile, for 3D scene scaling) */\n  readonly scale: number;\n  \n  /**\n   * Physical arena width in meters.\n   * \n   * This is the actual size of the combat arena in the game world.\n   * Combined with width (pixels), this gives pixels-per-meter ratio:\n   * `pixelsPerMeter = width / worldWidthMeters`\n   * \n   * Example: Desktop 960px / 10m = 96 px/m, Mobile 300px / 6m = 50 px/m\n   */\n  readonly worldWidthMeters: number;\n  \n  /**\n   * Physical arena depth in meters.\n   * \n   * Typically same as worldWidthMeters for square arenas.\n   * For rectangular arenas, may differ.\n   * \n   * Example: 10m × 10m square arena\n   */\n  readonly worldDepthMeters: number;\n}\n\n/**\n * Default arena bounds used across visual effect components.\n * \n * Represents a standard 10m × 7.5m arena at desktop resolution (1200×800px).\n * Components should use this as their default to ensure consistency.\n * \n * **Korean**: 기본경기장경계 (Default Arena Bounds)\n * \n * @public\n * @category Physics Types\n */\nexport const DEFAULT_PHYSICS_ARENA_BOUNDS: PhysicsArenaBounds = {\n  x: 0,\n  y: 0,\n  width: 1200,\n  height: 800,\n  scale: 1.0,\n  worldWidthMeters: 10,\n  worldDepthMeters: 7.5,\n} as const;\n\n/**\n * Validates if a value is a valid Position3D or THREE.Vector3.\n * \n * @param pos - Value to check\n * @returns True if valid position with x, y, z properties\n * @internal\n */\nfunction isValidPosition(pos: unknown): pos is Position3D | THREE.Vector3 {\n  return (\n    pos !== null &&\n    pos !== undefined &&\n    typeof pos === \"object\" &&\n    \"x\" in pos &&\n    \"y\" in pos &&\n    \"z\" in pos &&\n    typeof (pos as Position3D).x === \"number\" &&\n    typeof (pos as Position3D).y === \"number\" &&\n    typeof (pos as Position3D).z === \"number\" &&\n    Number.isFinite((pos as Position3D).x) &&\n    Number.isFinite((pos as Position3D).y) &&\n    Number.isFinite((pos as Position3D).z)\n  );\n}\n\n/**\n * Calculate pixels-per-meter ratio from arena bounds.\n * \n * This is the fundamental conversion factor between screen space (pixels)\n * and physics space (meters). It varies by device resolution and arena size.\n * \n * **Korean**: 픽셀당미터비율 (Pixels Per Meter Ratio)\n * \n * @param bounds - Arena bounds with pixel and meter dimensions\n * @returns Conversion ratio (pixels per meter)\n * @throws Error if worldWidthMeters is not positive\n * \n * @example\n * ```typescript\n * // Desktop: 960px arena, 10m world\n * const desktopPxPerM = getPixelsPerMeter({ width: 960, worldWidthMeters: 10, ... });\n * // Result: 96 px/m\n * \n * // Mobile: 300px arena, 6m world  \n * const mobilePxPerM = getPixelsPerMeter({ width: 300, worldWidthMeters: 6, ... });\n * // Result: 50 px/m\n * ```\n * \n * @public\n * @category Physics Types\n */\nexport function getPixelsPerMeter(bounds: PhysicsArenaBounds): number {\n  if (bounds.worldWidthMeters <= 0) {\n    throw new Error(\n      `worldWidthMeters must be positive, got: ${bounds.worldWidthMeters}`\n    );\n  }\n  return bounds.width / bounds.worldWidthMeters;\n}\n\n/**\n * Convert physics position (meters) to screen position (pixels).\n * \n * **IMPORTANT**: This function only handles scaling conversion between\n * meters and pixels. It does NOT account for arena position offsets\n * (bounds.x and bounds.y). Callers must add these offsets separately\n * when rendering to screen.\n * \n * Example:\n * ```typescript\n * const pixelPos = metersToPixels(physicsPos, bounds);\n * const screenX = bounds.x + pixelPos.x;  // Add arena offset\n * const screenY = bounds.y + pixelPos.y;  // Add arena offset\n * ```\n * \n * This conversion should ONLY be used at render time.\n * Internal game logic should always work in meters.\n * \n * **Korean**: 미터를픽셀로 (Meters To Pixels)\n * \n * @param positionMeters - Position in meters\n * @param bounds - Arena bounds for conversion\n * @returns Position in pixels RELATIVE to arena origin (add bounds.x/y for screen position)\n * @throws Error if position is invalid\n * \n * @public\n * @category Physics Types\n */\nexport function metersToPixels(\n  positionMeters: Position3D | THREE.Vector3,\n  bounds: PhysicsArenaBounds\n): { x: number; y: number } {\n  if (!isValidPosition(positionMeters)) {\n    throw new Error(\n      \"Invalid position: must be Vector3 or Position3D with numeric x, y, z properties\"\n    );\n  }\n  \n  const pixelsPerMeter = getPixelsPerMeter(bounds);\n  \n  return {\n    x: positionMeters.x * pixelsPerMeter,\n    y: positionMeters.z * pixelsPerMeter, // Z axis maps to screen Y\n  };\n}\n\n/**\n * Convert screen position (pixels) to physics position (meters).\n * \n * **IMPORTANT**: This function only handles scaling conversion between\n * pixels and meters. If you're converting from screen coordinates, you\n * must first subtract arena position offsets (bounds.x and bounds.y).\n * \n * Example:\n * ```typescript\n * const arenaRelativeX = screenX - bounds.x;  // Remove arena offset\n * const arenaRelativeY = screenY - bounds.y;  // Remove arena offset\n * const physicsPos = pixelsToMeters({ x: arenaRelativeX, y: arenaRelativeY }, bounds);\n * ```\n * \n * Use this when converting user input or initial positions.\n * After conversion, work entirely in meters.\n * \n * **Korean**: 픽셀을미터로 (Pixels To Meters)\n * \n * @param pixelPosition - Position in pixels RELATIVE to arena origin (subtract bounds.x/y first)\n * @param bounds - Arena bounds for conversion\n * @returns Position in meters\n * @throws Error if pixel coordinates are not finite numbers\n * \n * @public\n * @category Physics Types\n */\nexport function pixelsToMeters(\n  pixelPosition: { x: number; y: number },\n  bounds: PhysicsArenaBounds\n): Position3D {\n  if (!Number.isFinite(pixelPosition.x) || !Number.isFinite(pixelPosition.y)) {\n    throw new Error(\n      `Invalid pixel coordinates: x=${pixelPosition.x}, y=${pixelPosition.y}`\n    );\n  }\n  \n  const pixelsPerMeter = getPixelsPerMeter(bounds);\n  \n  return {\n    x: pixelPosition.x / pixelsPerMeter,\n    y: 0, // Ground plane\n    z: pixelPosition.y / pixelsPerMeter, // Screen Y maps to Z axis\n  };\n}\n\n/**\n * Calculate distance between two positions in meters.\n * \n * This is the correct way to calculate distance - always in meters,\n * never in pixels.\n * \n * **Korean**: 거리계산 (Distance Calculation)\n * \n * @param pos1 - First position in meters\n * @param pos2 - Second position in meters\n * @returns Distance in meters\n * @throws Error if either position is invalid\n * \n * @public\n * @category Physics Types\n */\nexport function calculateDistanceMeters(\n  pos1: Position3D | THREE.Vector3,\n  pos2: Position3D | THREE.Vector3\n): number {\n  if (!isValidPosition(pos1) || !isValidPosition(pos2)) {\n    throw new Error(\n      \"Invalid positions for distance calculation: both positions must be valid Vector3 or Position3D objects\"\n    );\n  }\n  \n  const dx = pos2.x - pos1.x;\n  const dy = pos2.y - pos1.y;\n  const dz = pos2.z - pos1.z;\n  \n  return Math.sqrt(dx * dx + dy * dy + dz * dz);\n}\n\n/**\n * Movement-specific arena bounds in world coordinates (meters).\n * \n * Defines the playable area boundaries for player/AI movement.\n * All arenas are centered at origin (0, 0) and extend symmetrically.\n * \n * **Korean**: 이동 경기장 경계 (Movement Arena Bounds)\n * \n * @remarks\n * This is distinct from `ArenaBounds` interfaces in layout/test code\n * which include pixel-based screen coordinates. MovementArenaBounds\n * only contains world-space meter coordinates for physics calculations.\n * \n * @public\n * @category Physics Types\n */\nexport interface MovementArenaBounds {\n  /** Minimum X position in meters (left edge) */\n  readonly minX: number;\n  /** Maximum X position in meters (right edge) */\n  readonly maxX: number;\n  /** Minimum Z position in meters (back edge) */\n  readonly minZ: number;\n  /** Maximum Z position in meters (front edge) */\n  readonly maxZ: number;\n  /** Arena center X in meters (typically 0) */\n  readonly centerX: number;\n  /** Arena center Z in meters (typically 0) */\n  readonly centerZ: number;\n  /** Arena width in meters */\n  readonly widthMeters: number;\n  /** Arena depth in meters */\n  readonly depthMeters: number;\n}\n\n/**\n * Calculate arena bounds from arena configuration.\n * \n * Creates bounds with a margin to account for character radius,\n * preventing characters from walking through edges.\n * \n * **Korean**: 경기장 경계 계산 (Calculate Arena Bounds)\n * \n * @param bounds - Arena configuration with meter dimensions (can be partial with just worldWidthMeters/worldDepthMeters)\n * @param margin - Character radius/margin in meters (default: 0.3m - half character width)\n * @returns Arena bounds for physics calculations\n * @throws Error if dimensions are invalid (non-positive or non-finite) or margin is invalid\n * \n * @example\n * ```typescript\n * const config = { worldWidthMeters: 10, worldDepthMeters: 7.5 };\n * const arenaBounds = calculateArenaBounds(config, 0.3);\n * // Result: { minX: -4.7, maxX: 4.7, minZ: -3.45, maxZ: 3.45, ... }\n * ```\n * \n * @public\n * @category Physics Types\n */\nexport function calculateArenaBounds(\n  bounds: Pick<PhysicsArenaBounds, 'worldWidthMeters' | 'worldDepthMeters'>,\n  margin: number = 0.3\n): MovementArenaBounds {\n  // Validate arena dimensions\n  if (!Number.isFinite(bounds.worldWidthMeters) || bounds.worldWidthMeters <= 0) {\n    throw new Error(\n      `worldWidthMeters must be a positive finite number, got: ${bounds.worldWidthMeters}`\n    );\n  }\n  if (!Number.isFinite(bounds.worldDepthMeters) || bounds.worldDepthMeters <= 0) {\n    throw new Error(\n      `worldDepthMeters must be a positive finite number, got: ${bounds.worldDepthMeters}`\n    );\n  }\n  \n  // Validate margin\n  if (!Number.isFinite(margin) || margin < 0) {\n    throw new Error(\n      `margin must be a non-negative finite number, got: ${margin}`\n    );\n  }\n  \n  const halfWidth = bounds.worldWidthMeters / 2;\n  const halfDepth = bounds.worldDepthMeters / 2;\n  \n  // Validate margin is not larger than arena dimensions\n  if (margin >= halfWidth) {\n    throw new Error(\n      `margin (${margin}m) must be less than half the arena width (${halfWidth}m)`\n    );\n  }\n  if (margin >= halfDepth) {\n    throw new Error(\n      `margin (${margin}m) must be less than half the arena depth (${halfDepth}m)`\n    );\n  }\n  \n  return {\n    minX: -halfWidth + margin,\n    maxX: halfWidth - margin,\n    minZ: -halfDepth + margin,\n    maxZ: halfDepth - margin,\n    centerX: 0,\n    centerZ: 0,\n    widthMeters: bounds.worldWidthMeters,\n    depthMeters: bounds.worldDepthMeters,\n  };\n}\n\n/**\n * Clamp a 3D position to stay within arena boundaries.\n * \n * Only clamps X and Z axes (horizontal plane). Y axis (height) is unchanged.\n * Arena is centered at origin with bounds extending ±width/2 and ±depth/2.\n * \n * **Korean**: 위치를 경기장 경계로 제한 (Clamp Position To Bounds)\n * \n * @param position - 3D position in meters (THREE.Vector3 or Position3D)\n * @param bounds - Arena bounds with min/max values\n * @returns Clamped position as new THREE.Vector3\n * \n * @example\n * ```typescript\n * const position = new THREE.Vector3(6, 0, 4); // Outside bounds\n * const bounds = calculateArenaBounds(config);\n * const clamped = clampPositionToBounds(position, bounds);\n * // Result: Vector3(4.7, 0, 3.45) - clamped to edges\n * ```\n * \n * @public\n * @category Physics Types\n */\nexport function clampPositionToBounds(\n  position: THREE.Vector3 | Position3D,\n  bounds: MovementArenaBounds\n): THREE.Vector3 {\n  return new THREE.Vector3(\n    Math.max(bounds.minX, Math.min(bounds.maxX, position.x)),\n    position.y, // Y is height, not bounds-checked\n    Math.max(bounds.minZ, Math.min(bounds.maxZ, position.z))\n  );\n}\n\n/**\n * Check if a position is within arena boundaries.\n * \n * Only checks X and Z axes (horizontal plane). Y axis (height) is ignored.\n * \n * For 2D positions, accepts `{ x, y }` where `y` maps to world Z (depth),\n * consistent with `clampToArenaBounds` and other 2D arena position APIs.\n * \n * **Korean**: 경기장 경계 내 위치 확인 (Check Position In Bounds)\n * \n * @param position - Position to check (2D {x,y} where y=depth, or 3D Vector3/Position3D)\n * @param bounds - Arena bounds\n * @returns True if position is within bounds\n * \n * @example\n * ```typescript\n * // 2D position (y maps to Z/depth)\n * const position = { x: 5, y: 2 };\n * const bounds = calculateArenaBounds(config);\n * const inBounds = isPositionInBounds(position, bounds);\n * \n * // 3D position (uses z directly)\n * const position3D = new THREE.Vector3(5, 1.8, 2);\n * const inBounds3D = isPositionInBounds(position3D, bounds);\n * ```\n * \n * @public\n * @category Physics Types\n */\nexport function isPositionInBounds(\n  position: { x: number; y: number } | THREE.Vector3 | Position3D,\n  bounds: MovementArenaBounds\n): boolean {\n  const x = position.x;\n  // For 2D positions {x,y}, y maps to world Z (depth)\n  // For 3D positions, use z directly\n  const z = 'z' in position ? position.z : position.y;\n  \n  return (\n    x >= bounds.minX &&\n    x <= bounds.maxX &&\n    z >= bounds.minZ &&\n    z <= bounds.maxZ\n  );\n}\n\n/**\n * Clamp a 2D position to stay within arena boundaries in meters.\n * \n * This function works in a projected 2D arena space where:\n * - `position.x` corresponds to world **X** (horizontal)\n * - `position.y` corresponds to world **Z** (depth)\n * \n * Arena coordinates are centered at origin (0, 0) and extend from\n * -worldWidthMeters/2 to +worldWidthMeters/2 in X (position.x),\n * -worldDepthMeters/2 to +worldDepthMeters/2 in Z/depth (position.y).\n * \n * This is used for physics calculations like knockback to ensure\n * players stay within the playable area.\n * \n * @param position - 2D projected position in meters (X, depth-as-Y), which may exceed arena bounds\n * @param bounds - Arena bounds with meter dimensions\n * @returns Position clamped to arena boundaries in the same 2D projection\n * \n * @example\n * ```typescript\n * const bounds = { worldWidthMeters: 10, worldDepthMeters: 7.5, ... };\n * const position = { x: 6, y: 4 }; // Outside arena in X/Z-projected space\n * const clamped = clampToArenaBounds(position, bounds);\n * // Result: { x: 5, y: 3.75 } - clamped to boundaries\n * ```\n * \n * @public\n * @category Physics Types\n */\nexport function clampToArenaBounds(\n  position: { x: number; y: number },\n  bounds: PhysicsArenaBounds\n): { x: number; y: number } {\n  const halfWidth = bounds.worldWidthMeters / 2;\n  const halfDepth = bounds.worldDepthMeters / 2;\n  \n  return {\n    x: Math.max(-halfWidth, Math.min(halfWidth, position.x)),\n    y: Math.max(-halfDepth, Math.min(halfDepth, position.y)),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAwEA,IAAa,+BAAmD;CAC9D,GAAG;CACH,GAAG;CACH,OAAO;CACP,QAAQ;CACR,OAAO;CACP,kBAAkB;CAClB,kBAAkB;CACnB;;;;;;;;;;;;;;;;;;;;;;;;AAoPD,SAAgB,qBACd,QACA,SAAiB,IACI;AAErB,KAAI,CAAC,OAAO,SAAS,OAAO,iBAAiB,IAAI,OAAO,oBAAoB,EAC1E,OAAM,IAAI,MACR,2DAA2D,OAAO,mBACnE;AAEH,KAAI,CAAC,OAAO,SAAS,OAAO,iBAAiB,IAAI,OAAO,oBAAoB,EAC1E,OAAM,IAAI,MACR,2DAA2D,OAAO,mBACnE;AAIH,KAAI,CAAC,OAAO,SAAS,OAAO,IAAI,SAAS,EACvC,OAAM,IAAI,MACR,qDAAqD,SACtD;CAGH,MAAM,YAAY,OAAO,mBAAmB;CAC5C,MAAM,YAAY,OAAO,mBAAmB;AAG5C,KAAI,UAAU,UACZ,OAAM,IAAI,MACR,WAAW,OAAO,6CAA6C,UAAU,IAC1E;AAEH,KAAI,UAAU,UACZ,OAAM,IAAI,MACR,WAAW,OAAO,6CAA6C,UAAU,IAC1E;AAGH,QAAO;EACL,MAAM,CAAC,YAAY;EACnB,MAAM,YAAY;EAClB,MAAM,CAAC,YAAY;EACnB,MAAM,YAAY;EAClB,SAAS;EACT,SAAS;EACT,aAAa,OAAO;EACpB,aAAa,OAAO;EACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgHH,SAAgB,mBACd,UACA,QAC0B;CAC1B,MAAM,YAAY,OAAO,mBAAmB;CAC5C,MAAM,YAAY,OAAO,mBAAmB;AAE5C,QAAO;EACL,GAAG,KAAK,IAAI,CAAC,WAAW,KAAK,IAAI,WAAW,SAAS,EAAE,CAAC;EACxD,GAAG,KAAK,IAAI,CAAC,WAAW,KAAK,IAAI,WAAW,SAAS,EAAE,CAAC;EACzD"}

package/lib/types/ResponsiveTypes.d.ts

@@ -0,0 +1,210 @@
+/**
+ * Responsive Type Definitions for Black Trigram
+ *
+ * Comprehensive type system for responsive layout management across
+ * all screen sizes from mobile (375px) to ultra-wide (2560px+).
+ *
+ * Features:
+ * - Five screen size categories (mobile, tablet, desktop, large, xlarge)
+ * - Proportional scaling system (0.8x - 1.4x)
+ * - Korean text readability (14-24px range)
+ * - Smooth transitions for resize operations
+ *
+ * @module types/ResponsiveTypes
+ * @category Responsive Layout
+ * @korean 반응형타입정의
+ */
+/**
+ * Screen size categories for responsive design
+ * Maps viewport width to device categories
+ *
+ * @category Responsive Layout
+ * @korean 화면크기범주
+ */
+export type ScreenSize = 'mobile' | 'tablet' | 'desktop' | 'large' | 'xlarge';
+/**
+ * Breakpoint values for responsive design transitions
+ * Defines width thresholds for each screen size category
+ *
+ * @category Responsive Layout
+ * @korean 중단점값
+ */
+export interface ResponsiveBreakpoints {
+    /** Small mobile devices (< 768px) - iPhone SE, standard phones */
+    readonly MOBILE: number;
+    /** Tablet devices (768-1024px) - iPad, Android tablets */
+    readonly TABLET: number;
+    /** Desktop devices (1024-1440px) - Standard monitors */
+    readonly DESKTOP: number;
+    /** Large desktop (1440-1920px) - HD/2K monitors */
+    readonly LARGE: number;
+    /** Extra large (≥1920px) - 4K monitors, ultra-wide displays */
+    readonly XLARGE: number;
+}
+/**
+ * Font scaling multipliers for each screen size
+ * Ensures consistent readability across all devices
+ *
+ * Base size (16px) * scale = final size
+ * Clamped to readable range (14-24px)
+ *
+ * @category Typography
+ * @korean 글꼴스케일배수
+ */
+export interface FontScaleMap {
+    /** Mobile scale (0.8x) - Compact for small screens */
+    readonly mobile: number;
+    /** Tablet scale (0.9x) - Slightly larger than mobile */
+    readonly tablet: number;
+    /** Desktop scale (1.0x) - Base reference size */
+    readonly desktop: number;
+    /** Large scale (1.2x) - Enhanced for large screens */
+    readonly large: number;
+    /** Extra large scale (1.4x) - Maximum for 4K displays */
+    readonly xlarge: number;
+}
+/**
+ * Spacing scaling multipliers for each screen size
+ * Proportional spacing that adapts to screen size
+ *
+ * Base spacing * scale = final spacing
+ *
+ * @category Layout
+ * @korean 간격스케일배수
+ */
+export interface SpacingScaleMap {
+    /** Mobile spacing (0.5x) - Compact layout */
+    readonly mobile: number;
+    /** Tablet spacing (0.75x) - Moderate layout */
+    readonly tablet: number;
+    /** Desktop spacing (1.0x) - Standard reference */
+    readonly desktop: number;
+    /** Large spacing (1.25x) - Spacious layout */
+    readonly large: number;
+    /** Extra large spacing (1.5x) - Maximum for 4K */
+    readonly xlarge: number;
+}
+/**
+ * Font size configuration with min/max constraints
+ * Ensures Korean and English text remain readable
+ *
+ * @category Typography
+ * @korean 글꼴크기설정
+ */
+export interface FontSizeConfig {
+    /** Base font size in pixels (reference point) */
+    readonly base: number;
+    /** Minimum readable size (14px for body text) */
+    readonly min: number;
+    /** Maximum size before becoming too large (24px) */
+    readonly max: number;
+    /** Current calculated size for screen */
+    readonly current: number;
+}
+/**
+ * Responsive scaling configuration
+ * Complete scaling system for all responsive elements
+ *
+ * @category Responsive Layout
+ * @korean 반응형스케일설정
+ */
+export interface ResponsiveScaleConfig {
+    /** Current screen size category */
+    readonly screenSize: ScreenSize;
+    /** Font scaling multiplier */
+    readonly fontScale: number;
+    /** Spacing scaling multiplier */
+    readonly spacingScale: number;
+    /** Viewport dimensions */
+    readonly viewport: {
+        readonly width: number;
+        readonly height: number;
+    };
+}
+/**
+ * Transition configuration for smooth resize operations
+ * Ensures 60fps performance during window resize
+ *
+ * @category Animation
+ * @korean 전환설정
+ */
+export interface ResizeTransitionConfig {
+    /** CSS transition duration (default: 300ms) */
+    readonly duration: string;
+    /** CSS transition timing function (default: ease-in-out) */
+    readonly easing: string;
+    /** Properties to transition (default: all) */
+    readonly properties: readonly string[];
+    /** Whether transitions are enabled */
+    readonly enabled: boolean;
+}
+/**
+ * Complete responsive configuration
+ * All settings needed for responsive layout management
+ *
+ * @category Responsive Layout
+ * @korean 반응형설정완료
+ */
+export interface ResponsiveConfig {
+    /** Screen size category */
+    readonly screenSize: ScreenSize;
+    /** Breakpoint values */
+    readonly breakpoints: ResponsiveBreakpoints;
+    /** Font scaling configuration */
+    readonly fontScale: FontScaleMap;
+    /** Spacing scaling configuration */
+    readonly spacingScale: SpacingScaleMap;
+    /** Transition configuration */
+    readonly transitions: ResizeTransitionConfig;
+}
+/**
+ * Calculated responsive values for a component
+ * Ready-to-use values computed from configuration
+ *
+ * @category Responsive Layout
+ * @korean 계산된반응형값
+ */
+export interface ResponsiveValues {
+    /** Calculated font sizes */
+    readonly fontSize: {
+        readonly small: number;
+        readonly body: number;
+        readonly title: number;
+        readonly hero: number;
+        readonly hud: number;
+    };
+    /** Calculated spacing values */
+    readonly spacing: {
+        readonly xs: number;
+        readonly sm: number;
+        readonly md: number;
+        readonly lg: number;
+        readonly xl: number;
+    };
+    /** CSS transition string for smooth resizing */
+    readonly transition: string;
+}
+/**
+ * Screen size test result
+ * Used for testing responsive breakpoints
+ *
+ * @category Testing
+ * @korean 화면크기테스트결과
+ */
+export interface ScreenSizeTestResult {
+    /** Tested width in pixels */
+    readonly width: number;
+    /** Tested height in pixels */
+    readonly height: number;
+    /** Determined screen size */
+    readonly screenSize: ScreenSize;
+    /** Whether this is mobile */
+    readonly isMobile: boolean;
+    /** Whether this is tablet */
+    readonly isTablet: boolean;
+    /** Whether this is desktop or larger */
+    readonly isDesktop: boolean;
+    /** Whether in landscape orientation */
+    readonly isLandscape: boolean;
+}
+//# sourceMappingURL=ResponsiveTypes.d.ts.map