Game.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "IScreen.hpp"
#include "animation/AnimationLibrary.hpp"
#include "animation/AnimationTesterUI.hpp"
#include "animation/CharacterRig.hpp"
#include "animation/SkinningBackend.hpp"
#include "app/AppContext.hpp"
#include "debug/ClientPerfRecorder.hpp"
#include "debug/DebugUI.hpp"
#include "debug/FrameRecorder.hpp"
#include "ecs/AssetCatalog.hpp"
#include "ecs/AssetRegistry.hpp"
#include "ecs/components/Hitbox.hpp"
#include "ecs/components/InputSnapshot.hpp"
#include "ecs/components/PlayerSimState.hpp"
#include "ecs/components/PlayerVisState.hpp"
#include "ecs/components/Position.hpp"
#include "ecs/components/PreviousPosition.hpp"
#include "ecs/components/Velocity.hpp"
#include "ecs/components/ViewmodelConfig.hpp"
#include "ecs/physics/MapLoader.hpp"
#include "ecs/registry/Registry.hpp"
#include "hud/Hud.hpp"
#include "menus/pause/PauseMenu.hpp"
#include "menus/postmatch/PostMatchResult.hpp"
#include "network/Client.hpp"
#include "network/MatchStatus.hpp"
#include "network/RegistrySerialization.hpp"
#include "particles/ParticleSystem.hpp"
#include "renderer-new/NewRenderer.hpp"
#include "sfx/SfxSystem.hpp"
#include "systems/GamepadAimAssistSystem.hpp"
#include "systems/InputRingBuffer.hpp"
#include "systems/KillFeedEvent.hpp"
#include "util/WorkerPool.hpp"
#include "voice/VoiceChatSystem.hpp"
 
#include <SDL3/SDL.h>
 
#include <array>
#include <cstdint>
#include <deque>
#include <entt/entt.hpp>
#include <filesystem>
#include <glm/glm.hpp>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
#include <vector>

class Game : public IScreen
{
public:
    bool initDebugUI(const AppContext& ctx);

    bool init(AppContext& ctx);

    SDL_AppResult event(SDL_Event* event) override;

    SDL_AppResult iterate() override;

    bool shouldReturnToLobby() const;

    std::optional<PostMatchResult> consumePostMatchResult();

    bool consumeReturnToMainMenu();

    bool consumeServerShutdownNotice();

    void quit() override;

    void shutdownAfterRenderer() override;

    void refreshRemotePlayerRenderables();

    void refreshRemoteProjectileRenderables();

    void refreshRemoteRespawnRenderables();

    void refreshRemotePowerupRenderables();

    void refreshRemoteHealthPackRenderables();

    void refreshDroppedWeaponRenderables();
 
private:
    bool applyIncomingSnapshot(
        std::uint32_t snapshotTick, const std::uint8_t* bytes, Uint32 size, Uint64 captureNs, std::uint32_t& ackedTick);
    void handleLocalPlayerReady(entt::entity local);
 
    struct PredictedPlayerState
    {
        std::uint32_t tick = 0;
        Position position{};
        PreviousPosition previousPosition{};
        Velocity velocity{};
        PlayerVisState vis{};
        PlayerSimState sim{};
        InputSnapshot input{};
        bool valid = false;
    };
 
    struct ReconciliationDecision
    {
        bool skip = false;
        bool missingHistory = false;
        float positionError = 0.0f;
        float velocityError = 0.0f;
    };
 
    void clearPredictedStateHistory() noexcept;
    void storePredictedPlayerState(std::uint32_t tick);
    [[nodiscard]] std::optional<PredictedPlayerState> captureLocalPredictedState() const;
    [[nodiscard]] const PredictedPlayerState* predictedStateForTick(std::uint32_t tick) const noexcept;
    void restoreLocalPredictedState(const PredictedPlayerState& state);
    [[nodiscard]] ReconciliationDecision
    evaluateReconciliationSkip(const PredictedPlayerState& authoritative,
                               const PredictedPlayerState* predictedAtAck,
                               const std::optional<PredictedPlayerState>& currentBeforeSnapshot) const noexcept;

    void updateCachedPostMatchResult();

    void openChat();

    void closeChat();

    void submitChat();

    void appendChatMessage(ClientId sender, std::string_view message);

