blacktrigram 0.7.2

package/lib/components/screens/combat/components/effects/BloodParticles3D.js

@@ -0,0 +1,278 @@
+import { KOREAN_COLORS } from "../../../../../types/constants/colors.js";
+import "../../../../../types/constants/index.js";
+import { ThreeObjectPools } from "../../../../../utils/threeObjectPool.js";
+import React, { useMemo, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+import { useFrame } from "@react-three/fiber";
+import { PointMaterial, Points } from "@react-three/drei";
+import * as THREE from "three";
+//#region src/components/screens/combat/components/effects/BloodParticles3D.tsx
+/**
+* BloodParticles3D - Realistic blood splatter particle system
+*
+* Creates physics-based blood particles that spray from impact points with gravity,
+* creating pools on the arena floor. Optimized for 60fps with instanced rendering.
+*
+* Features:
+* - Gravity-based particle physics
+* - Blood pool accumulation on floor
+* - 10-second fade-out for pools
+* - Instanced rendering for performance
+* - Mobile-optimized particle counts
+*
+* @module components/combat/BloodParticles3D
+* @category Combat Effects
+* @korean 피입자3D
+*/
+/**
+* Performance and physics constants
+*/
+var BLOOD_CONSTANTS = {
+	GRAVITY: -9.8,
+	MAX_PARTICLES_DESKTOP: 300,
+	MAX_PARTICLES_MOBILE: 100,
+	PARTICLE_LIFETIME: 2,
+	POOL_FADE_DURATION: 10,
+	VELOCITY_MIN: 2,
+	VELOCITY_MAX: 5,
+	SPREAD_ANGLE: Math.PI / 3,
+	FLOOR_Y: 0,
+	PARTICLE_SIZE: .05,
+	MAX_DELTA: 1 / 30
+};
+/**
+* Generate initial particles for a blood splatter effect
+* 
+* PERFORMANCE OPTIMIZATION: Uses ThreeObjectPools for ALL Vector3 allocations
+* 
+* Pooling Strategy (UPDATED):
+* - Acquire temp vectors for calculations (baseDir, origin, axis vectors) - RELEASED
+* - Acquire position/velocity from pool for particle ownership - MUST BE RELEASED on expiration
+* 
+* Memory Impact:
+* - Before: 600 Vector3 allocations per splatter (2 per particle × 300)
+* - After: 5 temp vectors (reused) + particles use pooled vectors (released on expiration)
+* - Reduction: ~99.2% fewer allocations (600 → 5 temp + pooled reuse)
+* 
+* @param effect - Blood splatter effect configuration
+* @param maxParticles - Maximum number of particles to generate
+* @returns Array of blood particles with ALL vectors from pool (must be released later)
+*/
+var generateBloodParticles = (effect, maxParticles) => {
+	const particles = [];
+	const particleCount = Math.floor(maxParticles * effect.intensity);
+	const baseDir = ThreeObjectPools.vector3.acquire();
+	const origin = ThreeObjectPools.vector3.acquire();
+	const direction = ThreeObjectPools.vector3.acquire();
+	const yAxis = ThreeObjectPools.vector3.acquire();
+	const zAxis = ThreeObjectPools.vector3.acquire();
+	baseDir.set(...effect.direction).normalize();
+	origin.set(...effect.position);
+	yAxis.set(0, 1, 0);
+	zAxis.set(0, 0, 1);
+	for (let i = 0; i < particleCount; i++) {
+		const spreadAngle = BLOOD_CONSTANTS.SPREAD_ANGLE;
+		const phi = (Math.random() - .5) * spreadAngle;
+		const theta = Math.random() * Math.PI * 2;
+		direction.copy(baseDir);
+		direction.applyAxisAngle(yAxis, phi);
+		direction.applyAxisAngle(zAxis, theta);
+		const speed = BLOOD_CONSTANTS.VELOCITY_MIN + Math.random() * (BLOOD_CONSTANTS.VELOCITY_MAX - BLOOD_CONSTANTS.VELOCITY_MIN);
+		const particlePosition = ThreeObjectPools.vector3.acquire();
+		const particleVelocity = ThreeObjectPools.vector3.acquire();
+		particlePosition.copy(origin);
+		particleVelocity.copy(direction).multiplyScalar(speed);
+		particles.push({
+			position: particlePosition,
+			velocity: particleVelocity,
+			lifetime: BLOOD_CONSTANTS.PARTICLE_LIFETIME,
+			age: 0,
+			settled: false,
+			isPooled: true
+		});
+	}
+	ThreeObjectPools.vector3.release(baseDir);
+	ThreeObjectPools.vector3.release(origin);
+	ThreeObjectPools.vector3.release(direction);
+	ThreeObjectPools.vector3.release(yAxis);
+	ThreeObjectPools.vector3.release(zAxis);
+	return particles;
+};
+/**
+* BloodParticles3D Component
+*
+* Renders realistic blood splatter effects using physics-based particle simulation.
+* Optimized for performance with instanced rendering and efficient physics updates.
+*
+* @example
+* ```tsx
+* const [bloodEffects, setBloodEffects] = useState<BloodSplatterEffect[]>([]);
+*
+* // On hit event
+* const handleHit = (position: [number, number, number], direction: [number, number, number]) => {
+*   setBloodEffects([...bloodEffects, {
+*     id: generateId(),
+*     position,
+*     direction,
+*     intensity: 0.8,
+*     startTime: Date.now(),
+*   }]);
+* };
+*
+* <BloodParticles3D
+*   effects={bloodEffects}
+*   enabled={violenceSettings.blood}
+*   isMobile={isMobile}
+*   onEffectComplete={(id) => {
+*     setBloodEffects(prev => prev.filter(e => e.id !== id));
+*   }}
+* />
+* ```
+*/
+var BloodParticles3D = ({ effects, enabled = true, isMobile = false, onEffectComplete }) => {
+	const particlesRef = useRef(/* @__PURE__ */ new Map());
+	const poolParticlesRef = useRef([]);
+	const pointsRef = useRef(null);
+	const completedEffectsRef = useRef(/* @__PURE__ */ new Set());
+	const maxParticles = isMobile ? BLOOD_CONSTANTS.MAX_PARTICLES_MOBILE : BLOOD_CONSTANTS.MAX_PARTICLES_DESKTOP;
+	const bloodColor = useMemo(() => KOREAN_COLORS.BLOODLOSS_INDICATOR, []);
+	React.useEffect(() => {
+		if (!enabled) return;
+		effects.forEach((effect) => {
+			if (!particlesRef.current.has(effect.id)) {
+				const particles = generateBloodParticles(effect, maxParticles);
+				particlesRef.current.set(effect.id, particles);
+			}
+		});
+		const effectIds = new Set(effects.map((e) => e.id));
+		particlesRef.current.forEach((particles, id) => {
+			if (!effectIds.has(id)) {
+				particles.forEach((p) => {
+					if (p.isPooled) {
+						ThreeObjectPools.vector3.release(p.position);
+						ThreeObjectPools.vector3.release(p.velocity);
+						p.isPooled = false;
+					}
+				});
+				particlesRef.current.delete(id);
+				completedEffectsRef.current.delete(id);
+			}
+		});
+	}, [
+		effects,
+		enabled,
+		maxParticles
+	]);
+	React.useEffect(() => {
+		const currentParticles = particlesRef.current;
+		const currentPoolParticles = poolParticlesRef.current;
+		const currentCompletedEffects = completedEffectsRef.current;
+		return () => {
+			currentParticles.forEach((particles) => {
+				particles.forEach((p) => {
+					if (p.isPooled) {
+						ThreeObjectPools.vector3.release(p.position);
+						ThreeObjectPools.vector3.release(p.velocity);
+						p.isPooled = false;
+					}
+				});
+			});
+			currentPoolParticles.forEach((p) => {
+				if (p.isPooled) {
+					ThreeObjectPools.vector3.release(p.position);
+					ThreeObjectPools.vector3.release(p.velocity);
+					p.isPooled = false;
+				}
+			});
+			poolParticlesRef.current = [];
+			currentParticles.clear();
+			currentCompletedEffects.clear();
+		};
+	}, []);
+	const initialPositions = useMemo(() => {
+		return new Float32Array(maxParticles * 3);
+	}, [maxParticles]);
+	useFrame((_, delta) => {
+		if (!enabled || !pointsRef.current) return;
+		const safeDelta = Math.min(delta, BLOOD_CONSTANTS.MAX_DELTA);
+		let totalParticleIndex = 0;
+		const attr = pointsRef.current.geometry.attributes.position;
+		const posArray = attr.array;
+		particlesRef.current.forEach((particles, effectId) => {
+			let hasActiveParticles = false;
+			for (let i = 0; i < particles.length; i++) {
+				const p = particles[i];
+				p.age += safeDelta;
+				if (!p.settled) {
+					p.velocity.y += BLOOD_CONSTANTS.GRAVITY * safeDelta;
+					p.position.addScaledVector(p.velocity, safeDelta);
+					if (p.position.y <= BLOOD_CONSTANTS.FLOOR_Y) {
+						p.position.y = BLOOD_CONSTANTS.FLOOR_Y;
+						p.velocity.set(0, 0, 0);
+						p.settled = true;
+						p.lifetime = BLOOD_CONSTANTS.POOL_FADE_DURATION;
+						p.age = 0;
+						poolParticlesRef.current.push(p);
+					} else hasActiveParticles = true;
+				}
+				if (totalParticleIndex < posArray.length / 3) {
+					posArray[totalParticleIndex * 3] = p.position.x;
+					posArray[totalParticleIndex * 3 + 1] = p.position.y;
+					posArray[totalParticleIndex * 3 + 2] = p.position.z;
+					totalParticleIndex++;
+				} else if (process.env.NODE_ENV === "development") console.warn(`BloodParticles3D: Particle buffer full (${posArray.length / 3} particles). Additional particles are not rendered. Consider reducing particle counts or increasing maxParticles if this happens frequently.`);
+			}
+			if (!hasActiveParticles && !completedEffectsRef.current.has(effectId)) {
+				completedEffectsRef.current.add(effectId);
+				onEffectComplete?.(effectId);
+			}
+		});
+		const maxVisibleParticles = Math.min(maxParticles, posArray.length / 3);
+		if (totalParticleIndex >= maxVisibleParticles) poolParticlesRef.current = poolParticlesRef.current.filter((p) => {
+			p.age += safeDelta;
+			const isAlive = p.age < p.lifetime;
+			if (!isAlive && p.isPooled) {
+				ThreeObjectPools.vector3.release(p.position);
+				ThreeObjectPools.vector3.release(p.velocity);
+				p.isPooled = false;
+			}
+			return isAlive;
+		});
+		else poolParticlesRef.current = poolParticlesRef.current.filter((p) => {
+			p.age += safeDelta;
+			const isAlive = p.age < p.lifetime;
+			if (isAlive && totalParticleIndex < maxVisibleParticles) {
+				posArray[totalParticleIndex * 3] = p.position.x;
+				posArray[totalParticleIndex * 3 + 1] = p.position.y;
+				posArray[totalParticleIndex * 3 + 2] = p.position.z;
+				totalParticleIndex++;
+			}
+			if (!isAlive && p.isPooled) {
+				ThreeObjectPools.vector3.release(p.position);
+				ThreeObjectPools.vector3.release(p.velocity);
+				p.isPooled = false;
+			}
+			return isAlive;
+		});
+		attr.needsUpdate = true;
+	});
+	if (!enabled || effects.length === 0) return null;
+	return /* @__PURE__ */ jsx(Points, {
+		ref: pointsRef,
+		positions: initialPositions,
+		"data-testid": "blood-particles-3d",
+		children: /* @__PURE__ */ jsx(PointMaterial, {
+			color: bloodColor,
+			size: BLOOD_CONSTANTS.PARTICLE_SIZE,
+			sizeAttenuation: true,
+			transparent: true,
+			opacity: .9,
+			depthWrite: false,
+			blending: THREE.NormalBlending
+		})
+	});
+};
+//#endregion
+export { BloodParticles3D as default };
+
+//# sourceMappingURL=BloodParticles3D.js.map

package/lib/components/screens/combat/components/effects/BloodParticles3D.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BloodParticles3D.js","names":[],"sources":["../../../../../../src/components/screens/combat/components/effects/BloodParticles3D.tsx"],"sourcesContent":["/**\n * BloodParticles3D - Realistic blood splatter particle system\n *\n * Creates physics-based blood particles that spray from impact points with gravity,\n * creating pools on the arena floor. Optimized for 60fps with instanced rendering.\n *\n * Features:\n * - Gravity-based particle physics\n * - Blood pool accumulation on floor\n * - 10-second fade-out for pools\n * - Instanced rendering for performance\n * - Mobile-optimized particle counts\n *\n * @module components/combat/BloodParticles3D\n * @category Combat Effects\n * @korean 피입자3D\n */\n\nimport { Points, PointMaterial } from \"@react-three/drei\";\nimport { useFrame } from \"@react-three/fiber\";\nimport React, { useRef, useMemo } from \"react\";\nimport * as THREE from \"three\";\nimport { KOREAN_COLORS } from \"../../../../../types/constants\";\nimport { ThreeObjectPools } from \"../../../../../utils/threeObjectPool\";\n\n/**\n * Blood particle data structure for efficient simulation\n * \n * PERFORMANCE: position and velocity now use pooled Vector3 objects\n * that are acquired on particle creation and released on expiration\n */\ninterface BloodParticle {\n  /** Current position [x, y, z] - POOLED Vector3 */\n  position: THREE.Vector3;\n  /** Current velocity [x, y, z] - POOLED Vector3 */\n  velocity: THREE.Vector3;\n  /** Particle lifetime in seconds */\n  lifetime: number;\n  /** Time elapsed since creation */\n  age: number;\n  /** Whether particle has settled on floor */\n  settled: boolean;\n  /** Flag to track if vectors are pooled and need release */\n  isPooled: boolean;\n}\n\n/**\n * Blood splatter effect configuration\n */\nexport interface BloodSplatterEffect {\n  /** Unique identifier */\n  readonly id: string;\n  /** Origin position in 3D world space */\n  readonly position: [number, number, number];\n  /** Impact direction for splatter */\n  readonly direction: [number, number, number];\n  /** Intensity of effect (0.0 to 1.0) */\n  readonly intensity: number;\n  /** Timestamp when effect was created */\n  readonly startTime: number;\n}\n\n/**\n * Props for BloodParticles3D component\n */\nexport interface BloodParticles3DProps {\n  /** Active blood splatter effects to render */\n  readonly effects: readonly BloodSplatterEffect[];\n  /** Whether to enable blood effects (violence settings) */\n  readonly enabled?: boolean;\n  /** Mobile device mode (reduced particle count) */\n  readonly isMobile?: boolean;\n  /** Callback when effect completes */\n  readonly onEffectComplete?: (effectId: string) => void;\n}\n\n/**\n * Performance and physics constants\n */\nconst BLOOD_CONSTANTS = {\n  /** Gravity acceleration (m/s²) */\n  GRAVITY: -9.8,\n  /** Maximum particles per splatter effect */\n  MAX_PARTICLES_DESKTOP: 300,\n  MAX_PARTICLES_MOBILE: 100,\n  /** Particle lifetime in seconds */\n  PARTICLE_LIFETIME: 2.0,\n  /** Blood pool fade duration in seconds */\n  POOL_FADE_DURATION: 10.0,\n  /** Initial velocity range */\n  VELOCITY_MIN: 2.0,\n  VELOCITY_MAX: 5.0,\n  /** Spread angle in radians */\n  SPREAD_ANGLE: Math.PI / 3,\n  /** Floor Y position */\n  FLOOR_Y: 0.0,\n  /** Particle size */\n  PARTICLE_SIZE: 0.05,\n  /**\n   * Maximum per-frame delta time (seconds) used to clamp the blood physics update.\n   * \n   * We cap the simulation step at ~33ms (1/30) to avoid the classic\n   * \"spiral of death\" when the frame rate drops: very large timesteps can\n   * cause unstable motion, particles tunneling through the floor, or\n   * visually exaggerated splatter. Treating anything below 30fps as\n   * \"slow motion\" for this effect keeps the blood behavior stable even\n   * on slower devices. If the engine's minimum target frame rate changes,\n   * adjust this threshold accordingly.\n   */\n  MAX_DELTA: 1 / 30,\n} as const;\n\n/**\n * Generate initial particles for a blood splatter effect\n * \n * PERFORMANCE OPTIMIZATION: Uses ThreeObjectPools for ALL Vector3 allocations\n * \n * Pooling Strategy (UPDATED):\n * - Acquire temp vectors for calculations (baseDir, origin, axis vectors) - RELEASED\n * - Acquire position/velocity from pool for particle ownership - MUST BE RELEASED on expiration\n * \n * Memory Impact:\n * - Before: 600 Vector3 allocations per splatter (2 per particle × 300)\n * - After: 5 temp vectors (reused) + particles use pooled vectors (released on expiration)\n * - Reduction: ~99.2% fewer allocations (600 → 5 temp + pooled reuse)\n * \n * @param effect - Blood splatter effect configuration\n * @param maxParticles - Maximum number of particles to generate\n * @returns Array of blood particles with ALL vectors from pool (must be released later)\n */\nconst generateBloodParticles = (\n  effect: BloodSplatterEffect,\n  maxParticles: number\n): BloodParticle[] => {\n  const particles: BloodParticle[] = [];\n  const particleCount = Math.floor(maxParticles * effect.intensity);\n\n  // Acquire pooled temp vectors for reuse across all particles\n  // These will be released after the loop completes\n  const baseDir = ThreeObjectPools.vector3.acquire();\n  const origin = ThreeObjectPools.vector3.acquire();\n  const direction = ThreeObjectPools.vector3.acquire();\n  const yAxis = ThreeObjectPools.vector3.acquire();\n  const zAxis = ThreeObjectPools.vector3.acquire();\n\n  // Initialize reusable vectors\n  baseDir.set(...effect.direction).normalize();\n  origin.set(...effect.position);\n  yAxis.set(0, 1, 0);\n  zAxis.set(0, 0, 1);\n\n  for (let i = 0; i < particleCount; i++) {\n    // Random spread around impact direction\n    const spreadAngle = BLOOD_CONSTANTS.SPREAD_ANGLE;\n    const phi = (Math.random() - 0.5) * spreadAngle;\n    const theta = Math.random() * Math.PI * 2;\n\n    // Reuse direction vector: copy base direction and apply rotations\n    direction.copy(baseDir);\n    direction.applyAxisAngle(yAxis, phi);\n    direction.applyAxisAngle(zAxis, theta);\n\n    // Random velocity magnitude\n    const speed =\n      BLOOD_CONSTANTS.VELOCITY_MIN +\n      Math.random() * (BLOOD_CONSTANTS.VELOCITY_MAX - BLOOD_CONSTANTS.VELOCITY_MIN);\n\n    // CRITICAL CHANGE: Acquire pooled vectors for particle ownership\n    // These MUST be released when particle expires!\n    const particlePosition = ThreeObjectPools.vector3.acquire();\n    const particleVelocity = ThreeObjectPools.vector3.acquire();\n    \n    particlePosition.copy(origin);\n    particleVelocity.copy(direction).multiplyScalar(speed);\n\n    particles.push({\n      position: particlePosition,\n      velocity: particleVelocity,\n      lifetime: BLOOD_CONSTANTS.PARTICLE_LIFETIME,\n      age: 0,\n      settled: false,\n      isPooled: true, // Mark as pooled for cleanup\n    });\n  }\n\n  // Release all temp vectors back to pool for reuse\n  ThreeObjectPools.vector3.release(baseDir);\n  ThreeObjectPools.vector3.release(origin);\n  ThreeObjectPools.vector3.release(direction);\n  ThreeObjectPools.vector3.release(yAxis);\n  ThreeObjectPools.vector3.release(zAxis);\n\n  return particles;\n};\n\n/**\n * BloodParticles3D Component\n *\n * Renders realistic blood splatter effects using physics-based particle simulation.\n * Optimized for performance with instanced rendering and efficient physics updates.\n *\n * @example\n * ```tsx\n * const [bloodEffects, setBloodEffects] = useState<BloodSplatterEffect[]>([]);\n *\n * // On hit event\n * const handleHit = (position: [number, number, number], direction: [number, number, number]) => {\n *   setBloodEffects([...bloodEffects, {\n *     id: generateId(),\n *     position,\n *     direction,\n *     intensity: 0.8,\n *     startTime: Date.now(),\n *   }]);\n * };\n *\n * <BloodParticles3D\n *   effects={bloodEffects}\n *   enabled={violenceSettings.blood}\n *   isMobile={isMobile}\n *   onEffectComplete={(id) => {\n *     setBloodEffects(prev => prev.filter(e => e.id !== id));\n *   }}\n * />\n * ```\n */\nexport const BloodParticles3D: React.FC<BloodParticles3DProps> = ({\n  effects,\n  enabled = true,\n  isMobile = false,\n  onEffectComplete,\n}) => {\n  // Particle system state\n  const particlesRef = useRef<Map<string, BloodParticle[]>>(new Map());\n  const poolParticlesRef = useRef<BloodParticle[]>([]);\n  const pointsRef = useRef<THREE.Points>(null);\n  const completedEffectsRef = useRef<Set<string>>(new Set());\n\n  // Performance configuration\n  const maxParticles = isMobile\n    ? BLOOD_CONSTANTS.MAX_PARTICLES_MOBILE\n    : BLOOD_CONSTANTS.MAX_PARTICLES_DESKTOP;\n\n  // Blood color from Korean theme\n  const bloodColor = useMemo(() => KOREAN_COLORS.BLOODLOSS_INDICATOR, []);\n\n  // Initialize particles for new effects\n  React.useEffect(() => {\n    if (!enabled) return;\n\n    effects.forEach((effect) => {\n      if (!particlesRef.current.has(effect.id)) {\n        const particles = generateBloodParticles(effect, maxParticles);\n        particlesRef.current.set(effect.id, particles);\n      }\n    });\n\n    // Clean up removed effects - IMPORTANT: Release pooled vectors!\n    const effectIds = new Set(effects.map((e) => e.id));\n    particlesRef.current.forEach((particles, id) => {\n      if (!effectIds.has(id)) {\n        // Release all pooled vectors for this effect\n        particles.forEach((p) => {\n          if (p.isPooled) {\n            ThreeObjectPools.vector3.release(p.position);\n            ThreeObjectPools.vector3.release(p.velocity);\n            p.isPooled = false;\n          }\n        });\n        particlesRef.current.delete(id);\n        completedEffectsRef.current.delete(id);\n      }\n    });\n  }, [effects, enabled, maxParticles]);\n\n  // Cleanup on unmount - Release ALL pooled vectors\n  React.useEffect(() => {\n    // Capture refs at the start of effect to avoid stale closures\n    const currentParticles = particlesRef.current;\n    const currentPoolParticles = poolParticlesRef.current;\n    const currentCompletedEffects = completedEffectsRef.current;\n    \n    return () => {\n      // Release all active effect particles\n      currentParticles.forEach((particles) => {\n        particles.forEach((p) => {\n          if (p.isPooled) {\n            ThreeObjectPools.vector3.release(p.position);\n            ThreeObjectPools.vector3.release(p.velocity);\n            p.isPooled = false;\n          }\n        });\n      });\n      \n      // Release all pool particles\n      currentPoolParticles.forEach((p) => {\n        if (p.isPooled) {\n          ThreeObjectPools.vector3.release(p.position);\n          ThreeObjectPools.vector3.release(p.velocity);\n          p.isPooled = false;\n        }\n      });\n      \n      // Clear the pool particles array for complete cleanup\n      poolParticlesRef.current = [];\n      \n      // Clear refs\n      currentParticles.clear();\n      currentCompletedEffects.clear();\n    };\n  }, []);\n\n  // Initial particle positions for first render\n  // Actual positions are updated in useFrame\n  const initialPositions = useMemo(() => {\n    const positions = new Float32Array(maxParticles * 3);\n    // Initialize with zeros - actual positions set in useFrame\n    return positions;\n  }, [maxParticles]);\n\n  // Physics update loop\n  useFrame((_, delta) => {\n    if (!enabled || !pointsRef.current) return;\n\n    const safeDelta = Math.min(delta, BLOOD_CONSTANTS.MAX_DELTA);\n\n    let totalParticleIndex = 0;\n    const attr = pointsRef.current.geometry.attributes.position;\n    const posArray = attr.array as Float32Array;\n\n    // Update active splatter particles\n    particlesRef.current.forEach((particles, effectId) => {\n      let hasActiveParticles = false;\n\n      for (let i = 0; i < particles.length; i++) {\n        const p = particles[i];\n        p.age += safeDelta;\n\n        if (!p.settled) {\n          // Apply gravity\n          p.velocity.y += BLOOD_CONSTANTS.GRAVITY * safeDelta;\n\n          // Update position\n          p.position.addScaledVector(p.velocity, safeDelta);\n\n          // Check floor collision\n          if (p.position.y <= BLOOD_CONSTANTS.FLOOR_Y) {\n            p.position.y = BLOOD_CONSTANTS.FLOOR_Y;\n            p.velocity.set(0, 0, 0);\n            p.settled = true;\n            p.lifetime = BLOOD_CONSTANTS.POOL_FADE_DURATION;\n            p.age = 0;\n\n            // Add to pool particles\n            poolParticlesRef.current.push(p);\n          } else {\n            hasActiveParticles = true;\n          }\n        }\n\n        // Update render position\n        if (totalParticleIndex < posArray.length / 3) {\n          posArray[totalParticleIndex * 3] = p.position.x;\n          posArray[totalParticleIndex * 3 + 1] = p.position.y;\n          posArray[totalParticleIndex * 3 + 2] = p.position.z;\n          totalParticleIndex++;\n        } else if (process.env.NODE_ENV === \"development\") {\n          // Warn in development when particles are being dropped due to buffer overflow\n          console.warn(\n            `BloodParticles3D: Particle buffer full (${posArray.length / 3} particles). ` +\n            `Additional particles are not rendered. Consider reducing particle counts or ` +\n            `increasing maxParticles if this happens frequently.`\n          );\n        }\n      }\n\n      // Check if effect is complete\n      if (!hasActiveParticles && !completedEffectsRef.current.has(effectId)) {\n        completedEffectsRef.current.add(effectId);\n        onEffectComplete?.(effectId);\n      }\n    });\n\n    // Determine the maximum number of particles we can safely render this frame.\n    // This explicitly ties the visible particle cap to both the buffer size and maxParticles.\n    const maxVisibleParticles = Math.min(maxParticles, posArray.length / 3);\n\n    // Update blood pool particles (fade out)\n    if (totalParticleIndex >= maxVisibleParticles) {\n      // Buffer is full: continue aging and culling pool particles, but do not write positions.\n      poolParticlesRef.current = poolParticlesRef.current.filter((p) => {\n        p.age += safeDelta;\n        const isAlive = p.age < p.lifetime;\n        \n        // Release pooled vectors when particle dies\n        if (!isAlive && p.isPooled) {\n          ThreeObjectPools.vector3.release(p.position);\n          ThreeObjectPools.vector3.release(p.velocity);\n          p.isPooled = false; // Mark as released\n        }\n        \n        return isAlive;\n      });\n    } else {\n      // There is still room in the buffer: write pool particle positions up to the cap.\n      poolParticlesRef.current = poolParticlesRef.current.filter((p) => {\n        p.age += safeDelta;\n        const isAlive = p.age < p.lifetime;\n\n        if (isAlive && totalParticleIndex < maxVisibleParticles) {\n          posArray[totalParticleIndex * 3] = p.position.x;\n          posArray[totalParticleIndex * 3 + 1] = p.position.y;\n          posArray[totalParticleIndex * 3 + 2] = p.position.z;\n          totalParticleIndex++;\n        }\n\n        // Release pooled vectors when particle dies\n        if (!isAlive && p.isPooled) {\n          ThreeObjectPools.vector3.release(p.position);\n          ThreeObjectPools.vector3.release(p.velocity);\n          p.isPooled = false; // Mark as released\n        }\n\n        return isAlive;\n      });\n    }\n\n    attr.needsUpdate = true;\n  });\n\n  // Don't render if disabled or no effects\n  if (!enabled || effects.length === 0) {\n    return null;\n  }\n\n  return (\n    <Points\n      ref={pointsRef}\n      positions={initialPositions}\n      data-testid=\"blood-particles-3d\"\n    >\n      <PointMaterial\n        color={bloodColor}\n        size={BLOOD_CONSTANTS.PARTICLE_SIZE}\n        sizeAttenuation\n        transparent\n        opacity={0.9}\n        depthWrite={false}\n        blending={THREE.NormalBlending}\n      />\n    </Points>\n  );\n};\n\nexport default BloodParticles3D;\n"],"mappings":"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"}

