Script:Files:script/deployables/artillery.script

object deployable_artillery : deployable_base {
    void    preinit();
    void    init();
    void    destroy();
    void    syncFields();

    void    vDoneDeploy();

    void    TurningThread();

    void    ServerIdle();
    void    ServerAiming();
    void    ServerFiring();

    void    ClientIdle();
    void    ClientFiring();

    void    StopRotationSounds();

    void    vTargetSetTarget( vector targetPos, entity targetEnt );
    boolean    vTargetGetValid( vector targetPos );
    boolean    vTargetPlayerEligible( entity p );

    float    vGetFireSupportMode();

    //
    boolean    InRange( vector targetPos );
    boolean    InFiringRange( vector targetPos ) { return InRange( targetPos ); }
    void    UpdateTurning();
    boolean    UpdateYaw();
    boolean UpdatePitch();
    void    ResetAngles();
    void    TurnToward( float yaw, float pitch );
    boolean PitchValid( float pitch );
    boolean    CalcTargetAngles( vector targetPos );
    string    MuzzleForMissile( float missileIndex );

    // utility funcs ( none of these should be blocking )
    void    Launch( float missileIndex );
    void    FireMissile( float missileIndex );
    void    LaunchForEffect();

    float    GetMissileBarrelLength( float index );
    void    SetMissileBarrelLength( float index, float value );
    float    GetMissileSideOffset( float index );
    void    SetMissileSideOffset( float index, float value );

    void    OnFireSupportStateChanged();

    target_marker vCreateTargetMarker();

    void    ClearFiringDecal();    
    void    CreateFiringDecal();

    void    ReloadThread( float delay );

    float    recycle;
    float    fireCount;
    float    reloadWait;
    float    numMissiles;
    float    fireSyncDelay;
    float    nextFire;

    float    jointYaw;
    float    idealYaw;
    float    currentYaw;
    float    oldIdealYaw;
    float    minYawRate;
    float    maxYawRate;

    float    jointPitch;
    float    idealPitch;
    float    currentPitch;
    float    oldIdealPitch;
    float    minPitchRate;
    float    maxPitchRate;

    float    jointBarrel;

    float    minPitch;
    float    maxPitch;

    float    minRange;
    float    maxRange;

    float    missileSpeed;

    float    spread;

    float    clientState;

    float    targetYaw;
    float    targetPitch;
    vector    targetDiff;

    float    baseYaw;
    float    barrelPitch;
    vector    firingOffset;
    vector    firingVelocity;
    boolean    hasTarget;
    entity    targetPlayerEnemy;
    vector    targetLocation;
    float    projectileIndex;
    float    projectileForEffectIndex;    

    generic_target_marker        firingDecal;
    entity                        firingMarker;

    boolean anglesLocked;
}

float deployable_artillery::GetMissileBarrelLength( float index ) {
    return getFloatKey( "missile" + ( index + 1 ) + "_barrel_length" );
}

void deployable_artillery::SetMissileBarrelLength( float index, float value ) {
    setKey( "missile" + ( index + 1 ) + "_barrel_length", value );
}

float deployable_artillery::GetMissileSideOffset( float index ) {
    return getFloatKey( "missile" + ( index + 1 ) + "_side_offset" );
}

void deployable_artillery::SetMissileSideOffset( float index, float value ) {
    setKey( "missile" + ( index + 1 ) + "_side_offset", value );
}

void deployable_artillery::OnFireSupportStateChanged() {
    if ( fireSupportState == MPS_FIRING ) {
        if ( clientState != ART_CS_FIRING ) {
            setState( "ClientFiring" );
        }
    } else {
        if ( clientState != ART_CS_IDLE ) {
            setState( "ClientIdle" );
        }
    }
}

void deployable_artillery::syncFields() {
    syncBroadcast( "nextFire" );
    syncBroadcast( "targetLocation" );
    syncBroadcast( "fireSupportState" );
    syncBroadcast( "idealYaw" );
    syncBroadcast( "idealPitch" );
    syncBroadcast( "oldIdealYaw" );
    syncBroadcast( "oldIdealPitch" );

    syncCallback( "fireSupportState", "OnFireSupportStateChanged" );

    sync( "currentYaw" );
    sync( "currentPitch" );
}

