DPT Games Functional Siege Weapons

Quick Setup Checklist

1. Add DPT_SiegeWeapon to the root GameObject of your weapon prefab. An AudioSource is added automatically if one is not already present.
2. Under Core Object Setup, assign your intact mesh GameObjects to Pristine Meshes. These are hidden when the weapon is destroyed.
3. Under Animated Parts & Launch Setup, assign the Transforms that your Animator will drive: **Firing Arm**, **Traverse Pivot**, **Elevation Pivot**, and **Launch Point**. Assign the sling or ammo visual to **Ammo Visual** — it is shown while loaded and hidden when the weapon fires.
4. For cannon-style weapons with a lit fuse, assign **Fuse Point** to the empty Transform at the touch-hole. Parent your spark mesh and fuse ParticleSystem under this Transform in the prefab, then assign the ParticleSystem to **Fuse Effect**. The fuse activates automatically when the weapon enters the Loaded state and stops the moment it fires.
5. Optionally assign a **Projectile Prefab** under **Combat & Firing**. Leave it empty for animation-only mode.
6. Set **Fire Duration** to match your fire animation clip length and **Reload Duration** to match your reload clip length.
7. Expand the **Expanded Unity Events** foldout and wire onFireEvent and onReloadStartEvent to the corresponding Animator.SetTrigger calls.
8. (Optional) Assign a **Broken Parent** to enable the full fracture destruction system — see the Fracture & Destruction section below.
9. (Optional) For mobile wheeled weapons or models with moving mechanical elements, add the DPT_ProceduralMechanicalDrive companion script. (Refer to the separate *Procedural Mechanical Drive Guide* to configure its dedicated wheel audio loop settings).
10. Press **Reset Weapon** in the Inspector toolbar to confirm all references are clean before entering Play Mode.

The Weapon State Machine

The weapon is always in exactly one of the following states. Transitions happen automatically as part of the firing loop, or can be triggered externally via the scripting API.

Inspector Reference

Core Object Setup

Animated Parts & Launch Setup

Combat & Firing

Movement & Aiming

Health & Impact Damage

Fracture & Destruction

The destruction system is a direct port of the DPT_InteractiveProp fracture pipeline. When a Broken Parent is assigned, the weapon gains full debris explosion physics, directional impact forces, kinetic transfer to nearby objects, and the automatic sink-and-cleanup routine.

Hierarchy Setup

The Broken Parent should have a single root GameObject containing all debris Rigidbodies as direct or nested children. This root is deactivated by default and activated only when the weapon breaks. The script caches all Rigidbody positions and rotations at startup so ResetWeapon() can restore them cleanly.

For modular weapons with shared components such as axles, levers, or winding mechanisms that exist as separate prefabs, use Attached Debris Pieces to link their broken base transforms without needing to unpack or reparent them in the hierarchy. These pieces are reparented at runtime to the first Broken Base Piece on destruction and restored to their original parents on reset.

Fracture Physics Properties

Debris Cleanup

Kinetic Transfer

On destruction, the weapon can radially push nearby lightweight Rigidbodies, simulating the shockwave of a large structure collapsing. Only objects with a mass at or below Max Pushable Mass are affected, preventing artillery from launching siege towers.

Audio, VFX & Effects

To prevent audio cutoff and allow natural reverb tails, operational asset audio cues are routed through dedicated AudioSource components. Each event slot accepts multiple clips — one is selected at random each time that event fires.

Dedicated Audio Sources

Audio Clips

Audio Settings

VFX

Unity Events & Animator Integration

Every stage of the weapon loop exposes a UnityEvent in the Inspector. The primary use case is wiring these directly to Animator.SetTrigger() calls — no intermediate scripts required.

Recommended Animator Wiring

Scripting API

The following public methods are safe to call from any external script, NavMeshAgent, or AI controller.

Weapon Control

Damage & Destruction

Read-Only State Properties

Example: AI Fire Controller

// Fire at the player when within range and weapon is ready
void Update()
{
    if (!weapon.CanFire) return;

    float dist = Vector3.Distance(transform.position, player.position);
    if (dist < attackRange)
    {
        weapon.AimAt(player.position);
        weapon.Fire();
    }
}
    

Example: Adjusting Launch Power from a Custom Controller

// Call AdjustLaunchSpeed rather than setting launchSpeed directly.
// The weapon enforces its own min/max clamp internally.
void Update()
{
    float mouseY = Input.GetAxis("Mouse Y");
    weapon.AdjustLaunchSpeed(mouseY * powerAdjustmentSpeed * Time.deltaTime);
}
    

Scene View Gizmos

