//======================================================================================================================
//  NicePack / NiceBullet
//======================================================================================================================
//  Bullet class that's supposed to take care of all damage-dealing projectile needs.
//  Functionality:
//      - Simulation of both linear and piece-wise motion
//      - Collision detection that can be handled through the adapter class
//======================================================================================================================
//  'Nice pack' source
//  Do whatever the fuck you want with it
//  Author: dkanus
//  E-mail: dkanus@gmail.com
//======================================================================================================================
class NiceBullet extends Actor;
//  Link to interaction with the server
var NiceReplicationInfo niceRI;
//  Controller of our instigator
var NicePlayerController nicePlayer;
//  Controller of local player
var NicePlayerController localPlayer;
//  Link to our mutator
var NicePack niceMutator;

//======================================================================================================================
//  Battle bullet characteristic
var float                       charOrigDamage;
var float                       charDamage;
var float                       decapMod;
var float                       incapMod;
var int                         charPenetrationCount;
var float                       charMomentumTransfer;
var class<NiceWeaponDamageType> charDamageType;
var class<NiceWeaponDamageType> charExplosionDamageType;
var float                       charExplosionDamage;
var float                       charExplosionRadius;
var float                       charExplosionExponent;
var float                       charExplosionMomentum;
var bool                        charIsDud;
var float                       charFuseTime;
var bool                        charExplodeOnFuse;
var bool                        charExplodeOnPawnHit;
var bool                        charExplodeOnWallHit;
var bool                        charAffectedByScream;
var float                       charMinExplosionDist;
var bool                        charWasHipFired;
var bool                        charCausePain;
var bool                        charIsSticky;
var float                       charContiniousBonus;
var bool                        bAlreadyHitZed;
var NiceWeapon                  sourceWeapon;
var NiceMonster                 lockonZed;
var float                       lockonTime;
var float                       bounceHeadMod;
var int                         insideBouncesLeft;
var bool                        bGrazing;

//======================================================================================================================
//  Sticky projectile-related variables
var bool                            bStuck, bUseBone, bStuckToHead;
var name                            stuckBone;
var int                             stuckID;
//  Data about explosive characteristics that must be transfered after projectile sticks on something
struct ExplosionData{
    var Pawn                        instigator;
    var NiceWeapon                  sourceWeapon;
    var class<NiceBullet>           bulletClass;
    var class<NiceWeaponDamageType> explosionDamageType;
    var float                       explosionDamage;
    var float                       explosionRadius;
    var float                       explosionExponent;
    var float                       explosionMomentum;
    var float                       fuseTime;
    var bool                        explodeOnFuse;
    var bool                        affectedByScream;
    var bool                        stuckToHead;
};

//======================================================================================================================
//  Temporary variables that either need to be moved into config or generalized later
//  How often trajectory is allowed to change direction?
var const float trajUpdFreq;
//  How much tracing cycles to endure before declaring an infinite cycle?
var const int   maxTraceCycles;
var bool        bCanAngleDamage;

//======================================================================================================================
//  State variables
//  Indicates that all necessary values were recorded and we can process this bullet normally
var bool    bInitFinished;
var bool    bInitFinishDetected;
//  Disables all the interaction of this bullet with the world and removes it / marks it for removal
var bool    bBulletDead;
var bool    bGhost;

//======================================================================================================================
//  Collision management
//  Describes an actor that we don't wish to collide with
struct  IgnoreEntry{
    var Actor   ignored;
    //  Set to true when 3rd party already disabled this actor before we had the chance
    //  Used to avoid re-enabling it later
    var bool    bExtDisabled;
};
var array<IgnoreEntry>  ignoredActors;
//  'true' if we're enforcing our collision rules on actors to ignore them
var bool                bIgnoreIsActive;

//======================================================================================================================
//  Movement
//  If 'true' disables any modifications to the bullet's movement, making it travel in a simple, linear path
var bool    bDisableComplexMovement;
//  Linear motion
var float   movementSpeed;
var Vector  movementDirection;
//  Added vector acceleration
var Vector  movementAcceleration;
var bool    bShouldBounce;
//  Amount of time our bullet should fall down after hitting a wall
var float   movementFallTime;

//======================================================================================================================
//  Path building
//  We will be building a piecewise linear path for projectiles, where each linear segment should be passable by
//  projectile in time 'trajUpdFreq'.
//  By changing trajectory in only preset point allow client to emulate non-linear paths,
//  while keeping them more or less independent from the frame rate.
//  Start and End point of the current linear segment
var Vector  pathSegmentS, pathSegmentE;
//  Point in the segment, at which we've stopped after last movement
var Vector  shiftPoint;
//  The part of current segment that we've already covered, changes from 0.0 to 1.0.
//  Values above 1.0 indicate that segment was finished and we need to build another one.
//  Values below 0.0 indicate that no segment has yet been built.
var float   finishedSegmentPart;