void deployable_artillery::destroy() {
    ClearFiringDecal();
    delete fsStatus;
}

float deployable_artillery::vGetFireSupportMode() {
    return TARGET_ARTILLERY;
}

void deployable_artillery::preinit() {
    recycle            = getFloatKey( "missile_recycle" );
    fireCount        = getFloatKey( "missile_firecount" );
    reloadWait        = getFloatKey( "missile_reload" );
    numMissiles        = getFloatKey( "num_missiles" );
    fireSyncDelay    = getFloatKey( "sync_delay" );
    spread            = getFloatKey( "spread" );

    if ( fireCount <= 0 ) {
        fireCount = 6;
    }
    if ( reloadWait <= 0 ) {
        reloadWait = 30;
    }
    if ( fireSyncDelay <= 0 ) {
        fireSyncDelay = 0.5;
    }

    jointYaw        = getJointHandle( getKey( "joint_yaw" ) );
    jointPitch        = getJointHandle( getKey( "joint_pitch" ) );
    jointBarrel        = getJointHandle( getKey( "joint_barrel" ) );

    projectileIndex    = GetEntityDef( getKey( "def_projectile" ) );
    projectileForEffectIndex = GetEntityDef( getKey( "def_projectile_foreffect" ) );

    currentYaw        = 0;
    idealYaw        = 0;
    oldIdealYaw        = 0;
    maxYawRate        = getFloatKey( "max_yaw_turn" );
    minYawRate        = getFloatKey( "min_yaw_turn" );

    currentPitch    = 0;
    idealPitch        = 0;
    oldIdealPitch    = 0;
    maxPitchRate    = getFloatKey( "max_pitch_turn" );
    minPitchRate    = getFloatKey( "min_pitch_turn" );

    minPitch        = getFloatKey( "min_pitch" );
    maxPitch        = getFloatKey( "max_pitch" );

    minRange        = getFloatKey( "range_min" );
    maxRange        = getFloatKey( "range_max" );

    missileSpeed    = getFloatKey( "missile_speed" );

    hasTarget        = false;

    nextFire        = 0;

    fsStatus = new fireSupportStatus;

    thread TurningThread();
}

void deployable_artillery::vDoneDeploy() {
    vector barrel;
    float i;
    float muzzleHandle;
    vector pitchJointPos;
    float sideOffset;
    float barrelLength;

    pitchJointPos    = getLocalJointPos( jointPitch );
    barrel            = getLocalJointPos( jointBarrel ) - pitchJointPos;
    barrelPitch        = sys.atan2( barrel_z, barrel_x );

    for ( i = 0; i < numMissiles; i++ ) {
        muzzleHandle = getJointHandle( MuzzleForMissile( i ) );
        barrel = getLocalJointPos( muzzleHandle ) - pitchJointPos;
        sideOffset = barrel_y;
        barrel_y = 0;
        barrelLength = sys.vecLength( barrel );

        SetMissileSideOffset( i, sideOffset );
        SetMissileBarrelLength( i, barrelLength );
    }

    vector angles = getAngles();
    baseYaw = angles_y;

    SetDeployingFinished();
}

void deployable_artillery::init() {
    fadeSound( SND_DEPLOYABLE_YAW, -60.f, 0.f );
    fadeSound( SND_DEPLOYABLE_PITCH, -60.f, 0.f );
    startSound( "snd_turret_yaw", SND_DEPLOYABLE_YAW );
    startSound( "snd_turret_pitch", SND_DEPLOYABLE_PITCH );

    if ( sys.isClient() ) {
        setState( "ClientIdle" );
    } else {
        setState( "ServerIdle" );
    }
}

// ==========================================
// States
// ==========================================

void deployable_artillery::TurningThread() {
    while( true ) {
        sys.waitFrame();

        if ( disabledState ) {
            StopRotationSounds();
        } else {
            UpdateTurning();
        }
    }
}

void deployable_artillery::ClientIdle() {
    clientState = ART_CS_IDLE;

    ClearFiringDecal();
}

void deployable_artillery::ServerIdle() {
    hasTarget = false;
    ResetAngles();

    ClearFiringDecal();
}