package/lib/components/screens/combat/components/effects/BloodViscosity3D.d.ts

@@ -0,0 +1,64 @@
+/**
+ * BloodViscosity3D - Enhanced blood droplets with thicker physics for brutal combat realism
+ *
+ * Priority #5: Enhanced Blood Viscosity
+ * - Thicker droplets with slower fall rate
+ * - Variable splatter sizes (gouts vs mist)
+ * - Cling/drip physics (stick to surfaces)
+ * - Enhanced viscosity simulation
+ *
+ * PERFORMANCE OPTIMIZATION (Object Pooling):
+ * - Reduced allocations from ~85+ per effect to ~4 pooled objects
+ * - Pooling strategy:
+ *   1. Temporary calculation objects (direction, color, velocity) use pool
+ *   2. Owned objects (particle velocities) are cloned from pooled objects
+ *   3. All pooled objects released after particle creation
+ * - Estimated reduction:
+ *   - thin: 50 Color + 50 Vector3 = 100 allocations → 4 pooled objects
+ *   - medium: 80 Color + 80 Vector3 = 160 allocations → 4 pooled objects
+ *   - thick: 120 Color + 120 Vector3 = 240 allocations → 4 pooled objects
+ *   - gout: 200 Color + 200 Vector3 = 400 allocations → 4 pooled objects
+ *
+ * Korean martial arts context:
+ * - 절단격 (Cutting strikes) - Thin blood mist
+ * - 타격 (Impact strikes) - Medium blood splatter
+ * - 관통격 (Penetrating strikes) - Thick blood droplets
+ * - 깊은 상처 (Deep wounds) - Large blood gouts
+ */
+import React from 'react';
+/**
+ * Viscosity types for blood splatter
+ */
+export type ViscosityType = 'thin' | 'medium' | 'thick' | 'gout';
+/**
+ * Individual blood viscosity effect
+ */
+export interface BloodViscosityEffect {
+    readonly id: string;
+    readonly position: [number, number, number];
+    readonly direction: [number, number, number];
+    readonly viscosityType: ViscosityType;
+    readonly intensity: number;
+    readonly startTime: number;
+}
+/**
+ * Props for BloodViscosity3D component
+ */
+export interface BloodViscosity3DProps {
+    readonly effects: readonly BloodViscosityEffect[];
+    readonly enabled?: boolean;
+    readonly isMobile?: boolean;
+    readonly onEffectComplete?: (id: string) => void;
+}
+/**
+ * BloodViscosity3D - Enhanced blood droplets with realistic thicker physics
+ *
+ * Features:
+ * - Variable viscosity types (thin mist to thick gouts)
+ * - Cling/drip physics when hitting ground
+ * - Slower fall rates than arterial spray
+ * - Larger droplet sizes
+ * - Mobile optimization (50% particles)
+ */
+export declare const BloodViscosity3D: React.FC<BloodViscosity3DProps>;
+//# sourceMappingURL=BloodViscosity3D.d.ts.map