    void appendLocalChatMessage(std::string_view message);

    void appendPopupMessage(HudPopupKind kind, std::string_view message);

    void clearGameplayInputForChat();
 
    static constexpr int k_physicsHz = 128;                                      
    static constexpr float k_physicsDt = 1.0f / static_cast<float>(k_physicsHz); 
    static constexpr int k_maxTicksPerFrame = 2;
    static constexpr int k_fpsHistorySize = 512;                   
 
    SDL_Window* window = nullptr;                                  
    DebugUI debugUI;                                               
    NewRenderer* renderer = nullptr;                               
    Registry registry;                                             
    Client* client = nullptr;                                      
    SfxSystem* sfxSystem = nullptr;                                
    UserSettings* userSettings = nullptr;                          
    std::string_view userSettingsPath_;                            
    std::optional<registry_serialization::Loader> snapshotLoader_; 
    std::optional<entt::entity>
        mappedLocalPlayerEntity_;  
    ParticleSystem particleSystem; 
    VoiceChatSystem voiceChat_;    
    Hud hud_;                      
    entt::dispatcher dispatcher;   
 
    Uint64 prevTime = 0;           
    float accumulator = 0.0f;      
    int tickCount = 0;             
    uint32_t clientPredictTick = 0;

    bool prevShootingForDebug_ = false;

    InputRingBuffer inputRing_;
 
    std::array<PredictedPlayerState, InputRingBuffer::k_capacity> predictedStateHistory_{};
    bool mouseCaptured = true; 

    SDL_Gamepad* activeGamepad_ = nullptr;
    SDL_JoystickID activeGamepadId_ = 0;
    BindingDevice lastInputDevice_{};
    float gamepadLookSensitivity = 6.0f;

    systems::GamepadAimAssistConfig aimAssistCfg_;

    systems::GamepadAimAssistState aimAssistState_;

    std::unique_ptr<WorkerPool> workerPool_;

    bool localWasDead_ = false;
 
    // Runtime-tunable loop settings (exposed via ImGui)
    float mouseSensitivity = user_settings::kDefaultMouseSensitivity; 
    float horizontalFovDegrees = 90.0f;    
    bool renderSeparateFromPhysics = true; 
    bool inputSyncedWithPhysics = true;    
    bool limitFPSToMonitor = true;         
 
    Uint64 softLimitPeriod = 0;            
    Uint64 softLimitNextFrame = 0;         

    void applyFrameRateLimit();
 
    FrameRecorder recorder;  
    uint64_t frameCount = 0; 
 
    // Cached camera state — updated each iterate(), used by event() key shortcuts.
    glm::vec3 cachedEye_{0.f, 100.f, 0.f};
    glm::vec3 cachedCamFwd_{0.f, 0.f, 1.f};
    bool cachedGravFlipped_{false}; 
    float currentCameraRoll_{0.0f}; 
 
    // Emote state (client-side prediction for the local player). Set when the
    // emote wheel fires, cleared on local movement/combat input or death. Drives
    // the local animator override, the third-person emote camera, and showing
    // the local body. Remote players' emotes are server-driven via AnimSnapshot.
    int localEmote_{-1};        
    float emoteCamBlend_{0.0f}; 
 
    // Killcam: while dead and awaiting respawn, hold the camera at the death
    // position and rotate it to keep the killer centered on screen.
    bool killcamActive_{false};                    
    glm::vec3 killcamEye_{0.0f};                   
    float killcamYaw_{0.0f};                       
    float killcamPitch_{0.0f};                     
    glm::vec3 killcamKillerCenter_{0.0f};          
    glm::vec3 killcamKillerHalf_{0.0f};            
    entt::entity killcamKillerEntity_{entt::null}; 
    std::string killcamKillerName_;                
 
    // Map collision data — loaded from GLB, owns the vectors that back activeWorld().
    physics::MapCollisionData mapCollision_;
 
    // Central asset registry — maps human-readable names to renderer model indices.
    AssetRegistry assets_;
 
    // Legacy model index aliases (for code that still uses raw indices).
    // TODO: migrate all call sites to assets_.modelIndex("name") and remove these.
    int weaponModelIndices_[kRenderableWeaponTypeCount] = {-1, -1, -1, -1, -1};
    int weaponAssetIds_[kRenderableWeaponTypeCount] = {-1, -1, -1, -1, -1};
    int viewmodelLeftHandModelIdx_ = -1;
    int viewmodelRightHandModelIdx_ = -1;
    int handMountDebugMarkerModelIdx_ = -1;
 