void deployable_artillery::ReloadThread( float delay ) {
    fireSupportState = MPS_RELOADING;

    sys.wait( delay );

    fireSupportState = MPS_READY;
}

void deployable_artillery::StopRotationSounds() {
    DEPLOYABLE_STOP_YAW_SOUND
    DEPLOYABLE_STOP_PITCH_SOUND
}

void deployable_artillery::UpdateTurning() {
    boolean yawDone;
    boolean pitchDone;
    vector angles;

    yawDone = UpdateYaw();
    pitchDone = UpdatePitch();

    if ( !yawDone ) {
        angles_x = 0;
        angles_y = currentYaw;
        angles_z = 0;
        setJointAngle( jointYaw, JOINTMOD_LOCAL, angles );

        DEPLOYABLE_PLAY_YAW_SOUND
    } else {
        DEPLOYABLE_STOP_YAW_SOUND
    }

    if ( !pitchDone ) {
        angles_x = currentPitch;
        angles_y = 0;
        angles_z = 0;
        setJointAngle( jointPitch, JOINTMOD_LOCAL, angles );

        DEPLOYABLE_PLAY_PITCH_SOUND
    } else {
        DEPLOYABLE_STOP_PITCH_SOUND
    }

    if ( yawDone && pitchDone ) {
        anglesLocked = true;
    } else {
        anglesLocked = false;
    }
}

void deployable_artillery::ServerAiming() {
    fireSupportState = MPS_FIRING_PREPARE;

    while ( !anglesLocked ) {
        sys.waitFrame();

        if ( disabledState ) {
            fireSupportState = MPS_READY;

            setState( "ServerIdle" );
        }
    }

    setState( "ServerFiring" );
}

void deployable_artillery::ClientFiring() {
    float nextMiniFire    = 0;
    float nextMiniCount = 0;
    float baseFireTime    = 0;

    CreateFiringDecal();

    clientState = ART_CS_FIRING;

    if ( projectileForEffectIndex >= 0 ) {
        LaunchForEffect();        
        sys.wait( getFloatKey( "foreffect_wait" ) );
    }

    while( true ) {
        if ( nextFire < sys.getTime() ) {
            baseFireTime = sys.getTime();
            nextFire = baseFireTime + recycle;

            nextMiniCount = 0;
            nextMiniFire = baseFireTime + getFloatKey( "missile" + ( nextMiniCount + 1 ) + "_delay" );
        }

        if ( nextMiniCount < numMissiles ) {
            if( nextMiniFire < sys.getTime() ) {

                Launch( nextMiniCount );

                nextMiniCount++;
                nextMiniFire = baseFireTime + getFloatKey( "missile" + ( nextMiniCount + 1 ) + "_delay" );
            }
        }

        sys.waitFrame();
    }
}

void deployable_artillery::ServerFiring() {
    float count            = fireCount;
    float nextMiniFire    = 0;
    float nextMiniCount = 0;
    float baseFireTime    = 0;

    fireSupportState = MPS_FIRING;

    nextFire = sys.getTime() + 1.f;

    if ( projectileForEffectIndex >= 0 ) {
        LaunchForEffect();
        sys.wait( getFloatKey( "foreffect_wait" ) );
    }

    objManager.PlaySoundForPlayer( getKey( "snd_firing" ), owner );

    while( true ) {
        if ( disabledState ) {
            break;
        }

        if ( nextFire < sys.getTime() ) {
            baseFireTime = sys.getTime();
            nextFire = baseFireTime + recycle;
            count = count - 1;
            if ( count < 0 ) {
                break;
            }

            nextMiniCount = 0;
            nextMiniFire = baseFireTime + getFloatKey( "missile" + ( nextMiniCount + 1 ) + "_delay" );
        }

        if ( nextMiniCount < numMissiles ) {
            if ( nextMiniFire != 0 && nextMiniFire < sys.getTime() ) {

                Launch( nextMiniCount );

                nextMiniCount++;
                nextMiniFire = baseFireTime + getFloatKey( "missile" + ( nextMiniCount + 1 ) + "_delay" );
            }
        }

        sys.waitFrame();
    }

    nextFire = 0;

    thread ReloadThread( reloadWait );

    setState( "ServerIdle" );
}

// ==========================================
// Utility Funcs
// ==========================================