Select any GameObject carrying a DPT_SiegeWeapon component to see the following gizmos:

Editor Testing Tools

The DPT_SiegeWeaponEditor toolbar appears at the top of the Inspector whenever a Siege Weapon is selected. All buttons work in both Edit Mode and Play Mode.

DPT_SiegeWeaponController — Demo Player Controller

DPT_SiegeWeaponController is a ready-to-use first-person controller that lets a player walk up to any siege weapon, press E to take control of it, aim and fire, then press E again to disengage. It is included as a functional starting point and demonstration of the DPT_SiegeWeapon API — you are expected to replace or extend it for your own project.

Inspector Fields

The controller natively utilizes the modern Unity Input System via InputActionReference variables, completely decoupling the package from hardcoded keys. You must map your action asset into the corresponding inspector slots and ensure a PlayerInput component is active in your scene to drive the inputs.

Camera Interface Integration (IControllableCamera)

To cleanly decouple the siege weapon framework from your specific character controller, the possession system relies on the IControllableCamera interface. Simply add this interface to your custom player camera script (e.g., public class MyCharacter : MonoBehaviour, IControllableCamera) and implement the SetEnabled(bool state) method to freeze your character's movement. The siege weapon will automatically find it and manage the transition without slow reflection queries.

Camera & Screen Shake Modules

To add visceral impact to your siege weapons, the package includes modular screen shake components. These are completely decoupled from the main weapon controller, relying on the public UnityEvents to trigger.

Weapon Fire Screen Shake

The DPT_WeaponFireScreenShake component listens to the weapon's onProjectileLaunchEvent to trigger an environmental camera shake whenever the weapon fires.

Camera Shake Receiver

For the shake to actually move the player's view, attach the DPT_CameraShakeReceiver component directly to your Player Camera. This singleton-style listener automatically subscribes to both weapon firing events (DPT_WeaponFireScreenShake) and projectile impact events (DPT_ProjectileScreenShake), calculates distance attenuation, and applies the local position offset.

Breakable Props (DPT_BreakableProp)

The DPT_BreakableProp component is a streamlined script designed specifically for static destructible objects like mantlets, barricades, and ammo crates. It utilizes the same fracture physics, manual audio assignment, and automatic cleanup routines as the main Siege Weapon controller, but strips out all aiming and firing state machines for maximum performance on simple props.

Quick Setup

1. Attach the DPT_BreakableProp script to the root of your prop prefab. Make sure the root object has a Collider.
2. Assign your intact meshes to Pristine Meshes and your broken debris root to Broken Parents.
3. Under Audio & VFX, manually assign an AudioSource (configured for 3D spatial blending) and populate the Break Sounds array.
4. Adjust Max Health, Explosion Force, and Time Before Cleanup to suit the material of the prop.

Inspector Reference

Visuals, Health & Damage

Offensive Capabilities

Destruction Physics & Broken Base

Audio, VFX & Events

Scripting API

Interfacing with the Breakable Prop from your custom projectile or player scripts is straightforward:

Compatibility & Integration

Shared Infrastructure with Interactive Props

The destruction pipeline in DPT_SiegeWeapon is a direct port of the one used in DPT_InteractiveProp. Both systems use identical fracture force application, kinetic transfer, debris cleanup, and audio accordion logic. A weapon placed alongside interactive props in the same scene will behave consistently — debris forces, cleanup timing, and audio ducting all follow the same rules.

Input System Compatibility

DPT_SiegeWeaponController compiles correctly against the legacy UnityEngine.Input API and the new UnityEngine.InputSystem package. The correct path is selected automatically at compile time via #if ENABLE_INPUT_SYSTEM. In production, disable enableDirectInput and drive the weapon API from your own controller.

Object Pooling (Safe Debris Recall)

ResetWeapon() is strictly pool-safe. It restores all mesh visibility, Rigidbody poses, collider states, health, angle offsets, fuse state, satellite arrays, and the state machine. Crucially, the base class automatically caches the original local hierarchy data of every shattered piece. When reset, the weapon instantly vacuums up its unparented debris fragments, snaps them back to their original zero coordinates, and freezes their physics. Set Destroy On Cleanup to false to deactivate rather than destroy the GameObject at the end of its cleanup routine.

Support & Custom Pipeline Integration

If your project requires external or custom 3D models to be fully integrated into the DPT ecosystem—including custom vertex-data packing, procedural wood grain mapping, normal array configuration, advanced GPU wind system implementation, or any other bespoke features—freelance technical art services are available. Additionally, availability extends to general 3D asset production, high-to-low poly hard surface modeling, stylized prop creation, and game-ready LOD budgeting built to align cleanly with your specific project constraints.