    int rocketProjectileModelIdx_ = -1;
    int grenadeModelIdx_ = -1;
    int heGrenadeModelIdx_ = -1;
    int stickyGrenadeModelIdx_ = -1;
    int molotovModelIdx_ = -1;
    int medkitModelIdx_ = -1;
    int shieldPowerupModelIdx_ = -1;
    int damagePowerupModelIdx_ = -1;
 
    // Dynamic lighting test controls (ImGui-tunable)
    bool showDynLightUI_ = false;                        
    bool showHdrDebugUI_ = false;                        
    bool showHudDebug_ = false;                          
    bool showMenuThemeUI_ = false;                       
    bool flashlightEnabled_ = false;                     
    float flashlightIntensity_ = 8.0f;                   
    float flashlightRange_ = 800.0f;                     
    float flashlightOffset_ = 30.0f;                     
    bool movableSphereEnabled_ = false;                  
    float sphereFollowDist_ = 150.0f;                    
    float sphereIntensity_ = 5.0f;                       
    float sphereRange_ = 500.0f;                         
    bool beamEnabled_ = false;                           
    glm::vec3 beamStartOff_{30.0f, -5.0f, 10.0f};        
    glm::vec3 beamEndOff_{200.0f, -5.0f, 10.0f};         
    float beamRadius_ = 3.0f;                            
    glm::vec3 beamColor_{0.6f, 0.1f, 1.0f};              
    float beamLightIntensity_ = 4.0f;                    
    float beamLightRange_ = 300.0f;                      
    float beamLightSpacing_ = 60.0f;                     
    WeaponType currentEquippedType_ = WeaponType::Rifle; 
    WeaponType lastEquippedType_ = WeaponType::Rifle; 
    bool viewmodelDefaultsApplied_ = false;
 
    // Sound state tracking
    bool wasChargingRailgun_ = false; 
    struct BeamAudioState
    {
        bool active = false;
        float loopDelaySeconds = 0.0f;
        SfxSystem::SourceHandle loopHandle = SfxSystem::kInvalidSource;
    };
    std::unordered_map<entt::entity, BeamAudioState> beamAudioStates_;
    std::unordered_map<entt::entity, std::array<float, 5>> footstepPhases_;
    std::unordered_map<entt::entity, float> footstepCooldowns_;
 
    // Movement / ability transition tracking for SFX.
    struct PlayerSfxState
    {
        bool initialized = false;
        bool grounded = false;
        bool isDead = false;
        int moveMode = 0;
        bool gravityFlipped = false;
        bool grappleActive = false;
        float primaryCooldown = 0.0f;
        float secondaryCooldown = 0.0f;
        SfxSystem::SourceHandle slideLoopHandle = SfxSystem::kInvalidSource;
    };
    std::unordered_map<entt::entity, PlayerSfxState> playerSfxState_;
 
    // Hitmarker
    float hitmarkerTimer_ = 0.0f;       
    bool hitmarkerIsHeadshot_ = false;  
    bool hitmarkerShieldBreak_ = false; 
 
    // Floating damage numbers — queued from replicated particle events, consumed by HUD each frame.
    struct PendingDamageNumber
    {
        glm::vec3 pos;
        float damage;
        bool headshot;
        bool shielded;
    };
    std::vector<PendingDamageNumber> pendingDamageNumbers_;
 
    // Damage accumulator — tracks continuous damage to a single target.
    entt::entity accumTarget_ = entt::null; 
    int accumTotal_ = 0;                    
    float accumResetTimer_ = 0.f;           
    uint8_t accumLastHitType_ = 0;          
 
    // Shotgun pellet accumulator — groups the 9 NetParticleEvents emitted per
    // shotgun shot (by the server's WeaponSystem) into a single completed blast
    // for the HUD ShotgunPelletWidget. The widget is fed via
    // `HudGameState.latestShotgunBlast`, which is just a copy of
    // `lastShotgunBlast_` updated each frame with elapsed time.
    HudShotgunBlast shotgunPelletAccum_{}; 
    int shotgunPelletAccumCount_ = 0;      
    float shotgunPelletLastTimeSec_ = 0.f; 
    HudShotgunBlast lastShotgunBlast_{};   
 