string deployable_artillery::MuzzleForMissile( float missileIndex ) {
    return getKey( "missile" + ( missileIndex + 1 ) + "_barrel" );
}

void deployable_artillery::FireMissile( float missileIndex ) {
    vector org;

    org = getJointPos( jointPitch ) + firingOffset + ( getWorldAxis( 1 ) * GetMissileSideOffset( missileIndex ) );

    launchMissileSimple( owner, self, targetPlayerEnemy, projectileIndex, -1, spread, org, firingVelocity );

    playEffect( "fx_fire", MuzzleForMissile( missileIndex ), 0 );
}

void deployable_artillery::Launch( float missileIndex ) {
    string anim;
    float channel;

    FireMissile( missileIndex );

    anim = getKey( "missile" + ( missileIndex + 1 ) + "_anim" );
    if ( anim != "" ) {
        channel = getIntKey( "missile" + ( missileIndex + 1 ) + "_channel" );

        playAnim( channel, anim );
    }
}

void deployable_artillery::LaunchForEffect() {
    string anim;
    float channel;
    vector org;

    org = getJointPos( jointPitch ) + firingOffset + ( getWorldAxis( 1 ) * GetMissileSideOffset( 0 ) );

    launchMissileSimple( owner, self, $null_entity, projectileForEffectIndex, -1, 0.0, org, firingVelocity );

//	objManager.PlaySoundForPlayer( getKey( "snd_effect" ), owner );

    playEffect( "fx_fire", MuzzleForMissile( 0 ), 0 );

    anim = getKey( "missile1_anim" );
    if ( anim != "" ) {
        channel = getIntKey( "missile1_channel" );
        playAnim( channel, anim );
    }
}

// ==========================================
// ==========================================

boolean deployable_artillery::UpdateYaw() {
    float ang;
    float maxTurn;
    float frac;

    if ( idealYaw == currentYaw ) {
        return true;
    }

    ang = sys.angleNormalize180( idealYaw - currentYaw );
    frac = sys.sin( sys.fabs( ang / sys.angleNormalize180( idealYaw - oldIdealYaw ) ) * 180.f );

    maxTurn = ( minYawRate + ( maxYawRate - minYawRate ) * frac ) * sys.getFrameTime();

    if ( ang < -maxTurn ) {
        currentYaw = currentYaw - maxTurn;
    } else if ( ang > maxTurn ) {
        currentYaw = currentYaw + maxTurn;
    } else {
        currentYaw = idealYaw;
    }

    return false;
}

boolean deployable_artillery::UpdatePitch() {
    float ang;
    float maxTurn;
    float frac;

    if ( idealPitch == currentPitch ) {
        return true;
    }

    ang = sys.angleNormalize180( idealPitch - currentPitch );
    frac = sys.sin( sys.fabs( ang / sys.angleNormalize180( idealPitch - oldIdealPitch ) ) * 180.f );

    maxTurn = ( minPitchRate + ( maxPitchRate - minPitchRate ) * frac ) * sys.getFrameTime();

    if ( ang < -maxTurn ) {
        currentPitch = currentPitch - maxTurn;
    } else if ( ang > maxTurn ) {
        currentPitch = currentPitch + maxTurn;
    } else {
        currentPitch = idealPitch;
    }

    return false;
}

void deployable_artillery::TurnToward( float yaw, float pitch ) {
    oldIdealYaw        = currentYaw;
    oldIdealPitch    = currentPitch;
    idealYaw        = sys.angleNormalize180( yaw );
    idealPitch        = sys.angleNormalize180( pitch );
    anglesLocked    = false;
}

void deployable_artillery::ResetAngles() {
    TurnToward( 0, 0 );
}

