Frequently Asked Questions

Yes. The player uses a procedural animation system, allowing you to modify existing animations or add new ones.

The animation logic is fully modular and decoupled from movement, camera, and combat systems, so visual customization will not affect core gameplay behavior.

Yes, but the model pivot points must be preserved. Correct pivot placement is required for procedural animations to work properly.

Required pivot setup:
• Head and Chest: bottom face, centered
• Arms and Legs: top face, centered

Maintaining these pivots ensures correct limb rotation, positioning, and animation calculations within the PlayerController.

The VoxelPlayerController requires Unity 2020.3 LTS or newer. It has been tested extensively on 6000.2.9f1.

The system uses only stable, long-term supported Unity APIs and follows Unity's best practices for compatibility across LTS releases.

Yes, both systems are supported simultaneously. The PlayerInputManager automatically detects which input system is available at runtime and provides a unified abstraction layer.

Key features:

• Automatic detection of Input System package availability
• Fallback to Legacy Input if New System is unavailable
• Consistent API across both systems
• Automatic InputActionAsset creation if missing
• Gamepad/keyboard+mouse scheme switching

The asset is built for Built-in Render Pipeline but is fully compatible with URP and HDRP through material reassignment.

Conversion process:

1. Import the asset into your URP/HDRP project
2. Use Unity's Render Pipeline Converter (Window → Rendering → Render Pipeline Converter)
3. Convert materials and shaders to your target pipeline
4. Reassign any converted materials in the prefabs

No code changes are required - all systems are render pipeline agnostic.

Minimal dependencies:

• Optional: Unity's Input System Package (for New Input System features)
• Optional: NavMesh Components (for AdvancedNPC system - included in Unity)
• Required: Standard Unity components only (Rigidbody, Collider, etc.)

The system is designed to work with vanilla Unity installations. All optional dependencies have graceful fallbacks if unavailable.

Under 5 minutes for basic functionality. The system follows a plug-and-play philosophy:

1. Import the asset package
2. Add the player prefab to your scene
3. Configure environment layers (Ground, Water, Player, Enemy)
4. Press Play

All core systems are pre-wired in the provided prefabs. Configuration is Inspector-driven with sensible defaults that work immediately.

No code required for standard use cases. The system is designed for full Inspector configuration:

• All parameters exposed in Inspector with tooltips
• Sensible defaults for immediate functionality
• Visual debugging aids in Scene view
• Real-time parameter adjustment while playing

Code modification is only needed for advanced customization or integration with unique game systems.

Not directly included, but architecturally ready for networking. The decoupled design makes network integration straightforward:

• State-based systems are easy to synchronize
• Event-driven architecture fits network messaging patterns
• Clean public APIs for remote procedure calls
• No singleton patterns or global state that complicate networking

You would need to add networking (Mirror, Netcode, Photon, etc.) on top, but the architecture won't fight you.

Yes, with input system configuration. The PlayerInputManager abstracts input processing:

• New Input System supports touch, gyro, and mobile controls
• Same movement/combat systems work across all platforms
• Performance-optimized for mobile (cooldowns, reduced checks)
• Camera sensitivity adjustable for touch vs mouse

You'll need to set up touch control schemes in the Input System, but the core controller handles them natively.

Yes, that's the core architectural benefit. Each system is completely decoupled:

• Disable PlayerDamage if you don't need combat
• Replace PlayerCamera with your own camera system
• Use only the AI (AdvancedNPC) without player systems
• Mix and match systems as needed

Systems communicate through clean interfaces, not direct dependencies. Removing a system won't break others (they'll gracefully handle missing dependencies).

Procedural animation for precise control. The system uses Transform-based procedural animation instead of Unity's Animator Controller:

• PlayerController: Procedural limb/body movement
• PlayerDamage: Bézier curve weapon animations
• WaterSwimming: Physics-based swimming animations
• AdvancedNPC: Procedural movement and combat animations

This allows for frame-perfect control, smoother transitions, and better performance than complex animator state machines.

Yes, with smooth transitions. PlayerCamera supports:

• First-person view with crosshair
• Third-person orbital camera
• Automatic switching based on water state
• Manual switching via input or code
• Collision avoidance in third-person
• Smooth interpolation between views

The system automatically handles camera-relative movement calculation regardless of view mode.

AdvancedNPC includes a complete state-driven AI system:

• Idle: Timed waiting with random durations
• Patrol: Random point navigation within radius
• Chase: Player pursuit with pathfinding
• Attack: Melee combat with cooldowns
• Return: Path back to initial position
• Dead: Death animation and cleanup

All behaviors use NavMesh for navigation and include configurable radii, speeds, and timing parameters.

Centralized through PlayerAudioController with five dedicated AudioSources:

• Land: Footsteps, jumps, landings, crouches, dashes
• Water: Splashes, swimming loops
• Melee: Weapon swings, hits, equip/unequip
• Damage: Damage taken, death sounds
• Health: Healing, regeneration (reserved)

Other systems call simple API methods (PlayStepSound(), PlayMeleeSwingSound(), etc.) without managing audio playback themselves.

Yes, with configurable performance options:

• Cooldown systems: Environment checks use 0.1s cooldowns
• Optimization radii: Distant water/NPCs ignored
• Pre-allocation: AudioSources created at startup
• Squared distances: AI uses squared calculations
• Coroutine management: Proper cleanup and cancellation

For VR, you may need to adjust camera settings and disable certain visual effects, but the core systems are performant.

Minimal with default settings:

• PlayerController: ~0.1ms per frame
• PlayerEnvironmentSensor: ~0.05ms (with cooldowns)
• AdvancedNPC: ~0.2ms per NPC (varies with state)
• Audio: Fixed cost (5 AudioSources)
• Total typical: 0.5-1ms for full system

Performance scales with configured check frequencies and number of active NPCs. All expensive operations are throttled.

Standard Unity Asset Store EULA. This allows:

• Commercial game development
• Use in unlimited projects
• Team usage (seat-based licensing)
• Distribution in finished products
• Modification for your specific needs

You cannot redistribute the asset source code as-is or in competing products. Full EULA available on the Unity Asset Store page.

Comprehensive support package:

• Documentation: 44-page PDF technical documentation
• Updates: Free updates for the current major version
• Example: Complete example scene
• Source Code: Full C# source included

Major version upgrades (2.0, 3.0) may require repurchase, following Unity Asset Store policies.

Check requirements before purchase:

• Unity 2020.3 LTS or newer
• Built-in Render Pipeline (convertible to URP/HDRP)
• Standard Unity components only

If you encounter technical issues:

1. Check the documentation and example scenes
2. Contact support with specific error details
3. Unity Asset Store offers refunds within specific conditions

The system has been tested across of projects and Unity versions.