    // Vignette state: track previous frame health/armor for delta detection.
    float prevHealth_ = 100.f;
    float prevArmor_ = 100.f;
 
    // ── Voidfall HUD bookkeeping ────────────────────────────────────────
    float matchElapsedSeconds_ = 0.f;

    int prevPrimaryWeaponType_ = -1;
    int prevSecondaryWeaponType_ = -1;

    std::vector<HudPickupNotification> pendingPickupNotifications_;

    float damagePowerupHudTimer_ = 0.0f;
    float damagePowerupHudDuration_ = 1.0f;

    std::vector<HudPopupMessage> pendingPopupMessages_;
    std::vector<HudChatMessage> chatMessages_;
    std::vector<HudVoiceSpeaker> voiceSpeakers_;
    std::string chatDraft_;
    std::deque<std::string> pendingLocalChatEchoes_;
    bool chatOpen_ = false;
 
    // (No additional bookkeeping needed — name strings are constructed
    // each frame into the thread_local vector inside Game.cpp.)
 
    // Viewmodel tuning (live-adjustable via ImGui)
    float vmScale = 1.0f;         
    float vmForward = 0.0f;       
    float vmRight = 0.0f;         
    float vmDown = 0.0f;          
    float vmYawOffset = 0.0f;     
    float vmPitchOffset = 0.0f;   
    float vmRollOffset = 0.0f;    
    bool showViewmodelUI = false; 
 
    // Weapon sway state (CoD-style barrel lead)
    float prevSwayYaw_ = 0.0f;
    float prevSwayPitch_ = 0.0f;
    float swayOffsetX_ = 0.0f;     
    float swayOffsetY_ = 0.0f;     
    bool swayInitialized_ = false; 
 
    // Sway tuning (ImGui-adjustable)
    float swayAmplitudeYaw_ = 3.0f;
    float swayAmplitudePitch_ = 2.0f;
    float swayDecayRate_ = 8.0f;  
    float swaySmoothing_ = 0.15f; 
 
    // Visual recoil state (viewmodel-only, does not affect aim)
    float recoilPitch_ = 0.0f;    
    float recoilPushBack_ = 0.0f; 
    float recoilRoll_ = 0.0f;     
 
    // Apex-style spring-damped camera recoil (actually deflects aim — bullets drift).
    // Each frame the spring integrates toward `target`, then the per-frame delta is
    // committed to `InputSnapshot.pitch`/`yaw` on the local player so raycasts,
    // tracers, bullet-holes, and the replicated aim all follow the recoil. Target
    // accumulates per shot during sustained fire and only decays back toward 0
    // after `recoilIdleTime_` exceeds the idle threshold — that's what produces
    // the auto-recovery feel without fighting active firing.
    bool useSpringCameraRecoil_ = true;         
    float cameraRecoilPitch_ = 0.0f;            
    float cameraRecoilYaw_ = 0.0f;
    float cameraRecoilPitchVel_ = 0.0f;         
    float cameraRecoilYawVel_ = 0.0f;
    float cameraRecoilTargetPitch_ = 0.0f;      
    float cameraRecoilTargetYaw_ = 0.0f;
    float committedRecoilPitch_ = 0.0f;         
    float committedRecoilYaw_ = 0.0f;           
    float recoilPatternScaleMultiplier_ = 2.0f; 
    float cameraRecoilOmega_ = 35.0f;           
    float cameraRecoilTargetDecay_ = 5.0f;      
    float cameraRecoilIdleThreshold_ = 0.18f;   
 
    // Recovery model — switch live between:
    //   A) No recovery (CS-style). Aim stays where the recoil walked it; the
    //      player owns 100% of the pull-down.
    //   B) Compensated recovery (Apex-like). Auto-recovers after fire-off, BUT
    //      while firing we measure the player's counter-mouse and subtract it
    //      from the recovery debt — so the engine refunds only the un-paid
    //      portion. Avoids the "double-compensation" crosshair-drop bug.
    bool useRecoilCompensation_ = false;    
    float lastSnapPitchAfterCommit_ = 0.0f; 
    float lastSnapYawAfterCommit_ = 0.0f;   
    bool haveLastSnap_ = false;             
 