void deployable_artillery::vTargetSetTarget( vector targetPos, entity targetEnt ) {
    float firingPitch;
    float t;
    vector gravity;
    vector velocity;
    vector temp;
    float i;

    if( !CalcTargetAngles( targetPos ) ) {
        return;
    }

    gravity_x = 0;
    gravity_y = 0;
    gravity_z = -1066;

    firingPitch = targetPitch - barrelPitch;

    for ( i = 0; i < numMissiles; i++ ) {

        firingVelocity = targetDiff * ( sys.cos( targetPitch ) * missileSpeed );
        firingVelocity_z = sys.sin( targetPitch ) * missileSpeed;

        t = GetMissileBarrelLength( i ) / missileSpeed;

        gravity = gravity * t * t * 0.5f;

        temp = firingVelocity * t;

        firingOffset = temp + gravity;
        firingVelocity = firingVelocity + ( gravity * t );
    }

    TurnToward( targetYaw - baseYaw, -firingPitch );

    targetPlayerEnemy = owner.getEnemy();
    owner.lastValidTarget = targetPos;
    targetLocation = targetPos;

    Base_TargetSetTarget( targetPos, targetEnt );

    CreateFiringDecal();

    setState( "ServerAiming" );
}

boolean deployable_artillery::vTargetGetValid( vector targetPos ) {
    if ( !InRange( targetPos ) ) {
        return 0;
    }

    return CalcTargetAngles( targetPos );
}

boolean deployable_artillery::CalcTargetAngles( vector targetPos ) {
    vector barrelOrg;
    vector temp;
    float diffY;
    float diffX;
    float rootA;
    float count;
    float root1;
    float root2;

    barrelOrg = getJointPos( jointPitch );

    targetDiff = targetPos - barrelOrg;

    targetYaw = sys.angleNormalize180( sys.atan2( targetDiff_y, targetDiff_x ) );

    temp = targetDiff;

    diffY = temp_z;
    temp_z = 0.f;
    targetDiff = sys.vecNormalize( temp );
    diffX = sys.vecLength( temp );

    // FIXME: Expose default gravity
    rootA = ( 1066 * diffX * diffX ) / ( 2 * missileSpeed * missileSpeed );

    count = sys.solveRoots( rootA, -diffX, rootA + diffY );
    if ( count == 0 ) {
        return false;
    }

    if ( count == 1 ) {
        targetPitch = sys.atan( sys.getRoot( 0 ) );
        return PitchValid( targetPitch );
    }

    targetPitch = sys.atan( sys.getRoot( 0 ) );
    if ( PitchValid( targetPitch ) ) {
        return true;
    }

    targetPitch = sys.atan( sys.getRoot( 1 ) );
    return PitchValid( targetPitch );
}

boolean deployable_artillery::PitchValid( float pitch ) {
    return pitch < maxPitch && pitch > minPitch;
}

boolean    deployable_artillery::InRange( vector targetPos ) {    
    return true;
}

boolean deployable_artillery::vTargetPlayerEligible( entity p ) {
    if ( disabledState || !finishedDeploying ) {
        return 0.f;
    }

    return 1.f;
}

target_marker deployable_artillery::vCreateTargetMarker() {
    string entityDef = getKey( "def_marker" );
    if ( entityDef == "" ) {
        return $null;
    }

    generic_target_marker marker = new generic_target_marker;
    marker.Init( self, entityDef, getKey( "mtr_marker_cm" ), getFloatKey( "cm_marker_sort" ) );
    if ( vGetFireSupportMode() == TARGET_ROCKETS ) {
        marker.SetLocalOnly( true );
    }
    return marker;
}

void deployable_artillery::ClearFiringDecal() {
    if ( firingDecal != $null_entity ) {
        delete firingDecal;
    }

    if ( firingMarker != $null_entity ) {
        thread G_DelayRemoveEntity( firingMarker, 5.f );
        firingMarker = $null_entity;
    }
}

void deployable_artillery::CreateFiringDecal() {
    if ( !sys.isClient() ) {
        firingMarker = G_CreateFiringMarker( self, firingMarker, targetLocation );
    }

    if ( vGetFireSupportMode() == TARGET_ROCKETS ) {
        return;
    }

    entity p = sys.getLocalPlayer();
    if ( p == $null_entity ) {
        return;
    }

    if ( getEntityAllegiance( p ) != TA_FRIEND ) {
        return;
    }

    if ( firingDecal == $null_entity ) {
        firingDecal = vCreateTargetMarker();
    }

    if ( firingDecal != $null_entity ) { 
        firingDecal.SetTargetPosition( targetLocation );
    }
}


object deployable_rockets : deployable_artillery {
    float    vGetFireSupportMode();
}

float deployable_rockets::vGetFireSupportMode() {
    return TARGET_ROCKETS;
}