> ## Documentation Index > Fetch the complete documentation index at: https://docs.kinemation.xyz/llms.txt > Use this file to discover all available pages before exploring further. # Weapons > Configure the hunting rifle, bow, spear, knife, and axe and understand their animation and gameplay connections. The rifle and bow use `WeaponExample` for ammunition and firing timing. The spear, knife, and axe use `GameplayItemExample`, which forwards actions directly to their views. All five use `GameplayAnimationController` for the character animation and an item-specific procedural asset for the holding pose. | Prefab | View | Example component | Procedural asset | | - | - | - | - | | `Prefabs/Weapons/W_DL700` | `SurvivalRifleView` | `WeaponExample` | `PA_SurvivalPack_DL700` | | `Prefabs/Weapons/W_HX2` | `SurvivalBowView` | `WeaponExample` | `PA_SurvivalPack_HX2` | | `Prefabs/Items/W_Spear` | `SurvivalSpearView` | `GameplayItemExample` | `PA_SurvivalPack_Spear` | | `Prefabs/Items/W_Knife` | `SurvivalKnifeView` | `GameplayItemExample` | `PA_SurvivalPack_Knife` | | `Prefabs/Items/W_Axe` | `SurvivalAxeView` | `GameplayItemExample` | `PA_SurvivalPack_Axe` | Paths are relative to `Assets/KINEMATION/SurvivalPack`. Add these prefabs to **Item Prefabs** on `SurvivalPackController` before entering Play mode. ## Hunting rifle `W_DL700` uses `SurvivalRifleView`, which extends `WeaponView`. `WeaponExample` checks ammunition and the firing interval before asking the view to play a shot. The configured example has a five-round capacity, a fire rate of `40` rounds per minute, and semi-automatic fire. ![Survival Rifle View with DL700 procedural settings, recoil, aim point, reload loop, reload end, bolt pull, and ammo bones](https://mintcdn.com/kinemation/ZGatOp3ICUy8H4tB/survival-pack/unity/images/survival-pack_rifle-view-component.png?fit=max\&auto=format\&n=ZGatOp3ICUy8H4tB\&q=85\&s=ac6ac1434570982310b6c8c6f83ba88b) The DL700 view connects its procedural asset, paired actions, recoil, aim point, and bolt-action sequence. ### Animation setup Character clips live in `Animations/DL700/Character`; matching rifle clips live in `Animations/DL700/Weapon`. Draw, holster, reload start, reload loop, reload end, and bolt pull each have a character/item pair. The prefab leaves **Fire** and **Fire Out** empty. Recoil, camera shake, fire sound, and muzzle effects create the shot response. **Bolt Pull** plays afterward to animate the hands and rifle bolt together. `PA_SurvivalPack_DL700` sets the holding pose and procedural alignment. **Aim Point** identifies the sight line for ADS. The example uses a default FOV of `80`, an aim FOV of `35`, `Recoil_DL700`, and `Shake_Rifle`. These are values on this prefab. ### Firing and bolt pull After the shared firing effects, `SurvivalRifleView.PlayFireEffects()` starts an action for **Bolt Delay** plus the bolt pair's duration. It schedules **Bolt Pull** after the delay, which is `0.15` seconds on the prefab. Keep the bolt animation paired when replacing it. Adjust **Bolt Delay** when the new shot response needs a different pause before cycling the bolt. ### Reload sequence 1. **R** calls `WeaponExample.Reload()`, which invokes `SurvivalRifleView.OnReload()`. 2. The view plays **Reload Empty** as the reload-start pair and returns `-1`, because the number of insertion loops determines the duration. 3. **Reload Loop** repeats while ammunition remains below capacity. 4. The item clip `A_W_DL700_Reload_Loop` calls `AddAmmo` with one round. `WeaponExample` receives that event on the item GameObject and updates its ammunition. 5. Once full, the view plays **Reload End** and starts a timer for its duration. Preserve the insertion event when replacing the item clip. Without the ammo update, a valid reload loop keeps repeating. Unequipping or disabling the view cancels its scheduled callbacks. **Ammo Bones** controls visible ammunition parts: the view reveals the first N assigned bones for N rounds remaining. This list represents visible mesh parts; it does not set weapon capacity. The screenshot shows four assigned bones, while `WeaponExample` has a capacity of five. ## HX2 bow `W_HX2` combines `WeaponExample`, `SurvivalBowView`, and `ProjectileInventory`. The example has a one-round capacity and a fire rate of `60` rounds per minute. The view handles drawing the bow, releasing an arrow, loading the next arrow, and returning to aim. ![Survival Bow View Bow tab with the HX2 procedural asset, Projectile Inventory, ArrowSocket, and Ads Curve](https://mintcdn.com/kinemation/ZGatOp3ICUy8H4tB/survival-pack/unity/images/survival-pack_bow-view-component.png?fit=max\&auto=format\&n=ZGatOp3ICUy8H4tB\&q=85\&s=a3d8e3601ab021ac0b5505fe01f0822a) The Bow tab connects projectile selection, the arrow spawn transform, and the ADS blend curve. ### Aim overlay `PA_SurvivalPack_HX2` assigns `Overlay_SurvivalPack_HX2.controller` from `Animations/HX2/Character`. The view sets its `BowDrawn` boolean when aiming and also updates the item Animator's matching parameter. ![HX2 overlay Animator with Idle, IdleToAim, Loop, and AimToIdle states](https://mintcdn.com/kinemation/ZGatOp3ICUy8H4tB/survival-pack/unity/images/survival-pack_bow-overlay-animator.png?fit=max\&auto=format\&n=ZGatOp3ICUy8H4tB\&q=85\&s=3debc38ae6394ea5e963437854062f59) BowDrawn drives the bow overlay through idle, draw-to-aim, held aim, and return-to-idle states. **Ads Curve** controls the runtime ADS feature weight. The view advances the curve while aiming and reverses it while lowering or loading. Aiming also updates the camera FOV and recoil aim state. Keep the overlay assigned and preserve `BowDrawn` when replacing the controller. ### Fire and load an arrow Character and bow pairs are in `Animations/HX2/Character` and `Animations/HX2/Weapon`. The **Fire** pair plays the release, and **Reload Empty** loads the next arrow. Firing clears `BowDrawn`, plays the shared weapon effects, marks a pending projectile, and starts an action covering the fire and reload durations. The `LaunchProjectile` event in `A_FP_HX2_Fire` calls `SurvivalPackController`, which forwards it to the active view. The view spawns the selected arrow at **Arrow**, or at the item position if that transform is unset, using the camera's forward direction. It hides the held arrow mesh through `ProjectileInventory`. After the fire pair ends, the view plays the reload pair, restores ammunition, and reveals the next held arrow after the character reload's blend-in time. If aim is still held when loading finishes, it restores the drawn pose. Unequipping cancels loading and clears the pending projectile and aim state. ## Spear `SurvivalSpearView` extends `SurvivalItemView` and implements `ISurvivalProjectileWeapon`. `GameplayItemExample` forwards use and aim calls to it. `ProjectileInventory` selects the spear mesh and projectile prefab. ![Survival Spear View with Use Animation, Low Attack, Throw Release, Grip Animation, Projectile Inventory, and Grip Animation Speed](https://mintcdn.com/kinemation/ZGatOp3ICUy8H4tB/survival-pack/unity/images/survival-pack_spear-view-component.png?fit=max\&auto=format\&n=ZGatOp3ICUy8H4tB\&q=85\&s=6497a8ccc4ca7ac54d937999cade8208) The spear view assigns discrete attacks and throwing, plus the grip animation and projectile inventory. ### Grip and attacks `PA_SurvivalPack_Spear` assigns `Overlay_SurvivalPack_Spear.controller`. The view updates its `Grip` float from vertical look input and **Grip Animation Speed**. The overlay uses the grip animation to blend between high and low holding poses. Without aiming, use selects **Use Animation** above the look threshold or **Low Attack** below it. The prefab assigns `A_FP_Spear_High_Idle_Attack` and `A_FP_Spear_Low_Idle_Attack`. These are character-only actions; the spear's own animation slot can stay empty. ### Prepare and throw Aiming sets the overlay's `ThrowReady` boolean. Using the spear while aimed plays **Throw Release**, marks a pending projectile, and keeps the action active through the release and redraw durations. `A_FP_Spear_Throw_Release` contains `LaunchProjectile`. The controller forwards it to the spear view, which spawns the selected spear and hides the held mesh. When release finishes, the view plays **Draw**, restores the held mesh, and clears aiming. Keep `Grip`, `ThrowReady`, the overlay controller, and the release event connected when changing the spear animations. ## Knife `W_Knife` uses `GameplayItemExample` and `SurvivalKnifeView`. Its **Draw**, **Holster**, **Use Animation**, and **Alternate Attack** fields contain character animations from `Animations/Knife/Character`. Each use randomly chooses `A_FP_Knife_Slash_Left` or `A_FP_Knife_Slash_Right`. The view starts an action timer for `40%` of the selected pair's duration, allowing the next action before the full clip finishes. `PA_SurvivalPack_Knife` controls the resting pose and placement. Replace both slash assets when adapting the attacks. Keep their masks and blending settings appropriate for the hands and upper body. Add hit detection and damage in your gameplay code at the contact moment; the view plays the attack animation. ## Axe `W_Axe` uses `GameplayItemExample` and `SurvivalAxeView`. Use randomly selects **Use Animation** or **Alternate Attack**, assigned to `A_FP_Axe_Horizontal_Swing` and `A_FP_Axe_Vertical_Swing`. Its action timer is `60%` of the selected pair's duration. ### Block overlay `PA_SurvivalPack_Axe` assigns `Overlay_SurvivalPack_Axe.controller`. The overlay samples `A_FP_Axe_Block` using its `Block` motion-time parameter. ![Axe overlay state with A\_FP\_Axe\_Block, zero playback speed, and Block assigned as Motion Time](https://mintcdn.com/kinemation/ZGatOp3ICUy8H4tB/survival-pack/unity/images/survival-pack_axe-overlay-animator.png?fit=max\&auto=format\&n=ZGatOp3ICUy8H4tB\&q=85\&s=4964763b52e367b929ae4233dc7a6561) The axe overlay uses Block as normalized motion time for the block animation. Aim input sets the view's blocking state. Each update moves `Block` toward the raised or lowered pose using **Block Speed** and easing. Keep the parameter and motion-time binding when replacing the overlay. The view controls the visual block pose; implement damage reduction or attack rejection in your combat code. ## Projectile selection and flight The bow and spear use `ProjectileInventory`. Each entry connects a **Prefab** to spawn with a held **Mesh** to show. **N** calls `OnChangeProjectile` on the controller, which asks the active ranged view to select the next entry when no action or loading sequence is active. ![Projectile Inventory with modern arrow and stone arrow prefab and mesh pairs](https://mintcdn.com/kinemation/ZGatOp3ICUy8H4tB/survival-pack/unity/images/survival-pack_projectile-inventory-component.png?fit=max\&auto=format\&n=ZGatOp3ICUy8H4tB\&q=85\&s=2cd3873200d8603c9933443d1e63984d) Each bow projectile entry pairs the spawned arrow prefab with its held mesh. Only the selected mesh is visible. Launch hides it, and the view's reload or redraw reveals the next held projectile at the appropriate time. ![Projectiles folder containing arrow, stone arrow, spear, stone spear, and flare prefabs](https://mintcdn.com/kinemation/ZGatOp3ICUy8H4tB/survival-pack/unity/images/survival-pack_projectiles-folder.png?fit=max\&auto=format\&n=ZGatOp3ICUy8H4tB\&q=85\&s=c4da44425eb1ebb36efe30476405ea2b) The pack includes modern and stone arrows, modern and stone spears, and the flare projectile. The spawned prefab uses `SurvivalProjectile` with a `Rigidbody` and `Collider`. | Setting | Effect | | - | - | | **Speed** | Initial velocity in Unity units per second. | | **Gravity Scale** | Multiplier applied to `Physics.gravity` during flight. | | **Life Span** | Destroys the projectile after this many seconds when positive. | | **Stick On Impact** | Stops physics on impact and parents the projectile to the hit transform. | | **Rotate With Velocity** | Rotates the projectile to follow its flight direction. | ![Survival Projectile settings for speed, gravity, life span, impact sticking, and velocity alignment](https://mintcdn.com/kinemation/ZGatOp3ICUy8H4tB/survival-pack/unity/images/survival-pack_projectile-component.png?fit=max\&auto=format\&n=ZGatOp3ICUy8H4tB\&q=85\&s=2d001bb65293aa4f4bdcffa41c546184) Tune flight on the spawned projectile prefab, separately from the held item mesh. Launch ignores collisions with the owning character. The projectile example handles flight and sticking; add damage and other impact gameplay in your own implementation. ## Adapt a weapon Duplicate the closest prefab into your own project folder. Keep its example component, view, procedural asset, and required overlay parameters connected before replacing the model and action clips. Preserve paired actions and animation events, then test draw, idle, aim, use, reload or redraw, and holster. For the bow and spear, also test projectile selection and the exact release frame. [Item View](https://docs.kinemation.xyz/survival-pack/unity/general/item-views.md) explains the shared animation calls. This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.