//======================================================================================================================
//  Visual effects
var class<Emitter>  trailClass;
var class<xEmitter> trailXClass;
var Emitter         bulletTrail;
var xEmitter        bulletXTrail;
//  Describes effect that projectile should produce on hit
struct  ImpactEffect{
    //  Is this effect too important to cut it due to effect limit?
    var bool                bImportanEffect;
    //  Should we play classic KF's hit effect ('ROBulletHitEffect')?
    var bool                bPlayROEffect;
    //  Decal to spawn; null to skip
    var class<Projector>    decalClass;
    //  Emitter to spawn; null to skip
    var class<Emitter>      emitterClass;
    //  How much back (against direction of the shot) should we spawn emitter? Can be used to avoid clipping with walls
    var float               emitterShiftWall;   // Shift for wall-hits
    var float               emitterShiftPawn;   // Shift for pawn-hits
    //  Impact noise parameters
    var Sound               noise;
    var string              noiseRef;           // Reference to 'Sound' to allow dynamic resource allocation
    var float               noiseVolume;
};
var ImpactEffect    regularImpact;
var ImpactEffect    explosionImpact;
var ImpactEffect    disintegrationImpact;
var bool            bGenRegEffectOnPawn;
var bool    bShakeViewOnExplosion;
var Vector  shakeRotMag;        // how far to rot view
var Vector  shakeRotRate;       // how fast to rot view
var float   shakeRotTime;       // how much time to rot the instigator's view
var Vector  shakeOffsetMag;     // max view offset vertically
var Vector  shakeOffsetRate;    // how fast to offset view vertically
var float   shakeOffsetTime;    // how much time to offset view
var float   shakeRadiusMult;

//======================================================================================================================
//  References
//  References to allow pre-loading of some resource objects, declared in parent classes
var string meshRef;
var string staticMeshRef;
var string ambientSoundRef;

