Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 | 6x 6x 202x 122x 96x 42x 14x 179x 76x 21x 49x 23x 10x 179x 179x 179x 179x 5x 5x 5x 5x 5x 5x 5x 5x 5x 5x 9x | /**
* Arena world dimension calculations for physics-first coordinate system.
*
* Determines the physical size of the combat arena in meters based on
* screen **resolution** (not device type), ensuring appropriate gameplay
* space for different display capabilities.
*
* **Important**: Arena size is determined by RESOLUTION, not device type.
* A mobile device with a 4K screen gets a larger arena than a desktop with
* 1080p resolution, because arena size should match display capability.
*
* **4:3 Aspect Ratio Philosophy**:
* All arenas use 4:3 aspect ratio (width > height) for optimal screen usage.
* Width sizes: 6m, 8m, 10m, 12m, 14m based on resolution.
* Height is calculated as width × 0.75 (3/4).
* This ensures:
* - Efficient use of horizontal screen space
* - Consistent physics across all devices
* - Traditional fighting game proportions
*
* **Korean**: 경기장세계크기 (Arena World Size)
*
* @module utils/arenaWorldDimensions
* @category Physics
*/
/**
* Screen size category based on RESOLUTION (width in pixels).
*
* **Korean**: 화면크기범주 (Screen Size Category)
*
* @public
*/
export type ScreenSizeCategory =
| "small"
| "medium"
| "large"
| "xlarge"
| "ultra";
/**
* Standard arena widths in meters.
* Arenas use 4:3 aspect ratio (height = width × 0.75).
*
* @public
*/
export const ARENA_SIZES = {
/** Small arena for compact screens (6m × 4.5m) */
SMALL: 6,
/** Medium arena for tablets and small laptops (8m × 6m) */
MEDIUM: 8,
/** Large arena for standard desktops (10m × 7.5m) */
LARGE: 10,
/** Extra-large arena for high-res displays (12m × 9m) */
XLARGE: 12,
/** Ultra arena for 4K+ displays (14m × 10.5m) */
ULTRA: 14,
} as const;
/**
* Resolution breakpoints for arena size determination.
* Based on common display widths.
*
* @public
*/
export const RESOLUTION_BREAKPOINTS = {
/** Small screens: < 768px (phones, small tablets) */
SMALL_MAX: 768,
/** Medium screens: 768-1199px (tablets, small laptops) */
MEDIUM_MAX: 1200,
/** Large screens: 1200-1919px (laptops, standard monitors) */
LARGE_MAX: 1920,
/** XLarge screens: 1920-2559px (large monitors, some 4K) */
XLARGE_MAX: 2560,
/** Ultra screens: ≥ 2560px (4K, ultrawide) */
} as const;
/**
* World dimensions for an arena in meters.
*
* **Korean**: 세계크기 (World Dimensions)
*
* @public
*/
export interface WorldDimensions {
/** Arena width in meters */
readonly widthMeters: number;
/** Arena depth in meters (height = width × 0.75 for 4:3 ratio) */
readonly depthMeters: number;
/** Arena width in meters (same as widthMeters, for convenience) */
readonly sizeMeters: number;
/** Screen category used to determine arena size */
readonly screenCategory: ScreenSizeCategory;
}
/**
* Complete arena configuration including pixel and meter dimensions.
*
* @public
*/
export interface ArenaConfiguration {
/** Arena position X in pixels */
readonly x: number;
/** Arena position Y in pixels */
readonly y: number;
/** Arena width in pixels */
readonly width: number;
/** Arena height in pixels */
readonly height: number;
/** Arena world width in meters */
readonly worldWidthMeters: number;
/** Arena world depth in meters */
readonly worldDepthMeters: number;
/** Pixels per meter ratio for this arena */
readonly pixelsPerMeter: number;
/** Scale factor (1.0 = reference desktop, <1.0 = smaller screens) */
readonly scale: number;
}
/**
* Categorize screen based on resolution (width in pixels).
*
* This is used for arena sizing. Device type (mobile/desktop) is determined
* separately for UI controls only.
*
* **Korean**: 화면크기범주결정 (Determine Screen Size Category)
*
* @param screenWidth - Screen width in pixels
* @returns Screen size category for arena dimensions
*
* @example
* ```typescript
* getScreenSizeCategory(640); // "small" - small phone
* getScreenSizeCategory(1200); // "large" - standard laptop
* getScreenSizeCategory(3840); // "ultra" - 4K display
* ```
*
* @public
*/
export function getScreenSizeCategory(screenWidth: number): ScreenSizeCategory {
if (screenWidth < RESOLUTION_BREAKPOINTS.SMALL_MAX) return "small";
if (screenWidth < RESOLUTION_BREAKPOINTS.MEDIUM_MAX) return "medium";
if (screenWidth < RESOLUTION_BREAKPOINTS.LARGE_MAX) return "large";
if (screenWidth < RESOLUTION_BREAKPOINTS.XLARGE_MAX) return "xlarge";
return "ultra";
}
/**
* Get arena size in meters for a given screen category.
*
* @param category - Screen size category
* @returns Arena size in meters (square dimension)
*
* @public
*/
export function getArenaSizeForCategory(category: ScreenSizeCategory): number {
switch (category) {
case "small":
return ARENA_SIZES.SMALL;
case "medium":
return ARENA_SIZES.MEDIUM;
case "large":
return ARENA_SIZES.LARGE;
case "xlarge":
return ARENA_SIZES.XLARGE;
case "ultra":
return ARENA_SIZES.ULTRA;
default:
return ARENA_SIZES.LARGE;
}
}
/**
* Calculate appropriate arena world dimensions based on screen resolution.
*
* Larger resolution displays get larger arenas for better gameplay, while
* maintaining the same physical combat mechanics. Movement speed in m/s
* remains constant, but larger arenas provide more tactical space.
*
* **Arenas use 4:3 aspect ratio** (width > depth):
* - < 768px: 6m × 4.5m (compact, fast-paced combat)
* - 768-1199px: 8m × 6m (balanced gameplay)
* - 1200-1919px: 10m × 7.5m (tactical combat)
* - 1920-2559px: 12m × 9m (advanced positioning)
* - ≥ 2560px: 14m × 10.5m (maximum tactical space)
*
* **Korean**: 경기장크기계산 (Calculate Arena Size)
*
* @param screenWidth - Screen width in pixels (resolution, not device type)
* @returns World dimensions in meters (4:3 aspect ratio)
*
* @example
* ```typescript
* // Mobile phone 640px width
* const smallPhone = calculateArenaWorldDimensions(640);
* // Result: { widthMeters: 6, depthMeters: 4.5, sizeMeters: 6, screenCategory: "small" }
*
* // Desktop 1920×1080
* const desktop = calculateArenaWorldDimensions(1920);
* // Result: { widthMeters: 12, depthMeters: 9, sizeMeters: 12, screenCategory: "xlarge" }
* ```
*
* @public
*/
export function calculateArenaWorldDimensions(
screenWidth: number,
): WorldDimensions {
const category = getScreenSizeCategory(screenWidth);
const sizeMeters = getArenaSizeForCategory(category);
// 4:3 aspect ratio: depth = width × 0.75
const depthMeters = sizeMeters * 0.75;
return {
widthMeters: sizeMeters,
depthMeters,
sizeMeters,
screenCategory: category,
};
}
/**
* Calculate complete arena configuration including pixel and meter dimensions.
*
* This is the primary function for setting up arena bounds. It calculates:
* - Pixel dimensions based on available screen space
* - Meter dimensions based on screen resolution category
* - Pixels-per-meter ratio for physics conversion
*
* @param screenWidth - Screen width in pixels
* @param screenHeight - Screen height in pixels
* @param topOffset - Pixels reserved at top (HUD, headers)
* @param bottomOffset - Pixels reserved at bottom (controls, footer)
* @param horizontalMargin - Pixels to leave on sides (as ratio 0-1)
* @returns Complete arena configuration
*
* @public
*/
export function calculateArenaConfiguration(
screenWidth: number,
screenHeight: number,
topOffset: number,
bottomOffset: number,
horizontalMargin: number = 0.1,
): ArenaConfiguration {
// Get world dimensions based on resolution
const worldDimensions = calculateArenaWorldDimensions(screenWidth);
// Calculate available pixel space
const availableWidth = screenWidth * (1 - 2 * horizontalMargin);
const availableHeight = screenHeight - topOffset - bottomOffset;
// Use the smaller dimension to ensure square arena fits
const arenaSizePixels = Math.min(availableWidth, availableHeight);
// Calculate arena position (centered horizontally)
const arenaX = (screenWidth - arenaSizePixels) / 2;
const arenaY = topOffset;
// Calculate pixels per meter for this configuration
const pixelsPerMeter = arenaSizePixels / worldDimensions.sizeMeters;
// Calculate scale relative to reference (1000px / 10m = 100 px/m)
const referencePixelsPerMeter = 100;
const scale = pixelsPerMeter / referencePixelsPerMeter;
return {
x: arenaX,
y: arenaY,
width: arenaSizePixels,
height: arenaSizePixels,
worldWidthMeters: worldDimensions.widthMeters,
worldDepthMeters: worldDimensions.depthMeters,
pixelsPerMeter,
scale,
};
}
/**
* Calculate pixels-per-meter ratio from arena dimensions.
*
* @param arenaWidthPixels - Arena width in pixels
* @param arenaWidthMeters - Arena width in meters
* @returns Pixels per meter ratio
*
* @public
*/
export function calculatePixelsPerMeter(
arenaWidthPixels: number,
arenaWidthMeters: number,
): number {
if (arenaWidthMeters <= 0) {
throw new Error(`arenaWidthMeters must be positive: ${arenaWidthMeters}`);
}
return arenaWidthPixels / arenaWidthMeters;
}
/**
* Get player height in meters from archetype physical attributes.
*
* Converts archetype totalHeight (in centimeters) to meters for physics calculations.
*
* **Korean**: 플레이어키 (Player Height)
*
* @param archetypeHeightCm - Player height in centimeters from PhysicalAttributes
* @returns Height in meters
*
* @example
* ```typescript
* // Musa archetype: 180cm
* const height = getPlayerHeightMeters(180);
* // Result: 1.8 meters
* ```
*
* @public
*/
export function getPlayerHeightMeters(archetypeHeightCm: number): number {
return archetypeHeightCm / 100;
}
|