    // Credit accumulator (Approach B). Each frame, the player's counter-mouse is
    // banked into a signed credit (capped + slowly-decaying). The credit is then
    // consumed against target — pre-payment of future kicks is preserved, and
    // continued pull after fire-off still cancels recovery debt. Without this
    // (cap-at-current-target naive comp), excess mouse input was wasted and the
    // recovery refund overcompensated whatever debt remained.
    float compensationCreditPitch_ = 0.0f;
    float compensationCreditYaw_ = 0.0f;
    float compensationCreditCap_ = 0.10f;  
    float compensationCreditDecay_ = 1.0f; 
 
    // Visual reload state
    float reloadDownwardOffset_ = 0.0f;       
    float grenadeThrowDownwardOffset_ = 0.0f; 
 
    // Local weapon fire cooldown (mirrors server's per-weapon cooldown for VFX)
    float localFireCooldown_ = 0.0f; 
    float localRecoilHeat_ = 0.0f;
    float recoilIdleTime_ = 0.0f;
 
    int pendingScrollSwitch_ = 0; 
 
    // Third-person weapon tuning (per weapon type, live-adjustable via ImGui)
    ThirdPersonWeaponParams tpWeaponParams_[kRenderableWeaponTypeCount]; 
    int tpTuneWeaponIdx_ = 0;         
    bool tpFreezeAnimations_ = false; 
 
    // Third-person FK weapon hold poses (spine-relative gun + per-bone arm angles).
    std::array<WeaponHoldPose, kRenderableWeaponTypeCount> weaponHoldPoses_{};         
    std::array<WeaponHoldPose, kRenderableWeaponTypeCount> authoredWeaponHoldPoses_{}; 
    std::array<std::string, kRenderableWeaponTypeCount> weaponHoldPosePaths_{};        
    std::array<std::filesystem::file_time_type, kRenderableWeaponTypeCount> weaponHoldPoseMTimes_{};
    float holdPoseReloadAccumulator_ = 0.0f; 
    float holdRotStepDeg_ = 5.0f;            
    bool holdShowDebugMarker_ = true;        
    bool showWeaponHoldUI_ = false;          
 
    // First-person arm mount tuning (separate from third-person grips).
    FirstPersonHandMountParams
        fpHandMountParams_[kRenderableWeaponTypeCount];         
    FirstPersonHandMountParams
        authoredFPHandMountParams_[kRenderableWeaponTypeCount]; 
    int fpHandMountTuneWeaponIdx_ = 0;                          
    bool showFPHandMountUI_ = false;                            
 
    enum class HandMountDebugSpace : std::uint8_t
    {
        None,
        ThirdPerson,
        FirstPerson,
    };
 
    enum class HandMountDebugPoint : std::uint8_t
    {
        Shoulder,
        Elbow,
        Palm,
        Finger0,
        Finger1,
        Finger2,
        Finger3,
        Finger4,
    };
 
    struct HandMountDebugTarget
    {
        HandMountDebugSpace space = HandMountDebugSpace::None;
        int weaponIdx = 0;
        bool left = false;
        HandMountDebugPoint point = HandMountDebugPoint::Palm;
    };
 
    HandMountDebugTarget handMountDebugTarget_{};
 
    // Weapon spawner model tuning (per weapon type, live-adjustable via ImGui)
    WeaponSpawnerModelParams
        spawnerWeaponParams_[kRenderableWeaponTypeCount]; 
    int spawnerTuneWeaponIdx_ = 0;                        
    bool showWeaponSpawnerModelUI_ = false;               
 
    // Animation subsystem — shared rig + clip library + skinning backend.
    // CharacterAnimators (one per animated entity) hold non-owning refs.
    CharacterRig charRig_;       
    int rightHandJointIdx_ = -1; 
    int spine2JointIdx_ = -1;    
    struct GripSwapState
    {
        WeaponType lastType = WeaponType::Rifle;
        float swapElapsedSec = 1.0f; 
    };
    std::unordered_map<entt::entity, GripSwapState> gripSwapState_{};
    float aimAssistParityAccumSec_ = 0.0f; 
    AnimationLibrary animLibrary_;         
    CpuLbsSkinningBackend skinBackend_;    
    AnimationTesterState animUI_;          
    HitboxRig clientHitboxRig_;            
    float kRigScale_ = 1.0f;               
    float kRigVerticalOffset_ =
        -90.0f;                
    float rigMeshMinY_ = 0.0f; 