package/lib/components/screens/combat/components/effects/BloodViscosity3D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BloodViscosity3D.d.ts","sourceRoot":"","sources":["../../../../../../src/components/screens/combat/components/effects/BloodViscosity3D.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAA6B,MAAM,OAAO,CAAC;AAKlD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AAEjE;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAClD,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;CAClD;AAwDD;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,qBAAqB,CA+O5D,CAAC"}

package/lib/components/screens/combat/components/effects/BloodViscosity3D.js

@@ -0,0 +1,248 @@
+import { ThreeObjectPools } from "../../../../../utils/threeObjectPool.js";
+import React, { useEffect, useMemo } from "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { useFrame } from "@react-three/fiber";
+import * as THREE from "three";
+//#region src/components/screens/combat/components/effects/BloodViscosity3D.tsx
+/**
+* BloodViscosity3D - Enhanced blood droplets with thicker physics for brutal combat realism
+*
+* Priority #5: Enhanced Blood Viscosity
+* - Thicker droplets with slower fall rate
+* - Variable splatter sizes (gouts vs mist)
+* - Cling/drip physics (stick to surfaces)
+* - Enhanced viscosity simulation
+*
+* PERFORMANCE OPTIMIZATION (Object Pooling):
+* - Reduced allocations from ~85+ per effect to ~4 pooled objects
+* - Pooling strategy:
+*   1. Temporary calculation objects (direction, color, velocity) use pool
+*   2. Owned objects (particle velocities) are cloned from pooled objects
+*   3. All pooled objects released after particle creation
+* - Estimated reduction: 
+*   - thin: 50 Color + 50 Vector3 = 100 allocations → 4 pooled objects
+*   - medium: 80 Color + 80 Vector3 = 160 allocations → 4 pooled objects
+*   - thick: 120 Color + 120 Vector3 = 240 allocations → 4 pooled objects
+*   - gout: 200 Color + 200 Vector3 = 400 allocations → 4 pooled objects
+*
+* Korean martial arts context:
+* - 절단격 (Cutting strikes) - Thin blood mist
+* - 타격 (Impact strikes) - Medium blood splatter
+* - 관통격 (Penetrating strikes) - Thick blood droplets
+* - 깊은 상처 (Deep wounds) - Large blood gouts
+*/
+var BLOOD_VISCOSITY_CONSTANTS = {
+	GRAVITY: -9.8,
+	AIR_RESISTANCE: .94,
+	PARTICLE_COUNT: {
+		thin: 50,
+		medium: 80,
+		thick: 120,
+		gout: 200
+	},
+	VELOCITY: {
+		thin: {
+			min: 2,
+			max: 4
+		},
+		medium: {
+			min: 1.5,
+			max: 3
+		},
+		thick: {
+			min: 1,
+			max: 2.5
+		},
+		gout: {
+			min: .5,
+			max: 2
+		}
+	},
+	SIZE: {
+		thin: {
+			min: .02,
+			max: .04
+		},
+		medium: {
+			min: .04,
+			max: .08
+		},
+		thick: {
+			min: .06,
+			max: .12
+		},
+		gout: {
+			min: .1,
+			max: .2
+		}
+	},
+	SPREAD_ANGLE: {
+		thin: Math.PI / 3,
+		medium: Math.PI / 4,
+		thick: Math.PI / 6,
+		gout: Math.PI / 8
+	},
+	ACTIVE_LIFETIME: 2.5,
+	CLING_LIFETIME: 3,
+	TOTAL_LIFETIME: 5.5,
+	GROUND_LEVEL: .1,
+	CLING_DAMPING: .3,
+	BLOOD_COLOR: 9109504,
+	MAX_DELTA: 1 / 30
+};
+/**
+* BloodViscosity3D - Enhanced blood droplets with realistic thicker physics
+*
+* Features:
+* - Variable viscosity types (thin mist to thick gouts)
+* - Cling/drip physics when hitting ground
+* - Slower fall rates than arterial spray
+* - Larger droplet sizes
+* - Mobile optimization (50% particles)
+*/
+var BloodViscosity3D = ({ effects, enabled = true, isMobile = false, onEffectComplete }) => {
+	const [effectInstances, setEffectInstances] = React.useState(/* @__PURE__ */ new Map());
+	const getParticleCount = useMemo(() => (viscosityType) => {
+		const baseCount = BLOOD_VISCOSITY_CONSTANTS.PARTICLE_COUNT[viscosityType];
+		return isMobile ? Math.floor(baseCount * .5) : baseCount;
+	}, [isMobile]);
+	const createBloodParticles = useMemo(() => (effect) => {
+		const count = getParticleCount(effect.viscosityType);
+		const geometry = new THREE.BufferGeometry();
+		const positions = new Float32Array(count * 3);
+		const colors = new Float32Array(count * 3);
+		const sizes = new Float32Array(count);
+		const velocities = [];
+		const clinging = [];
+		const tempDirection = ThreeObjectPools.vector3.acquire();
+		const tempColor = ThreeObjectPools.color.acquire();
+		const tempVelocity = ThreeObjectPools.vector3.acquire();
+		const tempDeviation = ThreeObjectPools.vector3.acquire();
+		try {
+			tempDirection.set(...effect.direction).normalize();
+			const spreadAngle = BLOOD_VISCOSITY_CONSTANTS.SPREAD_ANGLE[effect.viscosityType];
+			const velocityRange = BLOOD_VISCOSITY_CONSTANTS.VELOCITY[effect.viscosityType];
+			const sizeRange = BLOOD_VISCOSITY_CONSTANTS.SIZE[effect.viscosityType];
+			tempColor.set(BLOOD_VISCOSITY_CONSTANTS.BLOOD_COLOR);
+			for (let i = 0; i < count; i++) {
+				positions[i * 3] = 0;
+				positions[i * 3 + 1] = 0;
+				positions[i * 3 + 2] = 0;
+				colors[i * 3] = tempColor.r;
+				colors[i * 3 + 1] = tempColor.g;
+				colors[i * 3 + 2] = tempColor.b;
+				sizes[i] = sizeRange.min + Math.random() * (sizeRange.max - sizeRange.min) * effect.intensity;
+				const speed = velocityRange.min + Math.random() * (velocityRange.max - velocityRange.min);
+				const theta = (Math.random() - .5) * spreadAngle;
+				const phi = Math.random() * Math.PI * 2;
+				tempDeviation.set(Math.sin(theta) * Math.cos(phi), Math.sin(theta) * Math.sin(phi), Math.cos(theta));
+				tempVelocity.copy(tempDirection).add(tempDeviation).normalize().multiplyScalar(speed);
+				velocities.push(tempVelocity.clone());
+				clinging.push(false);
+			}
+		} finally {
+			ThreeObjectPools.vector3.release(tempDirection);
+			ThreeObjectPools.color.release(tempColor);
+			ThreeObjectPools.vector3.release(tempVelocity);
+			ThreeObjectPools.vector3.release(tempDeviation);
+		}
+		geometry.setAttribute("position", new THREE.BufferAttribute(positions, 3));
+		geometry.setAttribute("color", new THREE.BufferAttribute(colors, 3));
+		geometry.setAttribute("size", new THREE.BufferAttribute(sizes, 1));
+		const material = new THREE.PointsMaterial({
+			size: .08,
+			vertexColors: true,
+			transparent: true,
+			opacity: .9,
+			blending: THREE.NormalBlending,
+			depthWrite: false,
+			sizeAttenuation: true
+		});
+		const points = new THREE.Points(geometry, material);
+		points.position.set(...effect.position);
+		return {
+			points,
+			velocities,
+			clinging
+		};
+	}, [getParticleCount]);
+	useEffect(() => {
+		if (!enabled) return;
+		setEffectInstances((prev) => {
+			const updated = new Map(prev);
+			effects.forEach((effect) => {
+				if (!updated.has(effect.id)) {
+					const { points, velocities, clinging } = createBloodParticles(effect);
+					updated.set(effect.id, {
+						particles: points,
+						velocities,
+						startTime: effect.startTime,
+						effect,
+						clinging
+					});
+				}
+			});
+			const currentIds = new Set(effects.map((e) => e.id));
+			Array.from(updated.keys()).forEach((id) => {
+				if (!currentIds.has(id)) {
+					const instance = updated.get(id);
+					if (instance) {
+						instance.particles.geometry.dispose();
+						instance.particles.material.dispose();
+					}
+					updated.delete(id);
+				}
+			});
+			return updated;
+		});
+	}, [
+		effects,
+		enabled,
+		createBloodParticles
+	]);
+	useFrame((_state, delta) => {
+		if (!enabled || effectInstances.size === 0) return;
+		const clampedDelta = Math.min(delta, BLOOD_VISCOSITY_CONSTANTS.MAX_DELTA);
+		const now = Date.now();
+		const completedIds = [];
+		effectInstances.forEach((instance, id) => {
+			const elapsed = (now - instance.startTime) / 1e3;
+			if (elapsed >= BLOOD_VISCOSITY_CONSTANTS.TOTAL_LIFETIME) {
+				completedIds.push(id);
+				return;
+			}
+			const geometry = instance.particles.geometry;
+			const positions = geometry.attributes.position.array;
+			const count = positions.length / 3;
+			for (let i = 0; i < count; i++) {
+				const idx = i * 3;
+				if (!instance.clinging[i]) {
+					instance.velocities[i].y += BLOOD_VISCOSITY_CONSTANTS.GRAVITY * clampedDelta;
+					instance.velocities[i].multiplyScalar(BLOOD_VISCOSITY_CONSTANTS.AIR_RESISTANCE);
+					positions[idx] += instance.velocities[i].x * clampedDelta;
+					positions[idx + 1] += instance.velocities[i].y * clampedDelta;
+					positions[idx + 2] += instance.velocities[i].z * clampedDelta;
+					if (positions[idx + 1] <= BLOOD_VISCOSITY_CONSTANTS.GROUND_LEVEL) {
+						positions[idx + 1] = BLOOD_VISCOSITY_CONSTANTS.GROUND_LEVEL;
+						instance.velocities[i].multiplyScalar(BLOOD_VISCOSITY_CONSTANTS.CLING_DAMPING);
+						instance.clinging[i] = true;
+					}
+				}
+			}
+			geometry.attributes.position.needsUpdate = true;
+			if (elapsed >= BLOOD_VISCOSITY_CONSTANTS.ACTIVE_LIFETIME) {
+				const fadeProgress = (elapsed - BLOOD_VISCOSITY_CONSTANTS.ACTIVE_LIFETIME) / BLOOD_VISCOSITY_CONSTANTS.CLING_LIFETIME;
+				const material = instance.particles.material;
+				material.opacity = .9 * (1 - fadeProgress);
+			}
+		});
+		completedIds.forEach((id) => {
+			onEffectComplete?.(id);
+		});
+	});
+	return /* @__PURE__ */ jsx(Fragment, { children: Array.from(effectInstances.values()).map((instance) => /* @__PURE__ */ jsx("primitive", { object: instance.particles }, instance.effect.id)) });
+};
+//#endregion
+export { BloodViscosity3D };
+
+//# sourceMappingURL=BloodViscosity3D.js.map