//======================================================================================================================
//  Functions
static function PreloadAssets(){
    if(default.ambientSound == none && default.ambientSoundRef != "")
       default.ambientSound = sound(DynamicLoadObject(default.ambientSoundRef, class'Sound', true));
    if(default.staticMesh == none && default.staticMeshRef != "")
       UpdateDefaultStaticMesh(StaticMesh(DynamicLoadObject(default.staticMeshRef, class'StaticMesh', true)));
    if(default.mesh == none && default.meshRef != "")
       UpdateDefaultMesh(Mesh(DynamicLoadObject(default.meshRef, class'Mesh', true)));
    if(default.regularImpact.noise == none && default.regularImpact.noiseRef != "")
       default.regularImpact.noise =
           sound(DynamicLoadObject(default.regularImpact.noiseRef, class'Sound', true));
    if(default.explosionImpact.noise == none && default.explosionImpact.noiseRef != "")
       default.explosionImpact.noise =
           sound(DynamicLoadObject(default.explosionImpact.noiseRef, class'Sound', true));
    if(default.disintegrationImpact.noise == none && default.disintegrationImpact.noiseRef != "")
       default.disintegrationImpact.noise =
           sound(DynamicLoadObject(default.disintegrationImpact.noiseRef, class'Sound', true));
}
static function bool UnloadAssets(){
    default.AmbientSound = none;
    UpdateDefaultStaticMesh(none);
    UpdateDefaultMesh(none);
    default.regularImpact.noise = none;
    default.explosionImpact.noise = none;
    default.disintegrationImpact.noise = none;
    return true;
}
function PostBeginPlay(){
    super.PostBeginPlay();
    bounceHeadMod   = 1.0;
}
function UpdateTrails(){
    local Actor trailBase;
    // Do nothing on dedicated server
    if(Level.NetMode == NM_DedicatedServer)
       return;
    // Spawn necessary trails first
    if(trailClass != none && bulletTrail == none)
       bulletTrail = Spawn(trailClass, self);
    if(trailXClass != none && bulletXTrail == none)
       bulletXTrail = Spawn(trailXClass, self);
    // Handle positioning differently for stuck and regular projectiles
    if(bStuck && base != none){
       if(bUseBone){
           if(bulletTrail != none){
               bulletTrail.SetBase(base);
               base.AttachToBone(bulletTrail, stuckBone);
               bulletTrail.SetRelativeLocation(relativeLocation);
               bulletTrail.SetRelativeRotation(relativeRotation);
           }
           if(bulletXTrail != none){
               bulletXTrail.SetBase(base);
               base.AttachToBone(bulletTrail, stuckBone);
               bulletXTrail.SetRelativeLocation(relativeLocation);
               bulletXTrail.SetRelativeRotation(relativeRotation);
           }
       }
    }
    else
       trailBase = self;
    // Update lifetime and base (latter is for non-bone attachments only)
    if(bulletTrail != none){
       if(trailBase != none)
           bulletTrail.SetBase(trailBase);
       bulletTrail.lifespan = lifeSpan;
    }
    if(bulletXTrail != none){
       if(trailBase != none)
           bulletXTrail.SetBase(trailBase);
       bulletXTrail.lifespan = lifeSpan;
    }
}
function ResetPathBuilding(){
    finishedSegmentPart = -1.0;
    shiftPoint = location;
}
//  Resets default values for this bullet.
//  Must be called before each new use of a bullet.
function Renew(){
    bInitFinished       = false;
    bBulletDead         = false;
    bCanAngleDamage     = true;
    SoundVolume         = default.SoundVolume;
    decapMod = 1.0f;
    incapMod = 1.0f;
    ResetIgnoreList();
    ResetPathBuilding();
}
simulated function Tick(float delta){
    super.Tick(delta);
    if(localPlayer == none)
       localPlayer = NicePlayerController(Level.GetLocalPlayerController());
    if(charFuseTime > 0){
       charFuseTime -= delta;
       if(charFuseTime < 0){
           if(charExplodeOnFuse && !charIsDud){
               GenerateImpactEffects(explosionImpact, location, movementDirection);
               if(bStuck)
                   class'NiceBulletAdapter'.static.Explode(self, niceRI, location, base);
               else
                   class'NiceBulletAdapter'.static.Explode(self, niceRI, location);
           }
           if(!charExplodeOnFuse)
               GenerateImpactEffects(disintegrationImpact, location, movementDirection);
           KillBullet();
       }
    }
    if(bInitFinished && !bInitFinishDetected){
       bInitFinishDetected = true;
       UpdateTrails();
    }
    if(bInitFinished && !bBulletDead && !bStuck)
       DoProcessMovement(delta);
    if(bInitFinished && bStuck){
       if(base == none || (KFMonster(base) != none && KFMonster(base).health <= 0))
           nicePlayer.ExplodeStuckBullet(stuckID);
    }
}
//  Extracts pawn actor from it's auxiliary collision
//  @param  other   Actor we collided with
//  @return         Pawn we're interested in
function Actor GetMainActor(Actor other){
    if(other == none)
       return none;
    // Try owner
    if( KFPawn(other) == none && KFMonster(other) == none
    &&  (KFPawn(other.owner) != none || KFMonster(other.owner) != none) )
       other = other.owner;
    // Try base
    if( KFPawn(other) == none && KFMonster(other) == none
    &&  (KFPawn(other.base) != none || KFMonster(other.base) != none) )
       other = other.base;
    return other;
}
//  Returns 'true' if passed actor is either world geometry, 'Level' itself or nothing ('none')
//  Neither of these related to pawn damage dealing
function bool IsLevelActor(Actor other){
    if(other == none)
       return true;
    return (other.bWorldGeometry || other == Level);
}
//  Adds given actor and every colliding object connected to it to ignore list
//  Removes their collision in case ignore is active (see 'bIgnoreIsActive')
function TotalIgnore(Actor other){
    // These mark what objects, associated with 'other' we also need to ignore
    local KFPawn    pawnOther;
    local KFMonster zedOther;
    if(other == none)
       return;
    // Try to find main actor as KFPawn
    pawnOther = KFPawn(other);
    if(pawnOther == none)
       pawnOther = KFPawn(other.base);
    if(pawnOther == none)
       pawnOther = KFPawn(other.owner);
    // Try to find main actor as KFMonster
    zedOther = KFMonster(other);
    if(zedOther == none)
       zedOther = KFMonster(other.base);
    if(zedOther == none)
       zedOther = KFMonster(other.owner);
    // Ignore everything that's associated with this actor and can have collision
    IgnoreActor(other);
    IgnoreActor(other.base);
    IgnoreActor(other.owner);
    if(pawnOther != none)
       IgnoreActor(pawnOther.AuxCollisionCylinder);
    if(zedOther != none)
       IgnoreActor(zedOther.MyExtCollision);
}
//  Adds a given actor to ignore list and removes it's collision in case ignore is active (see 'bIgnoreIsActive')
function IgnoreActor(Actor other){
    local int           i;
    local IgnoreEntry   newIgnoredEntry;
    // Check if that's a non-level actor and not already on the list
    if(IsLevelActor(other))
       return;
    for(i = 0;i < ignoredActors.Length;i ++)
       if(ignoredActors[i].ignored == other)
           return;
    // Add actor to the ignore list & disable collision if needed
    if(other != none){
       // Make entry
       newIgnoredEntry.ignored         = other;
       newIgnoredEntry.bExtDisabled    = !other.bCollideActors;
       // Add and activate it
       ignoredActors[ignoredActors.Length] = newIgnoredEntry;
       if(bIgnoreIsActive)
           other.SetCollision(false);
    }
}
//  Restores ignored state of the actors and zeroes our ignored arrays
function ResetIgnoreList(){
    SetIgnoreActive(false);
    ignoredActors.Length = 0;
}
//  Activates/deactivates ignore for actors on the ignore list.
//  Ignore deactivation doesn't restore collision if actor was set to not collide prior most recent ignore activation.
//  Activating ignore when it's already active does nothing; same with deactivation.
//  Ignore deactivation is supposed to be used in the same function call in which activation took place before.
function SetIgnoreActive(bool bActive){
    local int i;
    // Do nothing if we're already in a correct state
    if(bActive == bIgnoreIsActive)
       return;
    // Change ignore state & disable collision for ignored actors
    bIgnoreIsActive = bActive;
    for(i = 0;i < ignoredActors.Length;i ++)
       if(ignoredActors[i].ignored != none){
           // Mark actors that were set to not collide before activation
           if(bActive && !ignoredActors[i].ignored.bCollideActors)
               ignoredActors[i].bExtDisabled = true;
           // Change collision for actors that weren't externally modified
           if(!ignoredActors[i].bExtDisabled)
               ignoredActors[i].ignored.SetCollision(!bActive);
           // After we deactivated our rules - forget about external modifications
           if(!bActive)
               ignoredActors[i].bExtDisabled = false;
       }
}
function SetHumanPawnCollision(bool bEnable){
    local int i;
    if(niceMutator == none)
       niceMutator = class'NicePack'.static.Myself(Level);
    for(i = 0;i < niceMutator.recordedHumanPawns.Length;i ++)
       if(niceMutator.recordedHumanPawns[i] != none)
           niceMutator.recordedHumanPawns[i].bBlockHitPointTraces = bEnable;
}
function float CheckHeadshot(KFMonster kfZed, Vector hitLocation, Vector hitDirection){
    local float                     hsMod;
    local float                     precision;
    local bool                      bIsShotgunBullet;
    local NiceMonster               niceZed;
    local KFPlayerReplicationInfo   KFPRI;
    local class<NiceVeterancyTypes> niceVet;
    niceZed = NiceMonster(kfZed);
    hitDirection = Normal(hitDirection);
    bIsShotgunBullet = ClassIsChildOf(charDamageType, class'NiceDamageTypeVetEnforcer');
    if(niceZed != none){
       hsMod = bounceHeadMod;    // NICETODO: Add bounce and perk and damage type head-shot zones bonuses
       hsMod *= charDamageType.default.headSizeModifier;
       hsMod *= bounceHeadMod;
       if(nicePlayer != none)
           KFPRI = KFPlayerReplicationInfo(nicePlayer.PlayerReplicationInfo);
       if(KFPRI != none)
           niceVet = class<NiceVeterancyTypes>(KFPRI.ClientVeteranSkill);
       if(niceVet != none)
           hsMod *= niceVet.static.GetHeadshotCheckMultiplier(KFPRI, charDamageType);
       precision = niceZed.IsHeadshotClient(hitLocation, hitDirection, niceZed.clientHeadshotScale * hsMod);
       if(precision <= 0.0 && bIsShotgunBullet && nicePlayer != none && class'NiceVeterancyTypes'.static.hasSkill(nicePlayer, class'NiceSkillSupportGraze')){
           bGrazing = true;
           hsMod *= class'NiceSkillSupportGraze'.default.hsBonusZoneMult;
           precision = niceZed.IsHeadshotClient(hitLocation, hitDirection, niceZed.clientHeadshotScale * hsMod);
       }
       return precision;
    }
    else{
       if(kfZed.IsHeadShot(hitLocation, hitDirection, 1.0))
           return 1.0;
       else
           return 0.0;
    }
}
//  Makes bullet trace a directed line segment given by start and end points.
//  All traced actors and geometry are then properly affected by corresponding 'HandleHitPawn', 'HandleHitZed' and
//  'HandleHitWall' functions.
//  Might have to do several traces in case it either hits a (several) target(s)
function DoTraceLine(Vector lineStart, Vector lineEnd){
    local float         headshotLevel;
    // Amount of tracing iterations we had to do
    local int           iterationCount;
    // Direction and length of traced line
    local Vector        lineDirection;
    // Auxiliary variables for retrieving results of tracing
    local Vector        hitLocation, hitNormal;
    local Actor         tracedActor;
    local array<int>    hitPoints;
    local KFMonster     tracedZed;
    local KFPawn        tracedPawn;
    lineDirection = (lineEnd - lineStart);
    lineDirection = (lineDirection) / VSize(lineDirection);
    // Do not trace for disabled bullets and prevent infinite loops
    while(!bBulletDead && iterationCount < maxTraceCycles){
       iterationCount ++;
       // Trace next object
       if(!bGhost || localPlayer == none || localPlayer.tracesThisTick <= localPlayer.tracesPerTickLimit){
           if(Instigator != none)
               tracedActor = Instigator.Trace(hitLocation, hitNormal, lineEnd, lineStart, true);
           else
               tracedActor = none;
           localPlayer.tracesThisTick ++;
       }
       else
           tracedActor = none;
       if(charAffectedByScream && !charIsDud && localPlayer != none && localPlayer.localCollisionManager != none && localPlayer.localCollisionManager.IsCollidingWithAnything(lineStart, lineEnd))
           HandleScream(lineStart, lineDirection);
       if(tracedActor != none && IsLevelActor(tracedActor)){
           HandleHitWall(tracedActor, hitLocation, hitNormal);
           break;
       }
       else{
           TotalIgnore(tracedActor);
           tracedActor = GetMainActor(tracedActor);
       }

       // If tracing between current trace points haven't found anything and tracing step is less than segment's length
       // -- shift tracing bounds
       if(tracedActor == none)
           return;

       // First, try to handle pawn like a zed; if fails, - try to handle it like 'KFPawn'
       tracedZed = KFMonster(tracedActor);
       tracedPawn = KFPawn(tracedActor);
       if(tracedPawn != none && NiceHumanPawn(instigator) != none &&
           (NiceHumanPawn(instigator).ffScale <= 0 && NiceMedicProjectile(self) == none) )
           continue;
       if(tracedZed != none){
           if(tracedZed.Health > 0){
               headshotLevel = CheckHeadshot(tracedZed, hitLocation, lineDirection);
               HandleHitZed(tracedZed, hitLocation, lineDirection, headshotLevel);
           }
       }
       else if(tracedPawn != none && tracedPawn.Health > 0){
           if(tracedPawn.Health > 0)
               HandleHitPawn(tracedPawn, hitLocation, lineDirection, hitPoints);
       }
       else
           HandleHitWall(tracedActor, hitLocation, hitNormal);
    }
}
//  Replaces current path segment with the next one.
//  Doesn't check whether or not we've finished with the current segment.
function BuildNextPathSegment(){
    // Only set start point to our location when we build path segment for the first time
    // After that we can't even assume that bullet is exactly in the 'pathSegmentE' point
    if(finishedSegmentPart < 0.0)
       pathSegmentS = Location;
    else
       pathSegmentS = pathSegmentE;
    movementDirection += (movementAcceleration * trajUpdFreq) / movementSpeed;
    pathSegmentE = pathSegmentS + movementDirection * movementSpeed * trajUpdFreq;
    finishedSegmentPart = 0.0;
    shiftPoint = pathSegmentS;
}
//  Updates 'shiftPoint' to the next bullet position in current segment.
//  Does nothing if current segment is finished or no segment was built at all.
//  @param  delta   Amount of time bullet has to move through the segment.
//  @return         Amount of time left for bullet to move after this segment
function float ShiftInSegment(float delta){
    // Time that bullet still has available to move after this segment
    local float remainingTime;
    // Part of segment we can pass in a given time
    local float segmentPartWeCanPass;
    // Exit if there's no segment in progress
    if(finishedSegmentPart < 0.0 || finishedSegmentPart > 1.0)
       return delta;
    // [movementSpeed * delta] / [movementSpeed * trajUpdFreq] = [delta / trajUpdFreq]
    segmentPartWeCanPass = delta / trajUpdFreq;
    // If we can move through the rest of the segment - move to end point and mark it finished
    if(segmentPartWeCanPass >= (1.0 - finishedSegmentPart)){
       remainingTime = delta - (1.0 - finishedSegmentPart) * trajUpdFreq;
       finishedSegmentPart = 1.1;
       shiftPoint = pathSegmentE;
    }
    // Otherwise compute new 'shiftPoint' normally
    else{
       remainingTime = 0.0;
       finishedSegmentPart += (delta / trajUpdFreq);
       shiftPoint = pathSegmentS + movementDirection * movementSpeed * trajUpdFreq * finishedSegmentPart;
    }
    return remainingTime;
}
//  Moves bullet according to settings and decides when and how much tracing should it do.
//  @param  delta   Amount of time passed after previous bullet movement
function DoProcessMovement(float delta){
    local Vector    tempVect;
    SetIgnoreActive(true);
    //SetHumanPawnCollision(true);
    //  Simple linear movement
    if(bDisableComplexMovement){
       // Use 'traceStart' as a shift variable here
       // Naming is bad in this case, but it avoids 
       tempVect = movementDirection * movementSpeed * delta;
       DoTraceLine(location, location + tempVect);
       Move(tempVect);
       // Reset path building
       // If in future complex movement would be re-enabled, - we want to set first point of the path to
       // the location of bullet at a time and not use outdated information.
       finishedSegmentPart = -1.0;
    }
    //  Non-linear movement support
    else{
       while(delta > 0.0){
           if(finishedSegmentPart < 0.0 || finishedSegmentPart > 1.0)
               BuildNextPathSegment();
           // Remember current 'shiftPoint'. That's where we stopped tracing last time and where we must resume.
           tempVect = shiftPoint;
           // Update 'shiftPoint' (bullet position)
           // and update how much time we've got left after we wasted some to move.
           delta = ShiftInSegment(delta);
           // Trace between end point of previous tracing and end point of the new one.
           DoTraceLine(tempVect, shiftPoint);
       }
       tempVect = shiftPoint - location;
       Move(shiftPoint - location);
    }
    SetRotation(Rotator(movementDirection));
    if(charMinExplosionDist > 0)
       charMinExplosionDist -= VSize(tempVect);
    SetIgnoreActive(false);
    //SetHumanPawnCollision(false);
}
function Stick(Actor target, Vector hitLocation){
    local NiceMonster   targetZed;
    local name          boneStick;
    local float         distToBone;
    local float         t;
    local Vector        boneStrickOrig;
    local ExplosionData expData;
    if(bGhost)
       return;
    expData.explosionDamageType = charExplosionDamageType;
    expData.explosionDamage = charExplosionDamage;
    expData.explosionRadius = charExplosionRadius;
    expData.explosionExponent = charExplosionExponent;
    expData.explosionMomentum = charExplosionMomentum;
    expData.fuseTime = charFuseTime;
    expData.explodeOnFuse = charExplodeOnFuse;
    expData.affectedByScream = charAffectedByScream;
    expData.sourceWeapon = sourceWeapon;
    targetZed = NiceMonster(target);
    if(targetZed == none){
       expData.bulletClass = class;
       expData.instigator = instigator;
       niceRI.ServerStickProjectile(KFHumanPawn(instigator), target, 'None', hitLocation - target.location,
           Rotator(movementDirection), expData);
       class'NiceProjectileSpawner'.static.StickProjectile(KFHumanPawn(instigator), target, 'None',
           hitLocation - target.location, Rotator(movementDirection), expData);
    }
    else{
       expData.bulletClass = class;
       expData.instigator = instigator;
       boneStick = targetZed.GetClosestBone(hitLocation, movementDirection, distToBone);
       if(CheckHeadshot(targetZed, hitLocation, movementDirection) > 0.0)
           boneStick = targetZed.HeadBone;
       if(boneStick == targetZed.HeadBone)
           expData.stuckToHead = true;
       boneStrickOrig = targetZed.GetBoneCoords(boneStick).origin;
       t = movementDirection.x * (boneStrickOrig.x - hitLocation.x) +
           movementDirection.y * (boneStrickOrig.y - hitLocation.y) +
           movementDirection.z * (boneStrickOrig.z - hitLocation.z);
       t /= VSizeSquared(movementDirection);
       t *= 0.5;
       hitLocation = hitLocation + t * movementDirection;
       niceRI.ServerStickProjectile(KFHumanPawn(instigator), targetZed, boneStick,
           hitLocation - boneStrickOrig, Rotator(movementDirection), expData);
       class'NiceProjectileSpawner'.static.StickProjectile(KFHumanPawn(instigator), targetZed, boneStick,
           hitLocation - boneStrickOrig, Rotator(movementDirection), expData);
    }
    KillBullet();
}
function DoExplode(Vector explLocation, Vector impactNormal){
    if(charIsDud)
       return;
    if(bStuck)
       class'NiceBulletAdapter'.static.Explode(self, niceRI, explLocation, base);
    else
       class'NiceBulletAdapter'.static.Explode(self, niceRI, explLocation);
    GenerateImpactEffects(explosionImpact, explLocation, impactNormal, true, true);
    if(bShakeViewOnExplosion)
       ShakeView(explLocation);
    KillBullet();
}
function HandleHitWall(Actor wall, Vector hitLocation, Vector hitNormal){
    local bool          bBulletTooWeak;
    if(charExplodeOnWallHit && !charIsDud && charMinExplosionDist <= 0.0){
       DoExplode(hitLocation, hitNormal);
       return;
    }
    else{
       class'NiceBulletAdapter'.static.HitWall(self, niceRI, wall, hitLocation, hitNormal);
       GenerateImpactEffects(regularImpact, hitLocation, hitNormal, true, true);
       if(charIsSticky)
           Stick(wall, hitLocation);
    }
    if(bShouldBounce && !bDisableComplexMovement){
       movementDirection = (movementDirection - 2.0 * hitNormal * (movementDirection dot hitNormal));
       bBulletTooWeak = !class'NiceBulletAdapter'.static.ZedPenetration(charDamage, self, none, false, false);
       charPenetrationCount += 1;
       ResetPathBuilding();
       ResetIgnoreList();
       bounceHeadMod *= 2;
    }
    else if(movementFallTime > 0.0){
       charIsDud = true;
       lifeSpan = movementFallTime;
       movementFallTime = 0.0;
       movementDirection = vect(0,0,0);
       ResetPathBuilding();
       ResetIgnoreList();
    }
    else
       bBulletTooWeak = true;
    if(bBulletTooWeak)
       KillBullet();
}
function HandleHitPawn(KFPawn hitPawn, Vector hitLocation, Vector hitDirection, array<int> hitPoints){
    if(charExplodeOnPawnHit && !charIsDud && charMinExplosionDist <= 0.0){
       DoExplode(hitLocation, hitDirection);
       GenerateImpactEffects(explosionImpact, hitLocation, hitDirection);
       return;
    }
    else{
       class'NiceBulletAdapter'.static.HitPawn(self, niceRI, hitPawn, hitLocation, hitDirection, hitPoints);
       if(bGenRegEffectOnPawn)
           GenerateImpactEffects(regularImpact, hitLocation, hitDirection, false, false);
    }
    if(!class'NiceBulletAdapter'.static.ZedPenetration(charDamage, self, none, false, false)){
        charPenetrationCount += 1;
        KillBullet();
    }
}
function HandleHitZed(KFMonster targetZed, Vector hitLocation, Vector hitDirection, float headshotLevel){
    local bool bHitZedCalled;
    if(class'NiceVeterancyTypes'.static.hasSkill(nicePlayer, class'NiceSkillDemoDirectApproach')){
       class'NiceBulletAdapter'.static.HitZed(self, niceRI, targetZed, hitLocation, hitDirection, headshotLevel);
       if(bGenRegEffectOnPawn)
           GenerateImpactEffects(regularImpact, hitLocation, hitDirection, false, false);
       bHitZedCalled = true;
    }
    if(charExplodeOnPawnHit && !charIsDud && charMinExplosionDist <= 0.0){
       class'NiceBulletAdapter'.static.Explode(self, niceRI, hitLocation, targetZed);
       GenerateImpactEffects(explosionImpact, hitLocation, hitDirection);
       if(bShakeViewOnExplosion)
           ShakeView(hitLocation);
       KillBullet();
       return;
    }
    else{
       if(!bHitZedCalled){
           class'NiceBulletAdapter'.static.HitZed(self, niceRI, targetZed, hitLocation, hitDirection, headshotLevel);
           if(bGenRegEffectOnPawn)
               GenerateImpactEffects(regularImpact, hitLocation, hitDirection, false, false);
       }
       bHitZedCalled = true;
       if(!bGhost && !bAlreadyHitZed){
           bAlreadyHitZed = true;
           if(nicePlayer != none && niceRI != none)
               niceRI.ServerJunkieExtension(nicePlayer, headshotLevel > 0.0);
       }
       if(charIsSticky)
           Stick(targetZed, hitLocation);
    }
    if(!class'NiceBulletAdapter'.static.ZedPenetration(charDamage, self, targetZed, (headshotLevel > 0.0), (headshotLevel > charDamageType.default.prReqPrecise))){
        charPenetrationCount += 1;
        KillBullet();
    }
}
function HandleScream(Vector disintegrationLocation, Vector entryDirection){
    if(!charIsDud)
       GenerateImpactEffects(disintegrationImpact, disintegrationLocation, entryDirection);
    class'NiceBulletAdapter'.static.HandleScream(self, niceRI, disintegrationLocation, entryDirection);
}
function GenerateImpactEffects(ImpactEffect effect, Vector hitLocation, Vector hitNormal,
    optional bool bWallImpact, optional bool bGenerateDecal){
    local float                 actualCullDistance;
    local float                 actualImpactShift;
    local bool                  generatedEffect;
    // No need to play visuals on a server, for a dead bullets or in case there's no local player at all
    if(Level.NetMode == NM_DedicatedServer || bBulletDead || localPlayer == none)
       return;
    if(!localPlayer.CanSpawnEffect(bGhost) && !effect.bImportanEffect)
       return;
    // -- Classic effect
    if(effect.bPlayROEffect && !bBulletDead)
       Spawn(class'ROBulletHitEffect',,, hitLocation, rotator(-hitNormal));
    // -- Generate decal
    if(bGenerateDecal && effect.decalClass != none){
       // Find appropriate cull distance for this decal
       actualCullDistance = effect.decalClass.default.cullDistance;
       // Double cull distance if local player is an instigator
       if(instigator != none && localPlayer == instigator.Controller)
           actualCullDistance *= 2;    // NICETODO: magic number
       // Spawn decal
       if(!localPlayer.BeyondViewDistance(hitLocation, actualCullDistance)){
           Spawn(effect.decalClass, self,, hitLocation, rotator(- hitNormal));
           generatedEffect = true;
       }
    }
    // -- Generate custom effect
    if(effect.emitterClass != none && EffectIsRelevant(hitLocation, false)){
       if(bWallImpact)
           actualImpactShift = effect.emitterShiftWall;
       else
           actualImpactShift = effect.emitterShiftPawn;
       Spawn(effect.emitterClass,,, hitLocation - movementDirection * actualImpactShift, rotator(movementDirection));
       generatedEffect = true;
    }
    // -- Generate custom sound
    if(effect.noise != none){
       class'NiceSoundCls'.default.effectSound    = effect.noise;
       class'NiceSoundCls'.default.effectVolume   = effect.noiseVolume;
       Spawn(class'NiceSoundCls',,, hitLocation);
       generatedEffect = true;
    }
    if(generatedEffect)
       localPlayer.AddEffect();
}
function ShakeView(Vector hitLocation){
    local float distance, scale;
    if(nicePlayer == none || shakeRadiusMult < 0.0)
       return;
    distance = VSize(hitLocation - nicePlayer.ViewTarget.Location);
    if(distance < charExplosionRadius * shakeRadiusMult){
       if(distance < charExplosionRadius)
           scale = 1.0;
       else
           scale = (charExplosionRadius * ShakeRadiusMult - distance) / (charExplosionRadius);
       nicePlayer.ShakeView(shakeRotMag*scale, shakeRotRate, shakeRotTime, shakeOffsetMag * scale, shakeOffsetRate, shakeOffsetTime);
    }
}
function KillBullet(){
    local int i;
    if(bulletTrail != none){
       for(i = 0;i < bulletTrail.Emitters.Length;i ++){
           if(bulletTrail.Emitters[i] == none)
               continue;
           bulletTrail.Emitters[i].ParticlesPerSecond          = 0;
           bulletTrail.Emitters[i].InitialParticlesPerSecond   = 0;
           bulletTrail.Emitters[i].RespawnDeadParticles        = false;
       }
       bulletTrail.SetBase(none);
       bulletTrail.AutoDestroy = true;
    }
    if(bulletXTrail != none){
       bulletXTrail.mRegen = false;
       bulletXTrail.LifeSpan = LifeSpan;
    }
    bBulletDead = true;
    bHidden     = true;
    SoundVolume = 0;
    LifeSpan    = FMin(LifeSpan, 0.1);
}
event Destroyed(){
    KillBullet();
}

defaultproperties
{
     insideBouncesLeft=2
     trajUpdFreq=0.100000
     maxTraceCycles=128
     bDisableComplexMovement=True
     trailXClass=Class'KFMod.KFTracer'
     regularImpact=(bPlayROEffect=True)
     StaticMeshRef="kf_generic_sm.Shotgun_Pellet"
     DrawType=DT_StaticMesh
     bAcceptsProjectors=False
     LifeSpan=15.000000
     Texture=Texture'Engine.S_Camera'
     bGameRelevant=True
     bCanBeDamaged=True
     SoundVolume=255
}