    std::unordered_set<entt::entity> dissolveSpawned_;
 
    // FPS ring buffer -- inter-render deltas, newest at (head-1) % size
    float fpsHistory[k_fpsHistorySize] = {}; 
    int fpsHistoryHead = 0;                  
    int fpsHistoryCount = 0;                 
    Uint64 prevRenderTime = 0;               
 
    // Network ping timer
    float pingTimer = 0.0f; 
 
    // Performance stats -- refreshed every 0.5 s
    Uint64 statsPrevTime = 0;       
    int statsPhysTicks = 0;         
    int statsRenderFrames = 0;      
    float measuredPhysicsHz = 0.0f; 
    float statsFPSCurrent = 0.0f;   
    float statsFPSMin = 0.0f;       
    float statsFPSMax = 0.0f;       
    float statsFPS1pLow = 0.0f;     
    float statsFPS5pLow = 0.0f;     
 
    // Benchmark mode: when BENCH_SECONDS env var is set to a positive number,
    // the client runs for that many seconds, prints a one-line FPS summary to
    // stderr, then quits.  Powers `scripts/perf-100bots.sh`.
    float benchSeconds_ = 0.0f;                         
    Uint64 benchStartTime_ = 0;                         
    bool benchActive_ = false;                          
    static constexpr float k_benchWarmupSeconds = 2.0f; 
    std::vector<float> benchFrameTimesMs_;              

    std::vector<ClientPerfFrame> benchFrameStats_;
    ClientPerfRecorder perfRecorder_;
    float perfSnapshotApplyMs_ = 0.0f;
    std::uint32_t perfSnapshotApplyCount_ = 0;

    void attachAnimatedCharacter(entt::entity e);

    void onWeaponFired(const struct WeaponFiredEvent& evt);

    void adoptGamepad(SDL_JoystickID id);

    void scanForConnectedGamepads();
 
    // Match State
    MatchPhase currentMatchPhase = MatchPhase::LOBBY; 
    ClientId currentWinnerId = ClientId{-1};          
    float countdownTimer = 0.0f; 
    std::optional<PostMatchResult> cachedPostMatchResult_; 
    bool returnToLobbyRequested = false;         
    bool returnToMainMenuRequested_ = false;     
    bool serverShutdownNoticeRequested_ = false; 
 
    // Kill Feed State
    std::vector<KillFeedEvent> killFeed; 
 
    PauseMenu pauseMenu; 
 
    // Bullet tracer muzzle
    glm::vec3 cachedMuzzleWorld_{0.0f};
    bool cachedMuzzleValid_ = false;
 
    // Local player's right-palm world position, cached from the viewmodel pass
    // each frame. Used as a muzzle-flash fallback when the weapon has no muzzle marker.
    glm::vec3 cachedRightPalmWorld_{0.0f};
    bool cachedRightPalmValid_ = false;

    [[nodiscard]] glm::vec3 muzzleFlashOrigin(const glm::vec3& fallback) const;

    [[nodiscard]] glm::vec3 scopedRailgunBeamOrigin() const;

    [[nodiscard]] glm::vec3 muzzleFlashLightPosition(const glm::vec3& muzzleOrigin) const;
 
    glm::vec3 muzzleFlashLightOffset_{-12.25f, 0.0f, -10.0f}; 
 
    // Transient VFX point lights. Muzzle flashes and explosions both feed this
    // short-lived list, then iterate() fades the survivors into the renderer's
    // dynamic point-light array.
    struct TransientVfxLight
    {
        glm::vec3 position{0.0f}; 
        glm::vec3 color{1.0f};    
        float intensity = 0.0f;   
        float age = 0.0f;         
        float lifetime = 0.06f;   
        float range = 500.0f;     
    };
    std::vector<TransientVfxLight> transientVfxLights_;

    void spawnMuzzleFlashLight(const glm::vec3& pos, WeaponType weaponType);

    void spawnExplosionFlashLight(const glm::vec3& pos, WeaponType weaponType, float radius);
};